/* FIXME: remove these vars */
/* undefine to make plane finding use linear sort (note: really slow) */
-#define USE_HASHING
-#define PLANE_HASHES 8192
+#define USE_HASHING
+#define PLANE_HASHES 8192
-int planehash[ PLANE_HASHES ];
+int planehash[ PLANE_HASHES ];
-int c_boxbevels;
-int c_edgebevels;
-int c_areaportals;
-int c_detail;
-int c_structural;
+int c_boxbevels;
+int c_edgebevels;
+int c_areaportals;
+int c_detail;
+int c_structural;
*/
qboolean PlaneEqual( plane_t *p, vec3_t normal, vec_t dist ){
- float ne, de;
-
-
+ float ne, de;
+
+
/* get local copies */
ne = normalEpsilon;
de = distanceEpsilon;
-
+
/* compare */
// We check equality of each component since we're using '<', not '<='
// (the epsilons may be zero). We want to use '<' intead of '<=' to be
( p->normal[2] == normal[2] || fabs( p->normal[2] - normal[2] ) < ne ) ) {
return qtrue;
}
-
+
/* different */
return qfalse;
}
*/
void AddPlaneToHash( plane_t *p ){
- int hash;
+ int hash;
+
-
hash = ( PLANE_HASHES - 1 ) & (int) fabs( p->dist );
p->hash_chain = planehash[hash];
================
*/
int CreateNewFloatPlane( vec3_t normal, vec_t dist ){
- plane_t *p, temp;
+ plane_t *p, temp;
if ( VectorLength( normal ) < 0.5 ) {
Sys_Printf( "FloatPlane: bad normal\n" );
qboolean SnapNormal( vec3_t normal ){
#if Q3MAP2_EXPERIMENTAL_SNAP_NORMAL_FIX
- int i;
- qboolean adjusted = qfalse;
+ int i;
+ qboolean adjusted = qfalse;
// A change from the original SnapNormal() is that we snap each
// component that's close to 0. So for example if a normal is
// only snapped vectors that were near a perfect axis.
for ( i = 0; i < 3; i++ )
- {
+ {
if ( normal[i] != 0.0 && -normalEpsilon < normal[i] && normal[i] < normalEpsilon ) {
normal[i] = 0.0;
adjusted = qtrue;
}
return qfalse;
#else
- int i;
+ int i;
// I would suggest that you uncomment the following code and look at the
// results:
/*
- Sys_Printf("normalEpsilon is %f\n", normalEpsilon);
- for (i = 0;; i++)
- {
- normal[0] = 1.0;
- normal[1] = 0.0;
- normal[2] = i * 0.000001;
- VectorNormalize(normal, normal);
- if (1.0 - normal[0] >= normalEpsilon) {
- Sys_Printf("(%f %f %f)\n", normal[0], normal[1], normal[2]);
- Error("SnapNormal: test completed");
- }
- }
- */
+ Sys_Printf("normalEpsilon is %f\n", normalEpsilon);
+ for (i = 0;; i++)
+ {
+ normal[0] = 1.0;
+ normal[1] = 0.0;
+ normal[2] = i * 0.000001;
+ VectorNormalize(normal, normal);
+ if (1.0 - normal[0] >= normalEpsilon) {
+ Sys_Printf("(%f %f %f)\n", normal[0], normal[1], normal[2]);
+ Error("SnapNormal: test completed");
+ }
+ }
+ */
// When the normalEpsilon is 0.00001, the loop will break out when normal is
// (0.999990 0.000000 0.004469). In other words, this is the vector closest
// code fix.
for ( i = 0; i < 3; i++ )
- {
+ {
if ( fabs( normal[ i ] - 1 ) < normalEpsilon ) {
VectorClear( normal );
normal[ i ] = 1;
// brushes made from triangles of embedded models, and it has little effect
// on anything else (axial planes are usually derived from snapped points)
/*
- SnapPlane reenabled by namespace because of multiple reports of
- q3map2-crashes which were triggered by this patch.
+ SnapPlane reenabled by namespace because of multiple reports of
+ q3map2-crashes which were triggered by this patch.
*/
SnapNormal( normal );
snaps a plane to normal/distance epsilons, improved code
*/
void SnapPlaneImproved( vec3_t normal, vec_t *dist, int numPoints, const vec3_t *points ){
- int i;
- vec3_t center;
- vec_t distNearestInt;
+ int i;
+ vec3_t center;
+ vec_t distNearestInt;
if ( SnapNormal( normal ) ) {
if ( numPoints > 0 ) {
#ifdef USE_HASHING
{
- int i, j, hash, h;
+ int i, j, hash, h;
int pidx;
- plane_t *p;
- vec_t d;
+ plane_t *p;
+ vec_t d;
vec3_t normal;
VectorCopy( innormal, normal );
#endif
/* hash the plane */
hash = ( PLANE_HASHES - 1 ) & (int) fabs( dist );
-
+
/* search the border bins as well */
for ( i = -1; i <= 1; i++ )
{
if ( !PlaneEqual( p, normal, dist ) ) {
continue;
}
-
+
/* ydnar: uncomment the following line for old-style plane finding */
//% return p - mapplanes;
-
+
/* ydnar: test supplied points against this plane */
for ( j = 0; j < numPoints; j++ )
{
d = fabs( d );
if ( d != 0.0 && d >= distanceEpsilon ) {
break; // Point is too far from plane.
+ }
}
- }
-
+
/* found a matching plane */
if ( j >= numPoints ) {
return p - mapplanes;
+ }
}
}
- }
-
+
/* none found, so create a new one */
return CreateNewFloatPlane( normal, dist );
}
#else
{
- int i;
- plane_t *p;
+ int i;
+ plane_t *p;
vec3_t normal;
-
+
VectorCopy( innormal, normal );
#if Q3MAP2_EXPERIMENTAL_SNAP_PLANE_FIX
SnapPlaneImproved( normal, &dist, numPoints, (const vec3_t *) points );
#else
- SnapPlane( normal, &dist );
+ SnapPlane( normal, &dist );
#endif
for ( i = 0, p = mapplanes; i < nummapplanes; i++, p++ )
{
/* ydnar: uncomment the following line for old-style plane finding */
//% return i;
-
+
/* ydnar: test supplied points against this plane */
for ( j = 0; j < numPoints; j++ )
{
d = DotProduct( points[ j ], p->normal ) - p->dist;
if ( fabs( d ) > distanceEpsilon ) {
break;
+ }
}
- }
-
+
/* found a matching plane */
if ( j >= numPoints ) {
return i;
// for the provided points. It should do that. I think this code
// is unmaintained because nobody sets USE_HASHING to off.
}
-
+
return CreateNewFloatPlane( normal, dist );
}
int MapPlaneFromPoints( vec3_t *p ){
#if Q3MAP2_EXPERIMENTAL_HIGH_PRECISION_MATH_FIXES
- vec3_accu_t paccu[3];
- vec3_accu_t t1, t2, normalAccu;
- vec3_t normal;
- vec_t dist;
+ vec3_accu_t paccu[3];
+ vec3_accu_t t1, t2, normalAccu;
+ vec3_t normal;
+ vec_t dist;
VectorCopyRegularToAccu( p[0], paccu[0] );
VectorCopyRegularToAccu( p[1], paccu[1] );
return FindFloatPlane( normal, dist, 3, p );
#else
- vec3_t t1, t2, normal;
- vec_t dist;
-
-
+ vec3_t t1, t2, normal;
+ vec_t dist;
+
+
/* calc plane normal */
VectorSubtract( p[ 0 ], p[ 1 ], t1 );
VectorSubtract( p[ 2 ], p[ 1 ], t2 );
CrossProduct( t1, t2, normal );
VectorNormalize( normal, normal );
-
+
/* calc plane distance */
dist = DotProduct( p[ 0 ], normal );
-
+
/* store the plane */
return FindFloatPlane( normal, dist, 3, p );
#endif
*/
void SetBrushContents( brush_t *b ){
- int contentFlags, compileFlags;
- side_t *s;
- int i;
+ int contentFlags, compileFlags;
+ side_t *s;
+ int i;
//% qboolean mixed;
-
-
+
+
/* get initial compile flags from first side */
s = &b->sides[ 0 ];
contentFlags = s->contentFlags;
compileFlags = s->compileFlags;
b->contentShader = s->shaderInfo;
//% mixed = qfalse;
-
+
/* get the content/compile flags for every side in the brush */
for ( i = 1; i < b->numsides; i++, s++ )
{
contentFlags |= s->contentFlags;
compileFlags |= s->compileFlags;
}
-
+
/* ydnar: getting rid of this stupid warning */
//% if( mixed )
//% Sys_FPrintf( SYS_VRB,"Entity %i, Brush %i: mixed face contentFlags\n", b->entitynum, b->brushnum );
xml_Select( "Mixed detail and structural (defaulting to structural)", mapEnt->mapEntityNum, entitySourceBrushes, qfalse );
compileFlags &= ~C_DETAIL;
}
-
+
/* the fulldetail flag will cause detail brushes to be treated like normal brushes */
if ( fulldetail ) {
compileFlags &= ~C_DETAIL;
}
-
+
/* all translucent brushes that aren't specifically made structural will be detail */
if ( ( compileFlags & C_TRANSLUCENT ) && !( compileFlags & C_STRUCTURAL ) ) {
compileFlags |= C_DETAIL;
}
-
+
/* detail? */
if ( compileFlags & C_DETAIL ) {
c_detail++;
c_structural++;
b->detail = qfalse;
}
-
+
/* opaque? */
if ( compileFlags & C_TRANSLUCENT ) {
b->opaque = qfalse;
else{
b->opaque = qtrue;
}
-
+
/* areaportal? */
if ( compileFlags & C_AREAPORTAL ) {
c_areaportals++;
}
-
+
/* set brush flags */
b->contentFlags = contentFlags;
b->compileFlags = compileFlags;
*/
void AddBrushBevels( void ){
- int axis, dir;
- int i, j, k, l, order;
- side_t sidetemp;
- side_t *s, *s2;
- winding_t *w, *w2;
- vec3_t normal;
- float dist;
- vec3_t vec, vec2;
- float d, minBack;
+ int axis, dir;
+ int i, j, k, l, order;
+ side_t sidetemp;
+ side_t *s, *s2;
+ winding_t *w, *w2;
+ vec3_t normal;
+ float dist;
+ vec3_t vec, vec2;
+ float d, minBack;
//
// add the axial planes
{
/* ydnar: testing disabling of mre code */
#if 0
- if ( dir > 0 ) {
- if ( mapplanes[s->planenum].normal[axis] >= 0.9999f ) {
- break;
- }
+ if ( dir > 0 ) {
+ if ( mapplanes[s->planenum].normal[axis] >= 0.9999f ) {
+ break;
}
- else {
- if ( mapplanes[s->planenum].normal[axis] <= -0.9999f ) {
- break;
- }
+ }
+ else {
+ if ( mapplanes[s->planenum].normal[axis] <= -0.9999f ) {
+ break;
}
+ }
#else
if ( ( dir > 0 && mapplanes[ s->planenum ].normal[ axis ] == 1.0f ) ||
( dir < 0 && mapplanes[ s->planenum ].normal[ axis ] == -1.0f ) ) {
- break;
+ break;
}
#endif
}
}
else{
dist = buildBrush->maxs[ axis ];
- }
+ }
}
else
{
}
else{
dist = -buildBrush->mins[ axis ];
- }
+ }
}
s->planenum = FindFloatPlane( normal, dist, 0, NULL );
// add the edge bevels
//
if ( buildBrush->numsides == 6 ) {
- return; // pure axial
+ return; // pure axial
}
// test the non-axial plane edges
SnapNormal( vec );
for ( k = 0; k < 3; k++ ) {
if ( vec[k] == -1.0f || vec[k] == 1.0f || ( vec[k] == 0.0f && vec[( k + 1 ) % 3] == 0.0f ) ) {
- break; // axial
+ break; // axial
}
}
if ( k != 3 ) {
- continue; // only test non-axial edges
+ continue; // only test non-axial edges
}
/* debug code */
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++ ) {
for ( l = 0; l < w2->numpoints; l++ ) {
d = DotProduct( w2->p[l], normal ) - dist;
if ( d > 0.1f ) {
- break; // point in front
+ break; // point in front
}
if ( d < minBack ) {
minBack = d;
}
if ( k != buildBrush->numsides ) {
- continue; // wasn't part of the outer hull
+ continue; // wasn't part of the outer hull
}
-
+
/* debug code */
//% Sys_Printf( "n = %f %f %f\n", normal[ 0 ], normal[ 1 ], normal[ 2 ] );
-
+
// add this plane
if ( buildBrush->numsides == MAX_BUILD_SIDES ) {
xml_Select( "MAX_BUILD_SIDES", buildBrush->entityNum, buildBrush->brushNum, qtrue );
}
brush_t *FinishBrush( qboolean noCollapseGroups ){
- brush_t *b;
-
-
+ brush_t *b;
+
+
/* create windings for sides and bounds for brush */
if ( !CreateBrushWindings( buildBrush ) ) {
return NULL;
/* 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->compileFlags & C_ORIGIN ) {
- vec3_t origin;
+ vec3_t origin;
- Sys_Printf( "Entity %i, Brush %i: origin brush detected\n",
- mapEnt->mapEntityNum, entitySourceBrushes );
+ Sys_Printf( "Entity %i, Brush %i: origin brush detected\n",
+ mapEnt->mapEntityNum, entitySourceBrushes );
if ( numEntities == 1 ) {
- Sys_Printf( "Entity %i, Brush %i: origin brushes not allowed in world\n",
- mapEnt->mapEntityNum, entitySourceBrushes );
+ Sys_Printf( "Entity %i, Brush %i: origin brushes not allowed in world\n",
+ mapEnt->mapEntityNum, entitySourceBrushes );
return NULL;
}
-
+
VectorAdd( buildBrush->mins, buildBrush->maxs, origin );
VectorScale( origin, 0.5, origin );
/* don't keep this brush */
return NULL;
}
-
+
/* determine if the brush is an area portal */
if ( buildBrush->compileFlags & C_AREAPORTAL ) {
if ( numEntities != 1 ) {
return NULL;
}
}
-
+
/* add bevel planes */
if ( !noCollapseGroups ) {
AddBrushBevels();
}
-
+
/* keep it */
b = CopyBrush( buildBrush );
-
+
/* set map entity and brush numbering */
b->entityNum = mapEnt->mapEntityNum;
b->brushNum = entitySourceBrushes;
-
+
/* set original */
b->original = b;
-
+
/* link opaque brushes to head of list, translucent brushes to end */
if ( b->opaque || mapEnt->lastBrush == NULL ) {
b->next = mapEnt->brushes;
mapEnt->brushes = b;
if ( mapEnt->lastBrush == NULL ) {
mapEnt->lastBrush = b;
- }
+ }
}
else
{
mapEnt->lastBrush->next = b;
mapEnt->lastBrush = b;
}
-
+
/* link colorMod volume brushes to the entity directly */
if ( b->contentShader != NULL &&
- b->contentShader->colorMod != NULL &&
+ b->contentShader->colorMod != NULL &&
b->contentShader->colorMod->type == CM_VOLUME ) {
b->nextColorModBrush = mapEnt->colorModBrushes;
mapEnt->colorModBrushes = b;
}
-
+
/* return to sender */
return b;
}
(must be identical in radiant!)
*/
-vec3_t baseaxis[18] =
+vec3_t baseaxis[18] =
{
- {0,0,1}, {1,0,0}, {0,-1,0}, // floor
- {0,0,-1}, {1,0,0}, {0,-1,0}, // ceiling
- {1,0,0}, {0,1,0}, {0,0,-1}, // west wall
- {-1,0,0}, {0,1,0}, {0,0,-1}, // east wall
- {0,1,0}, {1,0,0}, {0,0,-1}, // south wall
- {0,-1,0}, {1,0,0}, {0,0,-1} // north wall
+ {0,0,1}, {1,0,0}, {0,-1,0}, // floor
+ {0,0,-1}, {1,0,0}, {0,-1,0}, // ceiling
+ {1,0,0}, {0,1,0}, {0,0,-1}, // west wall
+ {-1,0,0}, {0,1,0}, {0,0,-1}, // east wall
+ {0,1,0}, {1,0,0}, {0,0,-1}, // south wall
+ {0,-1,0}, {1,0,0}, {0,0,-1} // north wall
};
void TextureAxisFromPlane( plane_t *pln, vec3_t xv, vec3_t yv ){
- int bestaxis;
- vec_t dot,best;
- int i;
-
+ int bestaxis;
+ vec_t dot,best;
+ int i;
+
best = 0;
bestaxis = 0;
-
+
for ( i = 0 ; i < 6 ; i++ )
- {
+ {
dot = DotProduct( pln->normal, baseaxis[i * 3] );
if ( dot > best + 0.0001f ) { /* ydnar: bug 637 fix, suggested by jmonroe */
best = dot;
bestaxis = i;
}
}
-
+
VectorCopy( baseaxis[bestaxis * 3 + 1], xv );
VectorCopy( baseaxis[bestaxis * 3 + 2], yv );
}
*/
void QuakeTextureVecs( plane_t *plane, vec_t shift[ 2 ], vec_t rotate, vec_t scale[ 2 ], vec_t mappingVecs[ 2 ][ 4 ] ){
- vec3_t vecs[2];
- int sv, tv;
- vec_t ang, sinv, cosv;
- vec_t ns, nt;
- int i, j;
-
-
+ vec3_t vecs[2];
+ int sv, tv;
+ vec_t ang, sinv, cosv;
+ vec_t ns, nt;
+ int i, j;
+
+
TextureAxisFromPlane( plane, vecs[0], vecs[1] );
-
+
if ( !scale[0] ) {
scale[0] = 1;
}
sinv = -1 ; cosv = 0;
}
else
- {
+ {
ang = rotate / 180 * Q_PI;
sinv = sin( ang );
cosv = cos( ang );
else{
sv = 2;
}
-
+
if ( vecs[1][0] ) {
tv = 0;
}
else{
tv = 2;
}
-
+
for ( i = 0 ; i < 2 ; i++ ) {
ns = cosv * vecs[i][sv] - sinv * vecs[i][tv];
nt = sinv * vecs[i][sv] + cosv * vecs[i][tv];
*/
static void ParseRawBrush( qboolean onlyLights ){
- side_t *side;
- vec3_t planePoints[ 3 ];
- int planenum;
- shaderInfo_t *si;
- vec_t shift[ 2 ];
- vec_t rotate = 0;
- vec_t scale[ 2 ];
- char name[ MAX_QPATH ];
- char shader[ MAX_QPATH ];
- int flags;
-
-
+ side_t *side;
+ vec3_t planePoints[ 3 ];
+ int planenum;
+ shaderInfo_t *si;
+ vec_t shift[ 2 ];
+ vec_t rotate = 0;
+ vec_t scale[ 2 ];
+ char name[ MAX_QPATH ];
+ char shader[ MAX_QPATH ];
+ int flags;
+
+
/* initial setup */
buildBrush->numsides = 0;
buildBrush->detail = qfalse;
-
+
/* bp */
if ( g_bBrushPrimit == BPRIMIT_NEWBRUSHES ) {
MatchToken( "{" );
}
-
+
/* parse sides */
while ( 1 )
{
if ( !strcmp( token, "}" ) ) {
break;
}
-
+
/* ttimo : bp: here we may have to jump over brush epairs (only used in editor) */
if ( g_bBrushPrimit == BPRIMIT_NEWBRUSHES ) {
while ( 1 )
}
}
UnGetToken();
-
+
/* test side count */
if ( buildBrush->numsides >= MAX_BUILD_SIDES ) {
xml_Select( "MAX_BUILD_SIDES", buildBrush->entityNum, buildBrush->brushNum, qtrue );
}
-
+
/* add side */
side = &buildBrush->sides[ buildBrush->numsides ];
memset( side, 0, sizeof( *side ) );
buildBrush->numsides++;
-
+
/* read the three point plane definition */
Parse1DMatrix( 3, planePoints[ 0 ] );
Parse1DMatrix( 3, planePoints[ 1 ] );
Parse1DMatrix( 3, planePoints[ 2 ] );
-
+
/* bp: read the texture matrix */
if ( g_bBrushPrimit == BPRIMIT_NEWBRUSHES ) {
Parse2DMatrix( 2, 3, (float*) side->texMat );
}
-
+
/* read shader name */
GetToken( qfalse );
strcpy( name, token );
-
+
/* bp */
if ( g_bBrushPrimit == BPRIMIT_OLDBRUSHES ) {
GetToken( qfalse );
GetToken( qfalse );
shift[ 1 ] = atof( token );
GetToken( qfalse );
- rotate = atof( token );
+ rotate = atof( token );
GetToken( qfalse );
scale[ 0 ] = atof( token );
GetToken( qfalse );
scale[ 1 ] = atof( token );
}
-
+
/* set default flags and values */
sprintf( shader, "textures/%s", name );
if ( onlyLights ) {
side->contentFlags = si->contentFlags;
side->compileFlags = si->compileFlags;
side->value = si->value;
-
+
/* ydnar: gs mods: bias texture shift */
if ( si->globalTexture == qfalse ) {
shift[ 0 ] -= ( floor( shift[ 0 ] / si->shaderWidth ) * si->shaderWidth );
shift[ 1 ] -= ( floor( shift[ 1 ] / si->shaderHeight ) * si->shaderHeight );
}
-
+
/*
- historically, there are 3 integer values at the end of a brushside line in a .map file.
- in quake 3, the only thing that mattered was the first of these three values, which
- was previously the content flags. and only then did a single bit matter, the detail
- bit. because every game has its own special flags for specifying detail, the
- traditionally game-specified CONTENTS_DETAIL flag was overridden for Q3Map 2.3.0
- by C_DETAIL, defined in q3map2.h. the value is exactly as it was before, but
- is stored in compileFlags, as opposed to contentFlags, for multiple-game
- portability. :sigh:
- */
-
+ historically, there are 3 integer values at the end of a brushside line in a .map file.
+ in quake 3, the only thing that mattered was the first of these three values, which
+ was previously the content flags. and only then did a single bit matter, the detail
+ bit. because every game has its own special flags for specifying detail, the
+ traditionally game-specified CONTENTS_DETAIL flag was overridden for Q3Map 2.3.0
+ by C_DETAIL, defined in q3map2.h. the value is exactly as it was before, but
+ is stored in compileFlags, as opposed to contentFlags, for multiple-game
+ portability. :sigh:
+ */
+
if ( TokenAvailable() ) {
/* get detail bit from map content flags */
GetToken( qfalse );
if ( flags & C_DETAIL ) {
side->compileFlags |= C_DETAIL;
}
-
+
/* historical */
GetToken( qfalse );
//% td.flags = atoi( token );
GetToken( qfalse );
//% td.value = atoi( token );
}
-
+
/* find the plane number */
planenum = MapPlaneFromPoints( planePoints );
side->planenum = planenum;
-
+
/* bp: get the texture mapping for this texturedef / plane combination */
if ( g_bBrushPrimit == BPRIMIT_OLDBRUSHES ) {
QuakeTextureVecs( &mapplanes[ planenum ], shift, rotate, scale, side->vecs );
+ }
}
- }
-
+
/* bp */
if ( g_bBrushPrimit == BPRIMIT_NEWBRUSHES ) {
UnGetToken();
*/
qboolean RemoveDuplicateBrushPlanes( brush_t *b ){
- int i, j, k;
- side_t *sides;
+ int i, j, k;
+ side_t *sides;
sides = b->sides;
// check for a degenerate plane
if ( sides[i].planenum == -1 ) {
- xml_Select( "degenerate plane", b->entityNum, b->brushNum, qfalse );
+ xml_Select( "degenerate plane", b->entityNum, b->brushNum, qfalse );
// remove it
for ( k = i + 1 ; k < b->numsides ; k++ ) {
sides[k - 1] = sides[k];
// check for duplication and mirroring
for ( j = 0 ; j < i ; j++ ) {
if ( sides[i].planenum == sides[j].planenum ) {
- xml_Select( "duplicate plane", b->entityNum, b->brushNum, qfalse );
+ xml_Select( "duplicate plane", b->entityNum, b->brushNum, qfalse );
// remove the second duplicate
for ( k = i + 1 ; k < b->numsides ; k++ ) {
sides[k - 1] = sides[k];
if ( sides[i].planenum == ( sides[j].planenum ^ 1 ) ) {
// mirror plane, brush is invalid
- xml_Select( "mirrored plane", b->entityNum, b->brushNum, qfalse );
+ xml_Select( "mirrored plane", b->entityNum, b->brushNum, qfalse );
return qfalse;
}
}
static void ParseBrush( qboolean onlyLights, qboolean noCollapseGroups ){
/* parse the brush out of the map */
ParseRawBrush( onlyLights );
-
+
/* only go this far? */
if ( onlyLights ) {
return;
}
-
+
/* set some defaults */
buildBrush->portalareas[ 0 ] = -1;
buildBrush->portalareas[ 1 ] = -1;
buildBrush->entityNum = numMapEntities - 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->compileFlags & C_DETAIL ) ) {
//% FreeBrush( buildBrush );
return;
}
-
+
/* allow liquid brushes to be removed */
if ( nowater && ( buildBrush->compileFlags & C_LIQUID ) ) {
//% FreeBrush( buildBrush );
return;
}
-
+
/* ydnar: allow hint brushes to be removed */
if ( noHint && ( buildBrush->compileFlags & C_HINT ) ) {
//% FreeBrush( buildBrush );
return;
}
-
+
/* finish the brush */
FinishBrush( noCollapseGroups );
}
void AdjustBrushesForOrigin( entity_t *ent );
void MoveBrushesToWorld( entity_t *ent ){
- brush_t *b, *next;
- parseMesh_t *pm;
+ brush_t *b, *next;
+ parseMesh_t *pm;
/* we need to undo the common/origin adjustment, and instead shift them by the entity key origin */
VectorScale( ent->origin, -1, ent->originbrush_origin );
AdjustBrushesForOrigin( ent );
VectorClear( ent->originbrush_origin );
-
+
/* move brushes */
for ( b = ent->brushes; b != NULL; b = next )
{
/* get next brush */
next = b->next;
-
+
/* link opaque brushes to head of list, translucent brushes to end */
if ( b->opaque || entities[ 0 ].lastBrush == NULL ) {
b->next = entities[ 0 ].brushes;
entities[ 0 ].brushes = b;
if ( entities[ 0 ].lastBrush == NULL ) {
entities[ 0 ].lastBrush = b;
- }
+ }
}
else
{
}
}
ent->brushes = NULL;
-
+
/* ydnar: move colormod brushes */
if ( ent->colorModBrushes != NULL ) {
for ( b = ent->colorModBrushes; b->nextColorModBrush != NULL; b = b->nextColorModBrush ) ;
-
+
b->nextColorModBrush = entities[ 0 ].colorModBrushes;
entities[ 0 ].colorModBrushes = ent->colorModBrushes;
-
+
ent->colorModBrushes = NULL;
}
-
+
/* move patches */
if ( ent->patches != NULL ) {
for ( pm = ent->patches; pm->next != NULL; pm = pm->next ) ;
-
+
pm->next = entities[ 0 ].patches;
entities[ 0 ].patches = ent->patches;
-
+
ent->patches = NULL;
}
}
*/
void AdjustBrushesForOrigin( entity_t *ent ){
-
- int i;
- side_t *s;
- vec_t newdist;
- brush_t *b;
- parseMesh_t *p;
-
+
+ int i;
+ side_t *s;
+ vec_t newdist;
+ brush_t *b;
+ parseMesh_t *p;
+
/* walk brush list */
for ( b = ent->brushes; b != NULL; b = b->next )
{
{
/* get brush side */
s = &b->sides[ i ];
-
+
/* offset side plane */
newdist = mapplanes[ s->planenum ].dist - DotProduct( mapplanes[ s->planenum ].normal, ent->originbrush_origin );
-
+
/* find a new plane */
s->planenum = FindFloatPlane( mapplanes[ s->planenum ].normal, newdist, 0, NULL );
}
-
+
/* rebuild brush windings (ydnar: just offsetting the winding above should be fine) */
CreateBrushWindings( b );
}
-
+
/* walk patch list */
for ( p = ent->patches; p != NULL; p = p->next )
{
*/
void SetEntityBounds( entity_t *e ){
- int i;
- brush_t *b;
- parseMesh_t *p;
- vec3_t mins, maxs;
- const char *value;
+ int i;
+ brush_t *b;
+ parseMesh_t *p;
+ vec3_t mins, maxs;
+ const char *value;
+
+
-
-
/* walk the entity's brushes/patches and determine bounds */
ClearBounds( mins, maxs );
for ( i = 0; i < ( p->mesh.width * p->mesh.height ); i++ )
AddPointToBounds( p->mesh.verts[ i ].xyz, mins, maxs );
}
-
+
/* try to find explicit min/max key */
- value = ValueForKey( e, "min" );
+ value = ValueForKey( e, "min" );
if ( value[ 0 ] != '\0' ) {
GetVectorForKey( e, "min", mins );
}
- value = ValueForKey( e, "max" );
+ value = ValueForKey( e, "max" );
if ( value[ 0 ] != '\0' ) {
GetVectorForKey( e, "max", maxs );
}
-
+
/* store the bounds */
for ( b = e->brushes; b; b = b->next )
{
*/
void LoadEntityIndexMap( entity_t *e ){
- int i, size, numLayers, w, h;
- const char *value, *indexMapFilename, *shader;
- char ext[ MAX_QPATH ], offset[ 4096 ], *search, *space;
- byte *pixels;
- unsigned int *pixels32;
- indexMap_t *im;
- brush_t *b;
- parseMesh_t *p;
-
-
+ int i, size, numLayers, w, h;
+ const char *value, *indexMapFilename, *shader;
+ char ext[ MAX_QPATH ], offset[ 4096 ], *search, *space;
+ byte *pixels;
+ unsigned int *pixels32;
+ indexMap_t *im;
+ brush_t *b;
+ parseMesh_t *p;
+
+
/* this only works with bmodel ents */
if ( e->brushes == NULL && e->patches == NULL ) {
return;
}
-
+
/* determine if there is an index map (support legacy "alphamap" key as well) */
value = ValueForKey( e, "_indexmap" );
if ( value[ 0 ] == '\0' ) {
return;
}
indexMapFilename = value;
-
+
/* get number of layers (support legacy "layers" key as well) */
value = ValueForKey( e, "_layers" );
if ( value[ 0 ] == '\0' ) {
Sys_Printf( "Entity will not be textured properly. Check your keys/values.\n" );
return;
}
-
+
/* get base shader name (support legacy "shader" key as well) */
value = ValueForKey( mapEnt, "_shader" );
if ( value[ 0 ] == '\0' ) {
return;
}
shader = value;
-
+
/* note it */
Sys_FPrintf( SYS_VRB, "Entity %d (%s) has shader index map \"%s\"\n", mapEnt->mapEntityNum, ValueForKey( e, "classname" ), indexMapFilename );
-
+
/* get index map file extension */
ExtractFileExtension( indexMapFilename, ext );
-
+
/* handle tga image */
if ( !Q_stricmp( ext, "tga" ) ) {
/* load it */
Load32BitImage( indexMapFilename, &pixels32, &w, &h );
-
+
/* convert to bytes */
size = w * h;
pixels = safe_malloc( size );
pixels[ i ] = ( ( pixels32[ i ] & 0xFF ) * numLayers ) / 256;
if ( pixels[ i ] >= numLayers ) {
pixels[ i ] = numLayers - 1;
+ }
}
- }
-
+
/* free the 32 bit image */
free( pixels32 );
}
{
/* load it */
Load256Image( indexMapFilename, &pixels, NULL, &w, &h );
-
+
/* debug code */
//% Sys_Printf( "-------------------------------" );
-
+
/* fix up out-of-range values */
size = w * h;
for ( i = 0; i < size; i++ )
if ( pixels[ i ] >= numLayers ) {
pixels[ i ] = numLayers - 1;
}
-
+
/* debug code */
//% if( (i % w) == 0 )
//% Sys_Printf( "\n" );
//% Sys_Printf( "%c", pixels[ i ] + '0' );
}
-
+
/* debug code */
//% Sys_Printf( "\n-------------------------------\n" );
}
-
+
/* the index map must be at least 2x2 pixels */
if ( w < 2 || h < 2 ) {
Sys_Printf( "WARNING: Entity with index/alpha map \"%s\" is smaller than 2x2 pixels\n", indexMapFilename );
/* create a new index map */
im = safe_malloc( sizeof( *im ) );
memset( im, 0, sizeof( *im ) );
-
+
/* set it up */
im->w = w;
im->h = h;
strcpy( im->name, indexMapFilename );
strcpy( im->shader, shader );
im->pixels = pixels;
-
+
/* get height offsets */
value = ValueForKey( mapEnt, "_offsets" );
if ( value[ 0 ] == '\0' ) {
/* value is a space-seperated set of numbers */
strcpy( offset, value );
search = offset;
-
+
/* get each value */
for ( i = 0; i < 256 && *search != '\0'; i++ )
{
search = space + 1;
}
}
-
+
/* store the index map in every brush/patch in the entity */
for ( b = e->brushes; b != NULL; b = b->next )
b->im = im;
*/
static qboolean ParseMapEntity( qboolean onlyLights, qboolean noCollapseGroups ){
- epair_t *ep;
- const char *classname, *value;
- float lightmapScale, shadeAngle;
- int lightmapSampleSize;
- char shader[ MAX_QPATH ];
- shaderInfo_t *celShader = NULL;
- brush_t *brush;
- parseMesh_t *patch;
- qboolean funcGroup;
- int castShadows, recvShadows;
+ epair_t *ep;
+ const char *classname, *value;
+ float lightmapScale, shadeAngle;
+ int lightmapSampleSize;
+ char shader[ MAX_QPATH ];
+ shaderInfo_t *celShader = NULL;
+ brush_t *brush;
+ parseMesh_t *patch;
+ qboolean funcGroup;
+ int castShadows, recvShadows;
vec3_t colormod;
-
-
+
+
/* eof check */
if ( !GetToken( qtrue ) ) {
return qfalse;
}
-
+
/* conformance check */
if ( strcmp( token, "{" ) ) {
Sys_Printf( "WARNING: ParseEntity: { not found, found %s on line %d - last entity was at: <%4.2f, %4.2f, %4.2f>...\n"
- "Continuing to process map, but resulting BSP may be invalid.\n",
- token, scriptline, entities[ numEntities ].origin[ 0 ], entities[ numEntities ].origin[ 1 ], entities[ numEntities ].origin[ 2 ] );
+ "Continuing to process map, but resulting BSP may be invalid.\n",
+ token, scriptline, entities[ numEntities ].origin[ 0 ], entities[ numEntities ].origin[ 1 ], entities[ numEntities ].origin[ 2 ] );
return qfalse;
}
-
+
/* range check */
AUTOEXPAND_BY_REALLOC( entities, numEntities, allocatedEntities, 32 );
-
+
/* setup */
entitySourceBrushes = 0;
mapEnt = &entities[ numEntities ];
numEntities++;
memset( mapEnt, 0, sizeof( *mapEnt ) );
-
+
/* ydnar: true entity numbering */
mapEnt->mapEntityNum = numMapEntities;
numMapEntities++;
-
+
/* loop */
while ( 1 )
{
/* get initial token */
if ( !GetToken( qtrue ) ) {
Sys_Printf( "WARNING: ParseEntity: EOF without closing brace\n"
- "Continuing to process map, but resulting BSP may be invalid.\n" );
+ "Continuing to process map, but resulting BSP may be invalid.\n" );
return qfalse;
}
-
+
if ( !strcmp( token, "}" ) ) {
break;
}
-
+
if ( !strcmp( token, "{" ) ) {
/* parse a brush or patch */
if ( !GetToken( qtrue ) ) {
break;
}
-
+
/* check */
if ( !strcmp( token, "patchDef2" ) ) {
numMapPatches++;
}
else if ( !strcmp( token, "terrainDef" ) ) {
//% ParseTerrain();
- Sys_Printf( "WARNING: Terrain entity parsing not supported in this build.\n" ); /* ydnar */
+ Sys_Printf( "WARNING: Terrain entity parsing not supported in this build.\n" ); /* ydnar */
}
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( onlyLights, noCollapseGroups );
}
Error( "New brush format not allowed in old brush format map" );
}
g_bBrushPrimit = BPRIMIT_OLDBRUSHES;
-
+
/* parse old brush format */
UnGetToken();
ParseBrush( onlyLights, noCollapseGroups );
{
/* parse a key / value pair */
ep = ParseEPair();
-
+
/* ydnar: 2002-07-06 fixed wolf bug with empty epairs */
if ( ep->key[ 0 ] != '\0' && ep->value[ 0 ] != '\0' ) {
ep->next = mapEnt->epairs;
}
}
}
-
+
/* ydnar: get classname */
classname = ValueForKey( mapEnt, "classname" );
-
+
/* ydnar: only lights? */
if ( onlyLights && Q_strncasecmp( classname, "light", 5 ) ) {
numEntities--;
return qtrue;
}
-
+
/* ydnar: determine if this is a func_group */
if ( !Q_stricmp( "func_group", classname ) ) {
funcGroup = qtrue;
else{
funcGroup = qfalse;
}
-
+
/* worldspawn (and func_groups) default to cast/recv shadows in worldspawn group */
if ( funcGroup || mapEnt->mapEntityNum == 0 ) {
//% Sys_Printf( "World: %d\n", mapEnt->mapEntityNum );
castShadows = WORLDSPAWN_CAST_SHADOWS;
recvShadows = WORLDSPAWN_RECV_SHADOWS;
}
-
+
/* other entities don't cast any shadows, but recv worldspawn shadows */
else
{
castShadows = ENTITY_CAST_SHADOWS;
recvShadows = ENTITY_RECV_SHADOWS;
}
-
+
/* get explicit shadow flags */
GetEntityShadowFlags( mapEnt, NULL, &castShadows, &recvShadows );
-
+
/* vortex: added _ls key (short name of lightmapscale) */
/* ydnar: get lightmap scaling value for this entity */
lightmapScale = 0.0f;
if ( strcmp( "", ValueForKey( mapEnt, "lightmapscale" ) ) ||
- strcmp( "", ValueForKey( mapEnt, "_lightmapscale" ) ) ||
+ strcmp( "", ValueForKey( mapEnt, "_lightmapscale" ) ) ||
strcmp( "", ValueForKey( mapEnt, "_ls" ) ) ) {
/* get lightmap scale from entity */
lightmapScale = FloatForKey( mapEnt, "lightmapscale" );
}
if ( lightmapScale > 0.0f ) {
Sys_Printf( "Entity %d (%s) has lightmap scale of %.4f\n", mapEnt->mapEntityNum, classname, lightmapScale );
- }
+ }
}
VectorClear(colormod);
else if ( strcmp( "", ValueForKey( mapEnt, "_smooth" ) ) ) {
shadeAngle = FloatForKey( mapEnt, "_smooth" );
}
-
+
if ( shadeAngle < 0.0f ) {
shadeAngle = 0.0f;
}
if ( shadeAngle > 0.0f ) {
Sys_Printf( "Entity %d (%s) has shading angle of %.4f\n", mapEnt->mapEntityNum, classname, shadeAngle );
}
-
+
/* jal : entity based _samplesize */
lightmapSampleSize = 0;
if ( strcmp( "", ValueForKey( mapEnt, "_lightmapsamplesize" ) ) ) {
else if ( strcmp( "", ValueForKey( mapEnt, "_samplesize" ) ) ) {
lightmapSampleSize = IntForKey( mapEnt, "_samplesize" );
}
-
+
if ( lightmapSampleSize < 0 ) {
lightmapSampleSize = 0;
}
if ( lightmapSampleSize > 0 ) {
Sys_Printf( "Entity %d (%s) has lightmap sample size of %d\n", mapEnt->mapEntityNum, classname, lightmapSampleSize );
}
-
+
/* attach stuff to everything in the entity */
for ( brush = mapEnt->brushes; brush != NULL; brush = brush->next )
{
brush->shadeAngleDegrees = shadeAngle;
brush->colormod = colormod;
}
-
+
for ( patch = mapEnt->patches; patch != NULL; patch = patch->next )
{
patch->entityNum = mapEnt->mapEntityNum;
patch->celShader = celShader;
patch->colormod = colormod;
}
-
+
/* ydnar: gs mods: set entity bounds */
SetEntityBounds( mapEnt );
-
+
/* ydnar: gs mods: load shader index map (equivalent to old terrain alphamap) */
LoadEntityIndexMap( mapEnt );
-
+
/* get entity origin and adjust brushes */
GetVectorForKey( mapEnt, "origin", mapEnt->origin );
if ( mapEnt->originbrush_origin[ 0 ] || mapEnt->originbrush_origin[ 1 ] || mapEnt->originbrush_origin[ 2 ] ) {
numEntities--;
return qtrue;
}
-
+
/* group entities are just for editor convenience, toss all brushes into worldspawn */
if ( !noCollapseGroups && funcGroup ) {
MoveBrushesToWorld( mapEnt );
numEntities--;
return qtrue;
}
-
+
/* done */
return qtrue;
}
*/
void LoadMapFile( char *filename, qboolean onlyLights, qboolean noCollapseGroups ){
- FILE *file;
- brush_t *b;
- int oldNumEntities = 0, numMapBrushes;
-
-
+ FILE *file;
+ brush_t *b;
+ int oldNumEntities = 0, numMapBrushes;
+
+
/* note it */
Sys_FPrintf( SYS_VRB, "--- LoadMapFile ---\n" );
Sys_Printf( "Loading %s\n", filename );
-
+
/* hack */
file = SafeOpenRead( filename );
fclose( file );
-
+
/* load the map file */
LoadScriptFile( filename, -1 );
-
+
/* setup */
if ( onlyLights ) {
oldNumEntities = numEntities;
else{
numEntities = 0;
}
-
+
/* initial setup */
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 );
-
+
/* parse the map file */
while ( ParseMapEntity( onlyLights, noCollapseGroups ) ) ;
-
+
/* light loading */
if ( onlyLights ) {
/* emit some statistics */
AddPointToBounds( b->mins, mapMins, mapMaxs );
AddPointToBounds( b->maxs, mapMins, mapMaxs );
}
-
+
/* get brush counts */
numMapBrushes = CountBrushList( entities[ 0 ].brushes );
if ( (float) c_detail / (float) numMapBrushes < 0.10f && numMapBrushes > 500 ) {
Sys_Printf( "WARNING: Over 90 percent structural map detected. Compile time may be adversely affected.\n" );
}
-
+
/* emit some statistics */
Sys_FPrintf( SYS_VRB, "%9d total world brushes\n", numMapBrushes );
Sys_FPrintf( SYS_VRB, "%9d detail brushes\n", c_detail );
Sys_FPrintf( SYS_VRB, "%9d planes\n", nummapplanes );
Sys_Printf( "%9d areaportals\n", c_areaportals );
Sys_Printf( "Size: %5.0f, %5.0f, %5.0f to %5.0f, %5.0f, %5.0f\n",
- mapMins[ 0 ], mapMins[ 1 ], mapMins[ 2 ],
+ mapMins[ 0 ], mapMins[ 1 ], mapMins[ 2 ],
mapMaxs[ 0 ], mapMaxs[ 1 ], mapMaxs[ 2 ] );
-
+
/* write bogus map */
if ( fakemap ) {
WriteBSPBrushMap( "fakemap.map", entities[ 0 ].brushes );
- }
+ }
}
}
-/*
+/*
PicoPrintFunc()
callback for picomodel.lib
*/
}
switch ( level )
{
- case PICO_NORMAL:
- Sys_Printf( "%s\n", str );
- break;
-
- case PICO_VERBOSE:
- Sys_FPrintf( SYS_VRB, "%s\n", str );
- break;
-
- case PICO_WARNING:
- Sys_Printf( "WARNING: %s\n", str );
- break;
-
- case PICO_ERROR:
- Sys_Printf( "ERROR: %s\n", str );
- break;
-
- case PICO_FATAL:
- Error( "ERROR: %s\n", str );
- break;
+ case PICO_NORMAL:
+ Sys_Printf( "%s\n", str );
+ break;
+
+ case PICO_VERBOSE:
+ Sys_FPrintf( SYS_VRB, "%s\n", str );
+ break;
+
+ case PICO_WARNING:
+ Sys_Printf( "WARNING: %s\n", str );
+ break;
+
+ case PICO_ERROR:
+ Sys_Printf( "ERROR: %s\n", str );
+ break;
+
+ case PICO_FATAL:
+ Error( "ERROR: %s\n", str );
+ break;
}
}
-/*
+/*
PicoLoadFileFunc()
callback for picomodel.lib
*/
*/
picoModel_t *FindModel( const char *name, int frame ){
- int i;
-
-
+ int i;
+
+
/* init */
if ( numPicoModels <= 0 ) {
memset( picoModels, 0, sizeof( picoModels ) );
}
-
+
/* dummy check */
if ( name == NULL || name[ 0 ] == '\0' ) {
return NULL;
}
-
+
/* search list */
for ( i = 0; i < MAX_MODELS; i++ )
{
if ( picoModels[ i ] != NULL &&
- !strcmp( PicoGetModelName( picoModels[ i ] ), name ) &&
+ !strcmp( PicoGetModelName( picoModels[ i ] ), name ) &&
PicoGetModelFrameNum( picoModels[ i ] ) == frame ) {
return picoModels[ i ];
+ }
}
- }
-
+
/* no matching picoModel found */
return NULL;
}
*/
picoModel_t *LoadModel( const char *name, int frame ){
- int i;
- picoModel_t *model, **pm;
-
-
+ int i;
+ picoModel_t *model, **pm;
+
+
/* init */
if ( numPicoModels <= 0 ) {
memset( picoModels, 0, sizeof( picoModels ) );
}
-
+
/* dummy check */
if ( name == NULL || name[ 0 ] == '\0' ) {
return NULL;
}
-
+
/* try to find existing picoModel */
model = FindModel( name, frame );
if ( model != NULL ) {
return model;
}
-
+
/* none found, so find first non-null picoModel */
pm = NULL;
for ( i = 0; i < MAX_MODELS; i++ )
- {
+ {
if ( picoModels[ i ] == NULL ) {
pm = &picoModels[ i ];
break;
}
}
-
+
/* too many picoModels? */
if ( pm == NULL ) {
Error( "MAX_MODELS (%d) exceeded, there are too many model files referenced by the map.", MAX_MODELS );
}
-
+
/* attempt to parse model */
*pm = PicoLoadModel( name, frame );
-
+
/* if loading failed, make a bogus model to silence the rest of the warnings */
if ( *pm == NULL ) {
/* allocate a new model */
if ( *pm == NULL ) {
return NULL;
}
-
+
/* set data */
PicoSetModelName( *pm, name );
PicoSetModelFrameNum( *pm, frame );
}
-
+
/* debug code */
#if 0
{
- int numSurfaces, numVertexes;
- picoSurface_t *ps;
-
-
+ int numSurfaces, numVertexes;
+ picoSurface_t *ps;
+
+
Sys_Printf( "Model %s\n", name );
numSurfaces = PicoGetModelNumSurfaces( *pm );
for ( i = 0; i < numSurfaces; i++ )
}
}
#endif
-
+
/* set count */
if ( *pm != NULL ) {
numPicoModels++;
}
-
+
/* return the picoModel */
return *pm;
}
*/
void InsertModel( const char *name, int skin, int frame, m4x4_t transform, remap_t *remap, shaderInfo_t *celShader, int eNum, int castShadows, int recvShadows, int spawnFlags, float lightmapScale, int lightmapSampleSize, float shadeAngle, vec3_t colormod ){
- int i, j, s, numSurfaces;
- m4x4_t identity, nTransform;
- picoModel_t *model;
- picoShader_t *shader;
- picoSurface_t *surface;
- shaderInfo_t *si;
- mapDrawSurface_t *ds;
- bspDrawVert_t *dv;
- char *picoShaderName;
- char shaderName[ MAX_QPATH ];
- picoVec_t *xyz, *normal, *st;
- byte *color;
- picoIndex_t *indexes;
- remap_t *rm, *glob;
- skinfile_t *sf, *sf2;
- double normalEpsilon_save;
- double distanceEpsilon_save;
- char skinfilename[ MAX_QPATH ];
- char *skinfilecontent;
- int skinfilesize;
- char *skinfileptr, *skinfilenextptr;
-
-
+ int i, j, s, numSurfaces;
+ m4x4_t identity, nTransform;
+ picoModel_t *model;
+ picoShader_t *shader;
+ picoSurface_t *surface;
+ shaderInfo_t *si;
+ mapDrawSurface_t *ds;
+ bspDrawVert_t *dv;
+ char *picoShaderName;
+ char shaderName[ MAX_QPATH ];
+ picoVec_t *xyz, *normal, *st;
+ byte *color;
+ picoIndex_t *indexes;
+ remap_t *rm, *glob;
+ skinfile_t *sf, *sf2;
+ double normalEpsilon_save;
+ double distanceEpsilon_save;
+ char skinfilename[ MAX_QPATH ];
+ char *skinfilecontent;
+ int skinfilesize;
+ char *skinfileptr, *skinfilenextptr;
+
+
/* get model */
model = LoadModel( name, frame );
if ( model == NULL ) {
skinfilesize = vfsLoadFile( skinfilename, (void**) &skinfilecontent, 0 );
if ( skinfilesize >= 0 ) {
Sys_Printf( "Skin %d of %s does not exist, using 0 instead\n", skin, name );
- }
+ }
}
sf = NULL;
if ( skinfilesize >= 0 ) {
}
free( skinfilecontent );
}
-
+
/* handle null matrix */
if ( transform == NULL ) {
m4x4_identity( identity );
transform = identity;
}
-
+
/* hack: Stable-1_2 and trunk have differing row/column major matrix order
this transpose is necessary with Stable-1_2
uncomment the following line with old m4x4_t (non 1.3/spog_branch) code */
//% m4x4_transpose( transform );
-
+
/* create transform matrix for normals */
memcpy( nTransform, transform, sizeof( m4x4_t ) );
if ( m4x4_invert( nTransform ) ) {
Sys_FPrintf( SYS_VRB, "WARNING: Can't invert model transform matrix, using transpose instead\n" );
}
m4x4_transpose( nTransform );
-
+
/* fix bogus lightmap scale */
if ( lightmapScale <= 0.0f ) {
lightmapScale = 1.0f;
if ( shadeAngle <= 0.0f ) {
shadeAngle = 0.0f;
}
-
+
/* each surface on the model will become a new map drawsurface */
numSurfaces = PicoGetModelNumSurfaces( model );
//% Sys_FPrintf( SYS_VRB, "Model %s has %d surfaces\n", name, numSurfaces );
if ( surface == NULL ) {
continue;
}
-
+
/* only handle triangle surfaces initially (fixme: support patches) */
if ( PicoGetSurfaceType( surface ) != PICO_TRIANGLES ) {
continue;
}
-
+
/* get shader name */
- shader = PicoGetSurfaceShader( surface );
+ shader = PicoGetSurfaceShader( surface );
if ( shader == NULL ) {
picoShaderName = "";
}
if ( sf ) {
picoShaderName = NULL;
for ( sf2 = sf; sf2 != NULL; sf2 = sf2->next )
- {
+ {
if ( !Q_stricmp( surface->name, sf2->name ) ) {
Sys_FPrintf( SYS_VRB, "Skin file: mapping %s to %s\n", surface->name, sf2->to );
picoShaderName = sf2->to;
break;
}
}
-
+
if ( glob != NULL ) {
Sys_FPrintf( SYS_VRB, "Globbing %s to %s\n", picoShaderName, glob->to );
picoShaderName = glob->to;
}
-
+
/* shader renaming for sof2 */
if ( renameModelShaders ) {
strcpy( shaderName, picoShaderName );
else{
si = ShaderInfoForShader( picoShaderName );
}
-
+
/* allocate a surface (ydnar: gs mods) */
ds = AllocDrawSurface( SURFACE_TRIANGLES );
ds->entityNum = eNum;
if ( lightmapSampleSize > 0.0f ) {
ds->sampleSize = lightmapSampleSize;
}
-
+
/* set lightmap scale */
if ( lightmapScale > 0.0f ) {
ds->lightmapScale = lightmapScale;
if ( shadeAngle > 0.0f ) {
ds->shadeAngleDegrees = shadeAngle;
}
-
+
/* set particulars */
ds->numVerts = PicoGetSurfaceNumVertexes( surface );
ds->verts = safe_malloc( ds->numVerts * sizeof( ds->verts[ 0 ] ) );
memset( ds->verts, 0, ds->numVerts * sizeof( ds->verts[ 0 ] ) );
-
+
ds->numIndexes = PicoGetSurfaceNumIndexes( surface );
ds->indexes = safe_malloc( ds->numIndexes * sizeof( ds->indexes[ 0 ] ) );
memset( ds->indexes, 0, ds->numIndexes * sizeof( ds->indexes[ 0 ] ) );
-
+
/* copy vertexes */
for ( i = 0; i < ds->numVerts; i++ )
{
/* get vertex */
dv = &ds->verts[ i ];
-
+
/* xyz and normal */
xyz = PicoGetSurfaceXYZ( surface, i );
VectorCopy( xyz, dv->xyz );
m4x4_transform_point( transform, dv->xyz );
-
+
normal = PicoGetSurfaceNormal( surface, i );
VectorCopy( normal, dv->normal );
m4x4_transform_normal( nTransform, dv->normal );
dv->st[ 0 ] = si->stFlat[ 0 ];
dv->st[ 1 ] = si->stFlat[ 1 ];
}
-
+
/* ydnar: gs mods: added support for explicit shader texcoord generation */
else if ( si->tcGen ) {
/* project the texture */
dv->st[ 0 ] = DotProduct( si->vecs[ 0 ], dv->xyz );
dv->st[ 1 ] = DotProduct( si->vecs[ 1 ], dv->xyz );
}
-
+
/* normal texture coordinates */
else
{
dv->st[ 0 ] = st[ 0 ];
dv->st[ 1 ] = st[ 1 ];
}
-
+
/* set lightmap/color bits */
color = PicoGetSurfaceColor( surface, 0, i );
for ( j = 0; j < MAX_LIGHTMAPS; j++ )
}
}
}
-
+
/* copy indexes */
indexes = PicoGetSurfaceIndexes( surface, 0 );
for ( i = 0; i < ds->numIndexes; i++ )
ds->indexes[ i ] = indexes[ i ];
-
+
/* set cel shader */
ds->celShader = celShader;
-
+
/* ydnar: giant hack land: generate clipping brushes for model triangles */
if ( si->clipModel || ( spawnFlags & 2 ) ) { /* 2nd bit */
- vec3_t points[ 4 ], backs[ 3 ];
- vec4_t plane, reverse, pa, pb, pc;
-
-
+ vec3_t points[ 4 ], backs[ 3 ];
+ vec4_t plane, reverse, pa, pb, pc;
+
+
/* temp hack */
if ( !si->clipModel && !( si->compileFlags & C_SOLID ) ) {
continue;
}
-
+
/* walk triangle list */
for ( i = 0; i < ds->numIndexes; i += 3 )
{
/* overflow hack */
AUTOEXPAND_BY_REALLOC( mapplanes, ( nummapplanes + 64 ) << 1, allocatedmapplanes, 1024 );
-
+
/* make points and back points */
for ( j = 0; j < 3; j++ )
{
/* get vertex */
dv = &ds->verts[ ds->indexes[ i + j ] ];
-
+
/* copy xyz */
VectorCopy( dv->xyz, points[ j ] );
}
VectorCopy( points[0], points[3] ); // for cyclic usage
-
+
/* make plane for triangle */
// div0: add some extra spawnflags:
// 0: snap normals to axial planes for extrusion
}
if ( distanceEpsilon > 0 ) {
distanceEpsilon = 0;
- }
+ }
}
else{
buildBrush->detail = qtrue;
// that's at least sqrt(1/3) backPlaneDistance, unless in DOWN mode; in DOWN mode, we are screwed anyway if we encounter a plane that's perpendicular to the xy plane)
if ( PlaneFromPoints( pa, points[ 2 ], points[ 1 ], backs[ 1 ] ) &&
- PlaneFromPoints( pb, points[ 1 ], points[ 0 ], backs[ 0 ] ) &&
+ PlaneFromPoints( pb, points[ 1 ], points[ 0 ], backs[ 0 ] ) &&
PlaneFromPoints( pc, points[ 0 ], points[ 2 ], backs[ 2 ] ) ) {
/* set up brush sides */
buildBrush->numsides = 5;
buildBrush->sides[ 0 ].shaderInfo = si;
for ( j = 1; j < buildBrush->numsides; j++ )
- buildBrush->sides[ j ].shaderInfo = NULL; // don't emit these faces as draw surfaces, should make smaller BSPs; hope this works
+ buildBrush->sides[ j ].shaderInfo = NULL; // don't emit these faces as draw surfaces, should make smaller BSPs; hope this works
buildBrush->sides[ 0 ].planenum = FindFloatPlane( plane, plane[ 3 ], 3, points );
buildBrush->sides[ 1 ].planenum = FindFloatPlane( pa, pa[ 3 ], 2, &points[ 1 ] ); // pa contains points[1] and points[2]
}
else{
free( buildBrush );
+ }
}
}
}
}
- }
}
*/
void AddTriangleModels( entity_t *e ){
- int num, frame, skin, castShadows, recvShadows, spawnFlags;
- entity_t *e2;
- const char *targetName;
- const char *target, *model, *value;
- char shader[ MAX_QPATH ];
- shaderInfo_t *celShader;
- float temp, baseLightmapScale, lightmapScale;
- float shadeAngle;
- int lightmapSampleSize;
- vec3_t origin, scale, angles;
- m4x4_t transform;
- epair_t *ep;
- remap_t *remap, *remap2;
- char *split;
-
-
+ int num, frame, skin, castShadows, recvShadows, spawnFlags;
+ entity_t *e2;
+ const char *targetName;
+ const char *target, *model, *value;
+ char shader[ MAX_QPATH ];
+ shaderInfo_t *celShader;
+ float temp, baseLightmapScale, lightmapScale;
+ float shadeAngle;
+ int lightmapSampleSize;
+ vec3_t origin, scale, angles;
+ m4x4_t transform;
+ epair_t *ep;
+ remap_t *remap, *remap2;
+ char *split;
+
+
/* note it */
Sys_FPrintf( SYS_VRB, "--- AddTriangleModels ---\n" );
-
+
/* get current brush entity targetname */
if ( e == entities ) {
targetName = "";
else
{
targetName = ValueForKey( e, "targetname" );
-
+
/* misc_model entities target non-worldspawn brush model entities */
if ( targetName[ 0 ] == '\0' ) {
return;
+ }
}
- }
-
+
/* get lightmap scale */
/* vortex: added _ls key (short name of lightmapscale) */
baseLightmapScale = 0.0f;
if ( strcmp( "", ValueForKey( e, "lightmapscale" ) ) ||
- strcmp( "", ValueForKey( e, "_lightmapscale" ) ) ||
+ strcmp( "", ValueForKey( e, "_lightmapscale" ) ) ||
strcmp( "", ValueForKey( e, "_ls" ) ) ) {
baseLightmapScale = FloatForKey( e, "lightmapscale" );
if ( baseLightmapScale <= 0.0f ) {
}
if ( baseLightmapScale > 0.0f ) {
Sys_Printf( "World Entity has lightmap scale of %.4f\n", baseLightmapScale );
+ }
}
- }
-
-
+
+
/* walk the entity list */
for ( num = 1; num < numEntities; num++ )
{
/* get e2 */
e2 = &entities[ num ];
-
+
/* convert misc_models into raw geometry */
if ( Q_stricmp( "misc_model", ValueForKey( e2, "classname" ) ) ) {
continue;
if ( strcmp( target, targetName ) ) {
continue;
}
-
+
/* get model name */
model = ValueForKey( e2, "model" );
if ( model[ 0 ] == '\0' ) {
Sys_Printf( "WARNING: misc_model at %i %i %i without a model key\n",
- (int) origin[ 0 ], (int) origin[ 1 ], (int) origin[ 2 ] );
+ (int) origin[ 0 ], (int) origin[ 1 ], (int) origin[ 2 ] );
continue;
}
-
+
/* get model frame */
frame = 0;
if ( strcmp( "", ValueForKey( e2, "_frame" ) ) ) {
else if ( strcmp( "", ValueForKey( e2, "frame" ) ) ) {
frame = IntForKey( e2, "frame" );
}
-
+
/* worldspawn (and func_groups) default to cast/recv shadows in worldspawn group */
if ( e == entities ) {
castShadows = WORLDSPAWN_CAST_SHADOWS;
recvShadows = WORLDSPAWN_RECV_SHADOWS;
}
-
+
/* other entities don't cast any shadows, but recv worldspawn shadows */
else
{
castShadows = ENTITY_CAST_SHADOWS;
recvShadows = ENTITY_RECV_SHADOWS;
}
-
+
/* get explicit shadow flags */
GetEntityShadowFlags( e2, e, &castShadows, &recvShadows );
-
+
/* get spawnflags */
spawnFlags = IntForKey( e2, "spawnflags" );
-
+
/* get origin */
GetVectorForKey( e2, "origin", origin );
- VectorSubtract( origin, e->origin, origin ); /* offset by parent */
-
+ VectorSubtract( origin, e->origin, origin ); /* offset by parent */
+
/* get scale */
scale[ 0 ] = scale[ 1 ] = scale[ 2 ] = 1.0f;
temp = FloatForKey( e2, "modelscale" );
if ( value[ 0 ] != '\0' ) {
sscanf( value, "%f %f %f", &scale[ 0 ], &scale[ 1 ], &scale[ 2 ] );
}
-
+
/* get "angle" (yaw) or "angles" (pitch yaw roll) */
angles[ 0 ] = angles[ 1 ] = angles[ 2 ] = 0.0f;
angles[ 2 ] = FloatForKey( e2, "angle" );
if ( value[ 0 ] != '\0' ) {
sscanf( value, "%f %f %f", &angles[ 1 ], &angles[ 2 ], &angles[ 0 ] );
}
-
+
/* set transform matrix (thanks spog) */
m4x4_identity( transform );
m4x4_pivoted_transform_by_vec3( transform, origin, angles, eXYZ, scale, vec3_origin );
-
+
/* get shader remappings */
remap = NULL;
for ( ep = e2->epairs; ep != NULL; ep = ep->next )
{
/* look for keys prefixed with "_remap" */
if ( ep->key != NULL && ep->value != NULL &&
- ep->key[ 0 ] != '\0' && ep->value[ 0 ] != '\0' &&
+ ep->key[ 0 ] != '\0' && ep->value[ 0 ] != '\0' &&
!Q_strncasecmp( ep->key, "_remap", 6 ) ) {
/* create new remapping */
remap2 = remap;
remap = safe_malloc( sizeof( *remap ) );
remap->next = remap2;
strcpy( remap->from, ep->value );
-
+
/* split the string */
split = strchr( remap->from, ';' );
if ( split == NULL ) {
remap = remap2;
continue;
}
-
+
/* store the split */
*split = '\0';
strcpy( remap->to, ( split + 1 ) );
-
+
/* note it */
//% Sys_FPrintf( SYS_VRB, "Remapping %s to %s\n", remap->from, remap->to );
}
}
-
+
/* ydnar: cel shader support */
value = ValueForKey( e2, "_celshader" );
if ( value[ 0 ] == '\0' ) {
/* vortex: added _ls key (short name of lightmapscale) */
lightmapScale = 0.0f;
if ( strcmp( "", ValueForKey( e2, "lightmapscale" ) ) ||
- strcmp( "", ValueForKey( e2, "_lightmapscale" ) ) ||
+ strcmp( "", ValueForKey( e2, "_lightmapscale" ) ) ||
strcmp( "", ValueForKey( e2, "_ls" ) ) ) {
lightmapScale = FloatForKey( e2, "lightmapscale" );
if ( lightmapScale <= 0.0f ) {
}
if ( lightmapScale > 0.0f ) {
Sys_Printf( "misc_model has lightmap scale of %.4f\n", lightmapScale );
- }
+ }
}
/* jal : entity based _shadeangle */
/* insert the model */
InsertModel( model, skin, frame, transform, remap, celShader, mapEntityNum, castShadows, recvShadows, spawnFlags, lightmapScale, lightmapSampleSize, shadeAngle, colormod );
-
+
/* free shader remappings */
while ( remap != NULL )
{
#ifndef Q3MAP_VERSION
#error no Q3MAP_VERSION defined
#endif
-#define Q3MAP_MOTD "Your map saw the pretty lights from q3map2's BFG"
+#define Q3MAP_MOTD "Your map saw the pretty lights from q3map2's BFG"
/* general */
-#include "version.h" /* ttimo: might want to guard that if built outside of the GtkRadiant tree */
+#include "version.h" /* ttimo: might want to guard that if built outside of the GtkRadiant tree */
#include "cmdlib.h"
#include "mathlib.h"
------------------------------------------------------------------------------- */
-#define MAC_STATIC_HACK 0
-#if defined( __APPLE__ ) && MAC_STATIC_HACK
- #define MAC_STATIC static
+#define MAC_STATIC_HACK 0
+#if defined( __APPLE__ ) && MAC_STATIC_HACK
+ #define MAC_STATIC static
#else
- #define MAC_STATIC
+ #define MAC_STATIC
#endif
#if 1
#ifdef WIN32
- #define Q_stricmp stricmp
- #define Q_strncasecmp strnicmp
+ #define Q_stricmp stricmp
+ #define Q_strncasecmp strnicmp
#else
- #define Q_stricmp strcasecmp
- #define Q_strncasecmp strncasecmp
+ #define Q_stricmp strcasecmp
+ #define Q_strncasecmp strncasecmp
#endif
#endif
/* temporary hacks and tests (please keep off in SVN to prevent anyone's legacy map from screwing up) */
/* 2011-01-10 TTimo says we should turn these on in SVN, so turning on now */
-#define Q3MAP2_EXPERIMENTAL_HIGH_PRECISION_MATH_FIXES 1
-#define Q3MAP2_EXPERIMENTAL_SNAP_NORMAL_FIX 1
-#define Q3MAP2_EXPERIMENTAL_SNAP_PLANE_FIX 1
+#define Q3MAP2_EXPERIMENTAL_HIGH_PRECISION_MATH_FIXES 1
+#define Q3MAP2_EXPERIMENTAL_SNAP_NORMAL_FIX 1
+#define Q3MAP2_EXPERIMENTAL_SNAP_PLANE_FIX 1
/* general */
-#define MAX_QPATH 64
+#define MAX_QPATH 64
-#define MAX_IMAGES 512
-#define DEFAULT_IMAGE "*default"
+#define MAX_IMAGES 512
+#define DEFAULT_IMAGE "*default"
-#define MAX_MODELS 512
+#define MAX_MODELS 512
-#define DEF_BACKSPLASH_FRACTION 0.05f /* 5% backsplash by default */
-#define DEF_BACKSPLASH_DISTANCE 23
+#define DEF_BACKSPLASH_FRACTION 0.05f /* 5% backsplash by default */
+#define DEF_BACKSPLASH_DISTANCE 23
-#define DEF_RADIOSITY_BOUNCE 1.0f /* ydnar: default to 100% re-emitted light */
+#define DEF_RADIOSITY_BOUNCE 1.0f /* ydnar: default to 100% re-emitted light */
-#define MAX_SHADER_INFO 8192
+#define MAX_SHADER_INFO 8192
#define MAX_CUST_SURFACEPARMS 256
-#define SHADER_MAX_VERTEXES 1000
+#define SHADER_MAX_VERTEXES 1000
#define SHADER_MAX_INDEXES ( 6 * SHADER_MAX_VERTEXES )
-#define MAX_JITTERS 256
+#define MAX_JITTERS 256
/* epair parsing (note case-sensitivity directive) */
-#define CASE_INSENSITIVE_EPAIRS 1
+#define CASE_INSENSITIVE_EPAIRS 1
#if CASE_INSENSITIVE_EPAIRS
- #define EPAIR_STRCMP Q_stricmp
+ #define EPAIR_STRCMP Q_stricmp
#else
- #define EPAIR_STRCMP strcmp
+ #define EPAIR_STRCMP strcmp
#endif
/* ydnar: compiler flags, because games have widely varying content/surface flags */
-#define C_SOLID 0x00000001
-#define C_TRANSLUCENT 0x00000002
-#define C_STRUCTURAL 0x00000004
-#define C_HINT 0x00000008
-#define C_NODRAW 0x00000010
-#define C_LIGHTGRID 0x00000020
-#define C_ALPHASHADOW 0x00000040
-#define C_LIGHTFILTER 0x00000080
-#define C_VERTEXLIT 0x00000100
-#define C_LIQUID 0x00000200
-#define C_FOG 0x00000400
-#define C_SKY 0x00000800
-#define C_ORIGIN 0x00001000
-#define C_AREAPORTAL 0x00002000
-#define C_ANTIPORTAL 0x00004000 /* like hint, but doesn't generate portals */
-#define C_SKIP 0x00008000 /* like hint, but skips this face (doesn't split bsp) */
-#define C_NOMARKS 0x00010000 /* no decals */
-#define C_DETAIL 0x08000000 /* THIS MUST BE THE SAME AS IN RADIANT! */
+#define C_SOLID 0x00000001
+#define C_TRANSLUCENT 0x00000002
+#define C_STRUCTURAL 0x00000004
+#define C_HINT 0x00000008
+#define C_NODRAW 0x00000010
+#define C_LIGHTGRID 0x00000020
+#define C_ALPHASHADOW 0x00000040
+#define C_LIGHTFILTER 0x00000080
+#define C_VERTEXLIT 0x00000100
+#define C_LIQUID 0x00000200
+#define C_FOG 0x00000400
+#define C_SKY 0x00000800
+#define C_ORIGIN 0x00001000
+#define C_AREAPORTAL 0x00002000
+#define C_ANTIPORTAL 0x00004000 /* like hint, but doesn't generate portals */
+#define C_SKIP 0x00008000 /* like hint, but skips this face (doesn't split bsp) */
+#define C_NOMARKS 0x00010000 /* no decals */
+#define C_DETAIL 0x08000000 /* THIS MUST BE THE SAME AS IN RADIANT! */
/* shadow flags */
-#define WORLDSPAWN_CAST_SHADOWS 1
-#define WORLDSPAWN_RECV_SHADOWS 1
-#define ENTITY_CAST_SHADOWS 0
-#define ENTITY_RECV_SHADOWS 1
+#define WORLDSPAWN_CAST_SHADOWS 1
+#define WORLDSPAWN_RECV_SHADOWS 1
+#define ENTITY_CAST_SHADOWS 0
+#define ENTITY_RECV_SHADOWS 1
/* bsp */
-#define MAX_PATCH_SIZE 32
-#define MAX_BRUSH_SIDES 1024
-#define MAX_BUILD_SIDES 1024
+#define MAX_PATCH_SIZE 32
+#define MAX_BRUSH_SIDES 1024
+#define MAX_BUILD_SIDES 1024
-#define MAX_EXPANDED_AXIS 128
+#define MAX_EXPANDED_AXIS 128
-#define CLIP_EPSILON 0.1f
-#define PLANESIDE_EPSILON 0.001f
-#define PLANENUM_LEAF -1
+#define CLIP_EPSILON 0.1f
+#define PLANESIDE_EPSILON 0.001f
+#define PLANENUM_LEAF -1
-#define HINT_PRIORITY 1000 /* ydnar: force hint splits first and antiportal/areaportal splits last */
-#define ANTIPORTAL_PRIORITY -1000
-#define AREAPORTAL_PRIORITY -1000
-#define DETAIL_PRIORITY -3000
+#define HINT_PRIORITY 1000 /* ydnar: force hint splits first and antiportal/areaportal splits last */
+#define ANTIPORTAL_PRIORITY -1000
+#define AREAPORTAL_PRIORITY -1000
+#define DETAIL_PRIORITY -3000
-#define PSIDE_FRONT 1
-#define PSIDE_BACK 2
+#define PSIDE_FRONT 1
+#define PSIDE_BACK 2
#define PSIDE_BOTH ( PSIDE_FRONT | PSIDE_BACK )
-#define PSIDE_FACING 4
+#define PSIDE_FACING 4
-#define BPRIMIT_UNDEFINED 0
-#define BPRIMIT_OLDBRUSHES 1
-#define BPRIMIT_NEWBRUSHES 2
+#define BPRIMIT_UNDEFINED 0
+#define BPRIMIT_OLDBRUSHES 1
+#define BPRIMIT_NEWBRUSHES 2
/* vis */
-#define VIS_HEADER_SIZE 8
+#define VIS_HEADER_SIZE 8
-#define SEPERATORCACHE /* seperator caching helps a bit */
+#define SEPERATORCACHE /* seperator caching helps a bit */
-#define PORTALFILE "PRT1"
+#define PORTALFILE "PRT1"
-#define MAX_PORTALS 0x20000 /* same as MAX_MAP_PORTALS */
-#define MAX_SEPERATORS MAX_POINTS_ON_WINDING
-#define MAX_POINTS_ON_FIXED_WINDING 24 /* ydnar: increased this from 12 at the expense of more memory */
-#define MAX_PORTALS_ON_LEAF 1024
+#define MAX_PORTALS 0x20000 /* same as MAX_MAP_PORTALS */
+#define MAX_SEPERATORS MAX_POINTS_ON_WINDING
+#define MAX_POINTS_ON_FIXED_WINDING 24 /* ydnar: increased this from 12 at the expense of more memory */
+#define MAX_PORTALS_ON_LEAF 1024
/* light */
-#define EMIT_POINT 0
-#define EMIT_AREA 1
-#define EMIT_SPOT 2
-#define EMIT_SUN 3
-
-#define LIGHT_ATTEN_LINEAR 1
-#define LIGHT_ATTEN_ANGLE 2
-#define LIGHT_ATTEN_DISTANCE 4
-#define LIGHT_TWOSIDED 8
-#define LIGHT_GRID 16
-#define LIGHT_SURFACES 32
-#define LIGHT_DARK 64 /* probably never use this */
-#define LIGHT_FAST 256
-#define LIGHT_FAST_TEMP 512
+#define EMIT_POINT 0
+#define EMIT_AREA 1
+#define EMIT_SPOT 2
+#define EMIT_SUN 3
+
+#define LIGHT_ATTEN_LINEAR 1
+#define LIGHT_ATTEN_ANGLE 2
+#define LIGHT_ATTEN_DISTANCE 4
+#define LIGHT_TWOSIDED 8
+#define LIGHT_GRID 16
+#define LIGHT_SURFACES 32
+#define LIGHT_DARK 64 /* probably never use this */
+#define LIGHT_FAST 256
+#define LIGHT_FAST_TEMP 512
#define LIGHT_FAST_ACTUAL ( LIGHT_FAST | LIGHT_FAST_TEMP )
-#define LIGHT_NEGATIVE 1024
-#define LIGHT_UNNORMALIZED 2048 /* vortex: do not normalize _color */
+#define LIGHT_NEGATIVE 1024
+#define LIGHT_UNNORMALIZED 2048 /* vortex: do not normalize _color */
#define LIGHT_SUN_DEFAULT ( LIGHT_ATTEN_ANGLE | LIGHT_GRID | LIGHT_SURFACES )
#define LIGHT_AREA_DEFAULT ( LIGHT_ATTEN_ANGLE | LIGHT_ATTEN_DISTANCE | LIGHT_GRID | LIGHT_SURFACES ) /* q3a and wolf are the same */
#define LIGHT_Q3A_DEFAULT ( LIGHT_ATTEN_ANGLE | LIGHT_ATTEN_DISTANCE | LIGHT_GRID | LIGHT_SURFACES | LIGHT_FAST )
#define LIGHT_WOLF_DEFAULT ( LIGHT_ATTEN_LINEAR | LIGHT_ATTEN_DISTANCE | LIGHT_GRID | LIGHT_SURFACES | LIGHT_FAST )
-#define MAX_TRACE_TEST_NODES 256
-#define DEFAULT_INHIBIT_RADIUS 1.5f
+#define MAX_TRACE_TEST_NODES 256
+#define DEFAULT_INHIBIT_RADIUS 1.5f
-#define LUXEL_EPSILON 0.125f
-#define VERTEX_EPSILON -0.125f
-#define GRID_EPSILON 0.0f
+#define LUXEL_EPSILON 0.125f
+#define VERTEX_EPSILON -0.125f
+#define GRID_EPSILON 0.0f
-#define DEFAULT_LIGHTMAP_SAMPLE_SIZE 16
-#define DEFAULT_LIGHTMAP_MIN_SAMPLE_SIZE 0
-#define DEFAULT_LIGHTMAP_SAMPLE_OFFSET 1.0f
-#define DEFAULT_SUBDIVIDE_THRESHOLD 1.0f
+#define DEFAULT_LIGHTMAP_SAMPLE_SIZE 16
+#define DEFAULT_LIGHTMAP_MIN_SAMPLE_SIZE 0
+#define DEFAULT_LIGHTMAP_SAMPLE_OFFSET 1.0f
+#define DEFAULT_SUBDIVIDE_THRESHOLD 1.0f
-#define EXTRA_SCALE 2 /* -extrawide = -super 2 */
-#define EXTRAWIDE_SCALE 2 /* -extrawide = -super 2 -filter */
+#define EXTRA_SCALE 2 /* -extrawide = -super 2 */
+#define EXTRAWIDE_SCALE 2 /* -extrawide = -super 2 -filter */
-#define CLUSTER_UNMAPPED -1
-#define CLUSTER_OCCLUDED -2
-#define CLUSTER_FLOODED -3
+#define CLUSTER_UNMAPPED -1
+#define CLUSTER_OCCLUDED -2
+#define CLUSTER_FLOODED -3
-#define VERTEX_LUXEL_SIZE 3
-#define BSP_LUXEL_SIZE 3
-#define RAD_LUXEL_SIZE 3
-#define SUPER_LUXEL_SIZE 4
-#define SUPER_FLAG_SIZE 4
+#define VERTEX_LUXEL_SIZE 3
+#define BSP_LUXEL_SIZE 3
+#define RAD_LUXEL_SIZE 3
+#define SUPER_LUXEL_SIZE 4
+#define SUPER_FLAG_SIZE 4
#define FLAG_FORCE_SUBSAMPLING 1
#define FLAG_ALREADY_SUBSAMPLED 2
-#define SUPER_ORIGIN_SIZE 3
-#define SUPER_NORMAL_SIZE 4
-#define SUPER_DELUXEL_SIZE 3
-#define BSP_DELUXEL_SIZE 3
-#define SUPER_FLOODLIGHT_SIZE 4
+#define SUPER_ORIGIN_SIZE 3
+#define SUPER_NORMAL_SIZE 4
+#define SUPER_DELUXEL_SIZE 3
+#define BSP_DELUXEL_SIZE 3
+#define SUPER_FLOODLIGHT_SIZE 4
#define VERTEX_LUXEL( s, v ) ( vertexLuxels[ s ] + ( ( v ) * VERTEX_LUXEL_SIZE ) )
#define RAD_VERTEX_LUXEL( s, v )( radVertexLuxels[ s ] + ( ( v ) * VERTEX_LUXEL_SIZE ) )
------------------------------------------------------------------------------- */
-#define EXTERNAL_LIGHTMAP "lm_%04d.tga"
+#define EXTERNAL_LIGHTMAP "lm_%04d.tga"
-#define MAX_LIGHTMAPS 4 /* RBSP */
-#define MAX_LIGHT_STYLES 64
-#define MAX_SWITCHED_LIGHTS 32
-#define LS_NORMAL 0x00
-#define LS_UNUSED 0xFE
-#define LS_NONE 0xFF
+#define MAX_LIGHTMAPS 4 /* RBSP */
+#define MAX_LIGHT_STYLES 64
+#define MAX_SWITCHED_LIGHTS 32
+#define LS_NORMAL 0x00
+#define LS_UNUSED 0xFE
+#define LS_NONE 0xFF
-#define MAX_LIGHTMAP_SHADERS 256
+#define MAX_LIGHTMAP_SHADERS 256
/* ok to increase these at the expense of more memory */
-#define MAX_MAP_AREAS 0x100 /* MAX_MAP_AREA_BYTES in q_shared must match! */
-#define MAX_MAP_FOGS 30 //& 0x100 /* RBSP (32 - world fog - goggles) */
-#define MAX_MAP_LEAFS 0x20000
-#define MAX_MAP_PORTALS 0x20000
-#define MAX_MAP_LIGHTING 0x800000
-#define MAX_MAP_LIGHTGRID 0x100000 //% 0x800000 /* ydnar: set to points, not bytes */
+#define MAX_MAP_AREAS 0x100 /* MAX_MAP_AREA_BYTES in q_shared must match! */
+#define MAX_MAP_FOGS 30 //& 0x100 /* RBSP (32 - world fog - goggles) */
+#define MAX_MAP_LEAFS 0x20000
+#define MAX_MAP_PORTALS 0x20000
+#define MAX_MAP_LIGHTING 0x800000
+#define MAX_MAP_LIGHTGRID 0x100000 //% 0x800000 /* ydnar: set to points, not bytes */
#define MAX_MAP_VISCLUSTERS 0x4000 // <= MAX_MAP_LEAFS
#define MAX_MAP_VISIBILITY ( VIS_HEADER_SIZE + MAX_MAP_VISCLUSTERS * ( ( ( MAX_MAP_VISCLUSTERS + 63 ) & ~63 ) >> 3 ) )
-#define MAX_MAP_DRAW_SURFS 0x20000
+#define MAX_MAP_DRAW_SURFS 0x20000
-#define MAX_MAP_ADVERTISEMENTS 30
+#define MAX_MAP_ADVERTISEMENTS 30
/* key / value pair sizes in the entities lump */
-#define MAX_KEY 32
-#define MAX_VALUE 1024
+#define MAX_KEY 32
+#define MAX_VALUE 1024
/* the editor uses these predefined yaw angles to orient entities up or down */
-#define ANGLE_UP -1
-#define ANGLE_DOWN -2
+#define ANGLE_UP -1
+#define ANGLE_DOWN -2
-#define LIGHTMAP_WIDTH 128
-#define LIGHTMAP_HEIGHT 128
+#define LIGHTMAP_WIDTH 128
+#define LIGHTMAP_HEIGHT 128
#define MIN_WORLD_COORD ( -65536 )
#define MAX_WORLD_COORD ( 65536 )
typedef struct
{
- int offset, length;
+ int offset, length;
}
bspLump_t;
typedef struct
{
- char ident[ 4 ];
- int version;
-
- bspLump_t lumps[ 100 ]; /* theoretical maximum # of bsp lumps */
+ char ident[ 4 ];
+ int version;
+
+ bspLump_t lumps[ 100 ]; /* theoretical maximum # of bsp lumps */
}
bspHeader_t;
typedef struct
{
- float mins[ 3 ], maxs[ 3 ];
- int firstBSPSurface, numBSPSurfaces;
- int firstBSPBrush, numBSPBrushes;
+ float mins[ 3 ], maxs[ 3 ];
+ int firstBSPSurface, numBSPSurfaces;
+ int firstBSPBrush, numBSPBrushes;
}
bspModel_t;
typedef struct
{
- char shader[ MAX_QPATH ];
- int surfaceFlags;
- int contentFlags;
+ char shader[ MAX_QPATH ];
+ int surfaceFlags;
+ int contentFlags;
}
bspShader_t;
typedef struct
{
- float normal[ 3 ];
- float dist;
+ float normal[ 3 ];
+ float dist;
}
bspPlane_t;
typedef struct
{
- int planeNum;
- int children[ 2 ]; /* negative numbers are -(leafs+1), not nodes */
- int mins[ 3 ]; /* for frustom culling */
- int maxs[ 3 ];
+ int planeNum;
+ int children[ 2 ]; /* negative numbers are -(leafs+1), not nodes */
+ int mins[ 3 ]; /* for frustom culling */
+ int maxs[ 3 ];
}
bspNode_t;
typedef struct
{
- int cluster; /* -1 = opaque cluster (do I still store these?) */
- int area;
-
- int mins[ 3 ]; /* for frustum culling */
- int maxs[ 3 ];
-
- int firstBSPLeafSurface;
- int numBSPLeafSurfaces;
-
- int firstBSPLeafBrush;
- int numBSPLeafBrushes;
+ int cluster; /* -1 = opaque cluster (do I still store these?) */
+ int area;
+
+ int mins[ 3 ]; /* for frustum culling */
+ int maxs[ 3 ];
+
+ int firstBSPLeafSurface;
+ int numBSPLeafSurfaces;
+
+ int firstBSPLeafBrush;
+ int numBSPLeafBrushes;
}
bspLeaf_t;
typedef struct
{
- int planeNum; /* positive plane side faces out of the leaf */
- int shaderNum;
- int surfaceNum; /* RBSP */
+ int planeNum; /* positive plane side faces out of the leaf */
+ int shaderNum;
+ int surfaceNum; /* RBSP */
}
bspBrushSide_t;
typedef struct
{
- int firstSide;
- int numSides;
- int shaderNum; /* the shader that determines the content flags */
+ int firstSide;
+ int numSides;
+ int shaderNum; /* the shader that determines the content flags */
}
bspBrush_t;
typedef struct
{
- char shader[ MAX_QPATH ];
- int brushNum;
- int visibleSide; /* the brush side that ray tests need to clip against (-1 == none) */
+ char shader[ MAX_QPATH ];
+ int brushNum;
+ int visibleSide; /* the brush side that ray tests need to clip against (-1 == none) */
}
bspFog_t;
typedef struct
{
- vec3_t xyz;
- float st[ 2 ];
- float lightmap[ MAX_LIGHTMAPS ][ 2 ]; /* RBSP */
- vec3_t normal;
- byte color[ MAX_LIGHTMAPS ][ 4 ]; /* RBSP */
+ vec3_t xyz;
+ float st[ 2 ];
+ float lightmap[ MAX_LIGHTMAPS ][ 2 ]; /* RBSP */
+ vec3_t normal;
+ byte color[ MAX_LIGHTMAPS ][ 4 ]; /* RBSP */
}
bspDrawVert_t;
typedef struct bspGridPoint_s
{
- byte ambient[ MAX_LIGHTMAPS ][ 3 ];
- byte directed[ MAX_LIGHTMAPS ][ 3 ];
- byte styles[ MAX_LIGHTMAPS ];
- byte latLong[ 2 ];
+ byte ambient[ MAX_LIGHTMAPS ][ 3 ];
+ byte directed[ MAX_LIGHTMAPS ][ 3 ];
+ byte styles[ MAX_LIGHTMAPS ];
+ byte latLong[ 2 ];
}
bspGridPoint_t;
typedef struct
{
- int shaderNum;
- int fogNum;
- int surfaceType;
-
- int firstVert;
- int numVerts;
-
- int firstIndex;
- int numIndexes;
-
- byte lightmapStyles[ MAX_LIGHTMAPS ]; /* RBSP */
- byte vertexStyles[ MAX_LIGHTMAPS ]; /* RBSP */
- int lightmapNum[ MAX_LIGHTMAPS ]; /* RBSP */
- int lightmapX[ MAX_LIGHTMAPS ], lightmapY[ MAX_LIGHTMAPS ]; /* RBSP */
- int lightmapWidth, lightmapHeight;
-
- vec3_t lightmapOrigin;
- vec3_t lightmapVecs[ 3 ]; /* on patches, [ 0 ] and [ 1 ] are lodbounds */
-
- int patchWidth;
- int patchHeight;
+ int shaderNum;
+ int fogNum;
+ int surfaceType;
+
+ int firstVert;
+ int numVerts;
+
+ int firstIndex;
+ int numIndexes;
+
+ byte lightmapStyles[ MAX_LIGHTMAPS ]; /* RBSP */
+ byte vertexStyles[ MAX_LIGHTMAPS ]; /* RBSP */
+ int lightmapNum[ MAX_LIGHTMAPS ]; /* RBSP */
+ int lightmapX[ MAX_LIGHTMAPS ], lightmapY[ MAX_LIGHTMAPS ]; /* RBSP */
+ int lightmapWidth, lightmapHeight;
+
+ vec3_t lightmapOrigin;
+ vec3_t lightmapVecs[ 3 ]; /* on patches, [ 0 ] and [ 1 ] are lodbounds */
+
+ int patchWidth;
+ int patchHeight;
}
bspDrawSurface_t;
/* advertisements */
typedef struct {
- int cellId;
- vec3_t normal;
- vec3_t rect[4];
- char model[ MAX_QPATH ];
+ int cellId;
+ vec3_t normal;
+ vec3_t rect[4];
+ char model[ MAX_QPATH ];
} bspAdvertisement_t;
------------------------------------------------------------------------------- */
/* ydnar: for smaller structs */
-typedef unsigned char qb_t;
+typedef unsigned char qb_t;
/* ydnar: for q3map_tcMod */
-typedef float tcMod_t[ 3 ][ 3 ];
+typedef float tcMod_t[ 3 ][ 3 ];
/* ydnar: for multiple game support */
typedef struct surfaceParm_s
{
- char *name;
- int contentFlags, contentFlagsClear;
- int surfaceFlags, surfaceFlagsClear;
- int compileFlags, compileFlagsClear;
+ char *name;
+ int contentFlags, contentFlagsClear;
+ int surfaceFlags, surfaceFlagsClear;
+ int compileFlags, compileFlagsClear;
}
surfaceParm_t;
typedef struct game_s
{
- char *arg; /* -game matches this */
- char *gamePath; /* main game data dir */
- char *homeBasePath; /* home sub-dir on unix */
- char *magic; /* magic word for figuring out base path */
- char *shaderPath; /* shader directory */
- int maxLMSurfaceVerts; /* default maximum meta surface verts */
- int maxSurfaceVerts; /* default maximum surface verts */
- int maxSurfaceIndexes; /* default maximum surface indexes (tris * 3) */
- qboolean emitFlares; /* when true, emit flare surfaces */
- char *flareShader; /* default flare shader (MUST BE SET) */
- qboolean wolfLight; /* when true, lights work like wolf q3map */
- int lightmapSize; /* bsp lightmap width/height */
- float lightmapGamma; /* default lightmap gamma */
+ char *arg; /* -game matches this */
+ char *gamePath; /* main game data dir */
+ char *homeBasePath; /* home sub-dir on unix */
+ char *magic; /* magic word for figuring out base path */
+ char *shaderPath; /* shader directory */
+ int maxLMSurfaceVerts; /* default maximum meta surface verts */
+ int maxSurfaceVerts; /* default maximum surface verts */
+ int maxSurfaceIndexes; /* default maximum surface indexes (tris * 3) */
+ qboolean emitFlares; /* when true, emit flare surfaces */
+ char *flareShader; /* default flare shader (MUST BE SET) */
+ qboolean wolfLight; /* when true, lights work like wolf q3map */
+ int lightmapSize; /* bsp lightmap width/height */
+ float lightmapGamma; /* default lightmap gamma */
qboolean lightmapsRGB; /* default lightmap sRGB mode */
qboolean texturesRGB; /* default texture sRGB mode */
qboolean colorsRGB; /* default color sRGB mode */
- float lightmapExposure; /* default lightmap exposure */
- float lightmapCompensate; /* default lightmap compensate value */
- float gridScale; /* vortex: default lightgrid scale (affects both directional and ambient spectres) */
- float gridAmbientScale; /* vortex: default lightgrid ambient spectre scale */
- qboolean lightAngleHL; /* jal: use half-lambert curve for light angle attenuation */
- qboolean noStyles; /* use lightstyles hack or not */
- qboolean keepLights; /* keep light entities on bsp */
- int patchSubdivisions; /* default patch subdivisions tolerance */
- qboolean patchShadows; /* patch casting enabled */
- qboolean deluxeMap; /* compile deluxemaps */
- int deluxeMode; /* deluxemap mode (0 - modelspace, 1 - tangentspace with renormalization, 2 - tangentspace without renormalization) */
- int miniMapSize; /* minimap size */
- float miniMapSharpen; /* minimap sharpening coefficient */
- float miniMapBorder; /* minimap border amount */
- qboolean miniMapKeepAspect; /* minimap keep aspect ratio by letterboxing */
- miniMapMode_t miniMapMode; /* minimap mode */
+ float lightmapExposure; /* default lightmap exposure */
+ float lightmapCompensate; /* default lightmap compensate value */
+ float gridScale; /* vortex: default lightgrid scale (affects both directional and ambient spectres) */
+ float gridAmbientScale; /* vortex: default lightgrid ambient spectre scale */
+ qboolean lightAngleHL; /* jal: use half-lambert curve for light angle attenuation */
+ qboolean noStyles; /* use lightstyles hack or not */
+ qboolean keepLights; /* keep light entities on bsp */
+ int patchSubdivisions; /* default patch subdivisions tolerance */
+ qboolean patchShadows; /* patch casting enabled */
+ qboolean deluxeMap; /* compile deluxemaps */
+ int deluxeMode; /* deluxemap mode (0 - modelspace, 1 - tangentspace with renormalization, 2 - tangentspace without renormalization) */
+ int miniMapSize; /* minimap size */
+ float miniMapSharpen; /* minimap sharpening coefficient */
+ float miniMapBorder; /* minimap border amount */
+ qboolean miniMapKeepAspect; /* minimap keep aspect ratio by letterboxing */
+ miniMapMode_t miniMapMode; /* minimap mode */
char *miniMapNameFormat; /* minimap name format */
- char *bspIdent; /* 4-letter bsp file prefix */
- int bspVersion; /* bsp version to use */
- qboolean lumpSwap; /* cod-style len/ofs order */
- bspFunc load, write; /* load/write function pointers */
- surfaceParm_t surfaceParms[ 128 ]; /* surfaceparm array */
+ char *bspIdent; /* 4-letter bsp file prefix */
+ int bspVersion; /* bsp version to use */
+ qboolean lumpSwap; /* cod-style len/ofs order */
+ bspFunc load, write; /* load/write function pointers */
+ surfaceParm_t surfaceParms[ 128 ]; /* surfaceparm array */
}
game_t;
typedef struct image_s
{
- char *name, *filename;
- int refCount;
- int width, height;
- byte *pixels;
+ char *name, *filename;
+ int refCount;
+ int width, height;
+ byte *pixels;
}
image_t;
typedef struct sun_s
{
- struct sun_s *next;
- vec3_t direction, color;
- float photons, deviance, filterRadius;
- int numSamples, style;
+ struct sun_s *next;
+ vec3_t direction, color;
+ float photons, deviance, filterRadius;
+ int numSamples, style;
}
sun_t;
-typedef struct surfaceModel_s
+typedef struct surfaceModel_s
{
- struct surfaceModel_s *next;
- char model[ MAX_QPATH ];
- float density, odds;
- float minScale, maxScale;
- float minAngle, maxAngle;
- qboolean oriented;
+ struct surfaceModel_s *next;
+ char model[ MAX_QPATH ];
+ float density, odds;
+ float minScale, maxScale;
+ float minAngle, maxAngle;
+ qboolean oriented;
}
surfaceModel_t;
/* ydnar/sd: foliage stuff for wolf et (engine-supported optimization of the above) */
-typedef struct foliage_s
+typedef struct foliage_s
{
- struct foliage_s *next;
- char model[ MAX_QPATH ];
- float scale, density, odds;
- qboolean inverseAlpha;
+ struct foliage_s *next;
+ char model[ MAX_QPATH ];
+ float scale, density, odds;
+ qboolean inverseAlpha;
}
foliage_t;
typedef struct foliageInstance_s
{
- vec3_t xyz, normal;
+ vec3_t xyz, normal;
}
foliageInstance_t;
typedef struct remap_s
{
- struct remap_s *next;
- char from[ 1024 ];
- char to[ MAX_QPATH ];
+ struct remap_s *next;
+ char from[ 1024 ];
+ char to[ MAX_QPATH ];
}
remap_t;
typedef struct skinfile_s
{
- struct skinfile_s *next;
- char name[ 1024 ];
- char to[ MAX_QPATH ];
+ struct skinfile_s *next;
+ char name[ 1024 ];
+ char to[ MAX_QPATH ];
}
skinfile_t;
typedef struct colorMod_s
{
- struct colorMod_s *next;
- colorModType_t type;
- vec_t data[ 16 ];
+ struct colorMod_s *next;
+ colorModType_t type;
+ vec_t data[ 16 ];
}
colorMod_t;
typedef struct shaderInfo_s
{
- char shader[ MAX_QPATH ];
- int surfaceFlags;
- int contentFlags;
- int compileFlags;
- float value; /* light value */
-
- char *flareShader; /* for light flares */
- char *damageShader; /* ydnar: sof2 damage shader name */
- char *backShader; /* for surfaces that generate different front and back passes */
- char *cloneShader; /* ydnar: for cloning of a surface */
- char *remapShader; /* ydnar: remap a shader in final stage */
- char *deprecateShader; /* vortex: shader is deprecated and replaced by this on use */
-
- surfaceModel_t *surfaceModel; /* ydnar: for distribution of models */
- foliage_t *foliage; /* ydnar/splash damage: wolf et foliage */
-
- float subdivisions; /* from a "tesssize xxx" */
- float backsplashFraction; /* floating point value, usually 0.05 */
- float backsplashDistance; /* default 16 */
- float lightSubdivide; /* default 999 */
- float lightFilterRadius; /* ydnar: lightmap filtering/blurring radius for lights created by this shader (default: 0) */
-
- int lightmapSampleSize; /* lightmap sample size */
- float lightmapSampleOffset; /* ydnar: lightmap sample offset (default: 1.0) */
-
- float bounceScale; /* ydnar: radiosity re-emission [0,1.0+] */
- float offset; /* ydnar: offset in units */
- float shadeAngleDegrees; /* ydnar: breaking angle for smooth shading (degrees) */
-
- vec3_t mins, maxs; /* ydnar: for particle studio vertexDeform move support */
-
- qb_t legacyTerrain; /* ydnar: enable legacy terrain crutches */
- qb_t indexed; /* ydnar: attempt to use indexmap (terrain alphamap style) */
- qb_t forceMeta; /* ydnar: force metasurface path */
- qb_t noClip; /* ydnar: don't clip into bsp, preserve original face winding */
- qb_t noFast; /* ydnar: supress fast lighting for surfaces with this shader */
- qb_t invert; /* ydnar: reverse facing */
- qb_t nonplanar; /* ydnar: for nonplanar meta surface merging */
- qb_t tcGen; /* ydnar: has explicit texcoord generation */
- vec3_t vecs[ 2 ]; /* ydnar: explicit texture vectors for [0,1] texture space */
- tcMod_t mod; /* ydnar: q3map_tcMod matrix for djbob :) */
- vec3_t lightmapAxis; /* ydnar: explicit lightmap axis projection */
- colorMod_t *colorMod; /* ydnar: q3map_rgb/color/alpha/Set/Mod support */
-
- int furNumLayers; /* ydnar: number of fur layers */
- float furOffset; /* ydnar: offset of each layer */
- float furFade; /* ydnar: alpha fade amount per layer */
-
- qb_t splotchFix; /* ydnar: filter splotches on lightmaps */
-
- qb_t hasPasses; /* false if the shader doesn't define any rendering passes */
- qb_t globalTexture; /* don't normalize texture repeats */
- qb_t twoSided; /* cull none */
- qb_t autosprite; /* autosprite shaders will become point lights instead of area lights */
- qb_t polygonOffset; /* ydnar: don't face cull this or against this */
- qb_t patchShadows; /* have patches casting shadows when using -light for this surface */
- qb_t vertexShadows; /* shadows will be casted at this surface even when vertex lit */
- qb_t forceSunlight; /* force sun light at this surface even tho we might not calculate shadows in vertex lighting */
- qb_t notjunc; /* don't use this surface for tjunction fixing */
- qb_t fogParms; /* ydnar: has fogparms */
- qb_t noFog; /* ydnar: supress fogging */
- qb_t clipModel; /* ydnar: solid model hack */
- qb_t noVertexLight; /* ydnar: leave vertex color alone */
- qb_t noDirty; /* jal: do not apply the dirty pass to this surface */
-
- byte styleMarker; /* ydnar: light styles hack */
-
- float vertexScale; /* vertex light scale */
-
- char skyParmsImageBase[ MAX_QPATH ]; /* ydnar: for skies */
-
- char editorImagePath[ MAX_QPATH ]; /* use this image to generate texture coordinates */
- char lightImagePath[ MAX_QPATH ]; /* use this image to generate color / averageColor */
- char normalImagePath[ MAX_QPATH ]; /* ydnar: normalmap image for bumpmapping */
-
- implicitMap_t implicitMap; /* ydnar: enemy territory implicit shaders */
- char implicitImagePath[ MAX_QPATH ];
-
- image_t *shaderImage;
- image_t *lightImage;
- image_t *normalImage;
-
- float skyLightValue; /* ydnar */
- int skyLightIterations; /* ydnar */
- sun_t *sun; /* ydnar */
-
- vec3_t color; /* normalized color */
- vec3_t averageColor;
- byte lightStyle;
+ char shader[ MAX_QPATH ];
+ int surfaceFlags;
+ int contentFlags;
+ int compileFlags;
+ float value; /* light value */
+
+ char *flareShader; /* for light flares */
+ char *damageShader; /* ydnar: sof2 damage shader name */
+ char *backShader; /* for surfaces that generate different front and back passes */
+ char *cloneShader; /* ydnar: for cloning of a surface */
+ char *remapShader; /* ydnar: remap a shader in final stage */
+ char *deprecateShader; /* vortex: shader is deprecated and replaced by this on use */
+
+ surfaceModel_t *surfaceModel; /* ydnar: for distribution of models */
+ foliage_t *foliage; /* ydnar/splash damage: wolf et foliage */
+
+ float subdivisions; /* from a "tesssize xxx" */
+ float backsplashFraction; /* floating point value, usually 0.05 */
+ float backsplashDistance; /* default 16 */
+ float lightSubdivide; /* default 999 */
+ float lightFilterRadius; /* ydnar: lightmap filtering/blurring radius for lights created by this shader (default: 0) */
+
+ int lightmapSampleSize; /* lightmap sample size */
+ float lightmapSampleOffset; /* ydnar: lightmap sample offset (default: 1.0) */
+
+ float bounceScale; /* ydnar: radiosity re-emission [0,1.0+] */
+ float offset; /* ydnar: offset in units */
+ float shadeAngleDegrees; /* ydnar: breaking angle for smooth shading (degrees) */
+
+ vec3_t mins, maxs; /* ydnar: for particle studio vertexDeform move support */
+
+ qb_t legacyTerrain; /* ydnar: enable legacy terrain crutches */
+ qb_t indexed; /* ydnar: attempt to use indexmap (terrain alphamap style) */
+ qb_t forceMeta; /* ydnar: force metasurface path */
+ qb_t noClip; /* ydnar: don't clip into bsp, preserve original face winding */
+ qb_t noFast; /* ydnar: supress fast lighting for surfaces with this shader */
+ qb_t invert; /* ydnar: reverse facing */
+ qb_t nonplanar; /* ydnar: for nonplanar meta surface merging */
+ qb_t tcGen; /* ydnar: has explicit texcoord generation */
+ vec3_t vecs[ 2 ]; /* ydnar: explicit texture vectors for [0,1] texture space */
+ tcMod_t mod; /* ydnar: q3map_tcMod matrix for djbob :) */
+ vec3_t lightmapAxis; /* ydnar: explicit lightmap axis projection */
+ colorMod_t *colorMod; /* ydnar: q3map_rgb/color/alpha/Set/Mod support */
+
+ int furNumLayers; /* ydnar: number of fur layers */
+ float furOffset; /* ydnar: offset of each layer */
+ float furFade; /* ydnar: alpha fade amount per layer */
+
+ qb_t splotchFix; /* ydnar: filter splotches on lightmaps */
+
+ qb_t hasPasses; /* false if the shader doesn't define any rendering passes */
+ qb_t globalTexture; /* don't normalize texture repeats */
+ qb_t twoSided; /* cull none */
+ qb_t autosprite; /* autosprite shaders will become point lights instead of area lights */
+ qb_t polygonOffset; /* ydnar: don't face cull this or against this */
+ qb_t patchShadows; /* have patches casting shadows when using -light for this surface */
+ qb_t vertexShadows; /* shadows will be casted at this surface even when vertex lit */
+ qb_t forceSunlight; /* force sun light at this surface even tho we might not calculate shadows in vertex lighting */
+ qb_t notjunc; /* don't use this surface for tjunction fixing */
+ qb_t fogParms; /* ydnar: has fogparms */
+ qb_t noFog; /* ydnar: supress fogging */
+ qb_t clipModel; /* ydnar: solid model hack */
+ qb_t noVertexLight; /* ydnar: leave vertex color alone */
+ qb_t noDirty; /* jal: do not apply the dirty pass to this surface */
+
+ byte styleMarker; /* ydnar: light styles hack */
+
+ float vertexScale; /* vertex light scale */
+
+ char skyParmsImageBase[ MAX_QPATH ]; /* ydnar: for skies */
+
+ char editorImagePath[ MAX_QPATH ]; /* use this image to generate texture coordinates */
+ char lightImagePath[ MAX_QPATH ]; /* use this image to generate color / averageColor */
+ char normalImagePath[ MAX_QPATH ]; /* ydnar: normalmap image for bumpmapping */
+
+ implicitMap_t implicitMap; /* ydnar: enemy territory implicit shaders */
+ char implicitImagePath[ MAX_QPATH ];
+
+ image_t *shaderImage;
+ image_t *lightImage;
+ image_t *normalImage;
+
+ float skyLightValue; /* ydnar */
+ int skyLightIterations; /* ydnar */
+ sun_t *sun; /* ydnar */
+
+ vec3_t color; /* normalized color */
+ vec3_t averageColor;
+ byte lightStyle;
/* vortex: per-surface floodlight */
- float floodlightDirectionScale;
- vec3_t floodlightRGB;
- float floodlightIntensity;
- float floodlightDistance;
-
- qb_t lmMergable; /* ydnar */
- int lmCustomWidth, lmCustomHeight; /* ydnar */
- float lmBrightness; /* ydnar */
- float lmFilterRadius; /* ydnar: lightmap filtering/blurring radius for this shader (default: 0) */
-
- int shaderWidth, shaderHeight; /* ydnar */
- float stFlat[ 2 ];
-
- vec3_t fogDir; /* ydnar */
-
- char *shaderText; /* ydnar */
- qb_t custom;
- qb_t finished;
+ float floodlightDirectionScale;
+ vec3_t floodlightRGB;
+ float floodlightIntensity;
+ float floodlightDistance;
+
+ qb_t lmMergable; /* ydnar */
+ int lmCustomWidth, lmCustomHeight; /* ydnar */
+ float lmBrightness; /* ydnar */
+ float lmFilterRadius; /* ydnar: lightmap filtering/blurring radius for this shader (default: 0) */
+
+ int shaderWidth, shaderHeight; /* ydnar */
+ float stFlat[ 2 ];
+
+ vec3_t fogDir; /* ydnar */
+
+ char *shaderText; /* ydnar */
+ qb_t custom;
+ qb_t finished;
}
shaderInfo_t;
typedef struct face_s
{
- struct face_s *next;
- int planenum;
- int priority;
+ struct face_s *next;
+ int planenum;
+ int priority;
//qboolean checked;
- int compileFlags;
- winding_t *w;
+ int compileFlags;
+ winding_t *w;
}
face_t;
typedef struct plane_s
{
- vec3_t normal;
- vec_t dist;
- int type;
- int counter;
- int hash_chain;
+ vec3_t normal;
+ vec_t dist;
+ int type;
+ int counter;
+ int hash_chain;
}
plane_t;
typedef struct side_s
{
- int planenum;
-
- int outputNum; /* set when the side is written to the file list */
-
- float texMat[ 2 ][ 3 ]; /* brush primitive texture matrix */
- float vecs[ 2 ][ 4 ]; /* old-style texture coordinate mapping */
-
- winding_t *winding;
- winding_t *visibleHull; /* convex hull of all visible fragments */
-
- shaderInfo_t *shaderInfo;
-
- int contentFlags; /* from shaderInfo */
- int surfaceFlags; /* from shaderInfo */
- int compileFlags; /* from shaderInfo */
- int value; /* from shaderInfo */
-
- qboolean visible; /* choose visble planes first */
- qboolean bevel; /* don't ever use for bsp splitting, and don't bother making windings for it */
- qboolean culled; /* ydnar: face culling */
+ int planenum;
+
+ int outputNum; /* set when the side is written to the file list */
+
+ float texMat[ 2 ][ 3 ]; /* brush primitive texture matrix */
+ float vecs[ 2 ][ 4 ]; /* old-style texture coordinate mapping */
+
+ winding_t *winding;
+ winding_t *visibleHull; /* convex hull of all visible fragments */
+
+ shaderInfo_t *shaderInfo;
+
+ int contentFlags; /* from shaderInfo */
+ int surfaceFlags; /* from shaderInfo */
+ int compileFlags; /* from shaderInfo */
+ int value; /* from shaderInfo */
+
+ qboolean visible; /* choose visble planes first */
+ qboolean bevel; /* don't ever use for bsp splitting, and don't bother making windings for it */
+ qboolean culled; /* ydnar: face culling */
}
side_t;
typedef struct sideRef_s
{
- struct sideRef_s *next;
- side_t *side;
+ struct sideRef_s *next;
+ side_t *side;
}
sideRef_t;
/* ydnar: generic index mapping for entities (natural extension of terrain texturing) */
typedef struct indexMap_s
{
- int w, h, numLayers;
- char name[ MAX_QPATH ], shader[ MAX_QPATH ];
- float offsets[ 256 ];
- byte *pixels;
+ int w, h, numLayers;
+ char name[ MAX_QPATH ], shader[ MAX_QPATH ];
+ float offsets[ 256 ];
+ byte *pixels;
}
indexMap_t;
typedef struct brush_s
{
- struct brush_s *next;
- struct brush_s *nextColorModBrush; /* ydnar: colorMod volume brushes go here */
- struct brush_s *original; /* chopped up brushes will reference the originals */
-
+ struct brush_s *next;
+ struct brush_s *nextColorModBrush; /* ydnar: colorMod volume brushes go here */
+ struct brush_s *original; /* chopped up brushes will reference the originals */
+
int entityNum, brushNum; /* editor numbering */
- int outputNum; /* set when the brush is written to the file list */
-
+ int outputNum; /* set when the brush is written to the file list */
+
/* ydnar: for shadowcasting entities */
- int castShadows;
- int recvShadows;
-
- shaderInfo_t *contentShader;
- shaderInfo_t *celShader; /* :) */
-
+ int castShadows;
+ int recvShadows;
+
+ shaderInfo_t *contentShader;
+ shaderInfo_t *celShader; /* :) */
+
/* ydnar: gs mods */
- int lightmapSampleSize; /* jal : entity based _lightmapsamplesize */
- float lightmapScale;
+ int lightmapSampleSize; /* jal : entity based _lightmapsamplesize */
+ float lightmapScale;
vec3_t colormod;
- float shadeAngleDegrees; /* jal : entity based _shadeangle */
- vec3_t eMins, eMaxs;
- indexMap_t *im;
+ float shadeAngleDegrees; /* jal : entity based _shadeangle */
+ vec3_t eMins, eMaxs;
+ indexMap_t *im;
- int contentFlags;
- int compileFlags; /* ydnar */
- qboolean detail;
- qboolean opaque;
+ int contentFlags;
+ int compileFlags; /* ydnar */
+ qboolean detail;
+ qboolean opaque;
- int portalareas[ 2 ];
+ int portalareas[ 2 ];
- vec3_t mins, maxs;
- int numsides;
+ vec3_t mins, maxs;
+ int numsides;
- side_t sides[ 6 ]; /* variably sized */
+ side_t sides[ 6 ]; /* variably sized */
}
brush_t;
typedef struct fog_s
{
- shaderInfo_t *si;
- brush_t *brush;
- int visibleSide; /* the brush side that ray tests need to clip against (-1 == none) */
+ shaderInfo_t *si;
+ brush_t *brush;
+ int visibleSide; /* the brush side that ray tests need to clip against (-1 == none) */
}
fog_t;
typedef struct
{
- int width, height;
- bspDrawVert_t *verts;
+ int width, height;
+ bspDrawVert_t *verts;
}
mesh_t;
typedef struct parseMesh_s
{
- struct parseMesh_s *next;
-
- int entityNum, brushNum; /* ydnar: editor numbering */
-
+ struct parseMesh_s *next;
+
+ int entityNum, brushNum; /* ydnar: editor numbering */
+
/* ydnar: for shadowcasting entities */
- int castShadows;
- int recvShadows;
-
- mesh_t mesh;
- shaderInfo_t *shaderInfo;
- shaderInfo_t *celShader; /* :) */
-
+ int castShadows;
+ int recvShadows;
+
+ mesh_t mesh;
+ shaderInfo_t *shaderInfo;
+ shaderInfo_t *celShader; /* :) */
+
/* ydnar: gs mods */
- int lightmapSampleSize; /* jal : entity based _lightmapsamplesize */
- float lightmapScale;
+ int lightmapSampleSize; /* jal : entity based _lightmapsamplesize */
+ float lightmapScale;
vec3_t colormod;
- vec3_t eMins, eMaxs;
- indexMap_t *im;
-
+ vec3_t eMins, eMaxs;
+ indexMap_t *im;
+
/* grouping */
- qboolean grouped;
- float longestCurve;
- int maxIterations;
+ qboolean grouped;
+ float longestCurve;
+ int maxIterations;
}
parseMesh_t;
/*
- ydnar: the drawsurf struct was extended to allow for:
- - non-convex planar surfaces
- - non-planar brushface surfaces
- - lightmapped terrain
- - planar patches
+ ydnar: the drawsurf struct was extended to allow for:
+ - non-convex planar surfaces
+ - non-planar brushface surfaces
+ - lightmapped terrain
+ - planar patches
*/
typedef enum
SURFACE_PATCH,
SURFACE_TRIANGLES,
SURFACE_FLARE,
- SURFACE_FOLIAGE, /* wolf et */
-
+ SURFACE_FOLIAGE, /* wolf et */
+
/* ydnar: compiler-relevant surface types */
SURFACE_FORCED_META,
SURFACE_META,
SURFACE_FOGHULL,
SURFACE_DECAL,
SURFACE_SHADER,
-
+
NUM_SURFACE_TYPES
}
surfaceType_t;
-char *surfaceTypes[ NUM_SURFACE_TYPES ]
+char *surfaceTypes[ NUM_SURFACE_TYPES ]
#ifndef MAIN_C
;
#else
- =
- {
- "SURFACE_BAD",
- "SURFACE_FACE",
- "SURFACE_PATCH",
- "SURFACE_TRIANGLES",
- "SURFACE_FLARE",
- "SURFACE_FOLIAGE",
- "SURFACE_FORCED_META",
- "SURFACE_META",
- "SURFACE_FOGHULL",
- "SURFACE_DECAL",
- "SURFACE_SHADER"
- };
+ =
+ {
+ "SURFACE_BAD",
+ "SURFACE_FACE",
+ "SURFACE_PATCH",
+ "SURFACE_TRIANGLES",
+ "SURFACE_FLARE",
+ "SURFACE_FOLIAGE",
+ "SURFACE_FORCED_META",
+ "SURFACE_META",
+ "SURFACE_FOGHULL",
+ "SURFACE_DECAL",
+ "SURFACE_SHADER"
+ };
#endif
/* ydnar: this struct needs an overhaul (again, heh) */
typedef struct mapDrawSurface_s
{
- surfaceType_t type;
- qboolean planar;
- int outputNum; /* ydnar: to match this sort of thing up */
-
- qboolean fur; /* ydnar: this is kind of a hack, but hey... */
- qboolean skybox; /* ydnar: yet another fun hack */
- qboolean backSide; /* ydnar: q3map_backShader support */
-
- struct mapDrawSurface_s *parent; /* ydnar: for cloned (skybox) surfaces to share lighting data */
- struct mapDrawSurface_s *clone; /* ydnar: for cloned surfaces */
- struct mapDrawSurface_s *cel; /* ydnar: for cloned cel surfaces */
-
- shaderInfo_t *shaderInfo;
- shaderInfo_t *celShader;
- brush_t *mapBrush;
- parseMesh_t *mapMesh;
- sideRef_t *sideRef;
-
- int fogNum;
-
- int numVerts; /* vertexes and triangles */
- bspDrawVert_t *verts;
- int numIndexes;
- int *indexes;
-
- int planeNum;
- vec3_t lightmapOrigin; /* also used for flares */
- vec3_t lightmapVecs[ 3 ]; /* also used for flares */
- int lightStyle; /* used for flares */
-
+ surfaceType_t type;
+ qboolean planar;
+ int outputNum; /* ydnar: to match this sort of thing up */
+
+ qboolean fur; /* ydnar: this is kind of a hack, but hey... */
+ qboolean skybox; /* ydnar: yet another fun hack */
+ qboolean backSide; /* ydnar: q3map_backShader support */
+
+ struct mapDrawSurface_s *parent; /* ydnar: for cloned (skybox) surfaces to share lighting data */
+ struct mapDrawSurface_s *clone; /* ydnar: for cloned surfaces */
+ struct mapDrawSurface_s *cel; /* ydnar: for cloned cel surfaces */
+
+ shaderInfo_t *shaderInfo;
+ shaderInfo_t *celShader;
+ brush_t *mapBrush;
+ parseMesh_t *mapMesh;
+ sideRef_t *sideRef;
+
+ int fogNum;
+
+ int numVerts; /* vertexes and triangles */
+ bspDrawVert_t *verts;
+ int numIndexes;
+ int *indexes;
+
+ int planeNum;
+ vec3_t lightmapOrigin; /* also used for flares */
+ vec3_t lightmapVecs[ 3 ]; /* also used for flares */
+ int lightStyle; /* used for flares */
+
/* ydnar: per-surface (per-entity, actually) lightmap sample size scaling */
- float lightmapScale;
+ float lightmapScale;
/* divVerent: per-surface (per-entity, actually) color modding */
vec3_t colormod;
/* jal: per-surface (per-entity, actually) shadeangle */
- float shadeAngleDegrees;
-
+ float shadeAngleDegrees;
+
/* ydnar: surface classification */
- vec3_t mins, maxs;
- vec3_t lightmapAxis;
- int sampleSize;
-
+ vec3_t mins, maxs;
+ vec3_t lightmapAxis;
+ int sampleSize;
+
/* ydnar: shadow group support */
- int castShadows, recvShadows;
-
+ int castShadows, recvShadows;
+
/* ydnar: texture coordinate range monitoring for hardware with limited texcoord precision (in texel space) */
- float bias[ 2 ];
- int texMins[ 2 ], texMaxs[ 2 ], texRange[ 2 ];
-
+ float bias[ 2 ];
+ int texMins[ 2 ], texMaxs[ 2 ], texRange[ 2 ];
+
/* ydnar: for patches */
- float longestCurve;
- int maxIterations;
- int patchWidth, patchHeight;
- vec3_t bounds[ 2 ];
+ float longestCurve;
+ int maxIterations;
+ int patchWidth, patchHeight;
+ vec3_t bounds[ 2 ];
/* ydnar/sd: for foliage */
- int numFoliageInstances;
-
+ int numFoliageInstances;
+
/* ydnar: editor/useful numbering */
- int entityNum;
- int surfaceNum;
+ int entityNum;
+ int surfaceNum;
}
mapDrawSurface_t;
typedef struct drawSurfRef_s
{
- struct drawSurfRef_s *nextRef;
- int outputNum;
+ struct drawSurfRef_s *nextRef;
+ int outputNum;
}
drawSurfRef_t;
/* ydnar: metasurfaces are constructed from lists of metatriangles so they can be merged in the best way */
typedef struct metaTriangle_s
{
- shaderInfo_t *si;
- side_t *side;
- int entityNum, surfaceNum, planeNum, fogNum, sampleSize, castShadows, recvShadows;
- float shadeAngleDegrees;
- vec4_t plane;
- vec3_t lightmapAxis;
- int indexes[ 3 ];
+ shaderInfo_t *si;
+ side_t *side;
+ int entityNum, surfaceNum, planeNum, fogNum, sampleSize, castShadows, recvShadows;
+ float shadeAngleDegrees;
+ vec4_t plane;
+ vec3_t lightmapAxis;
+ int indexes[ 3 ];
}
metaTriangle_t;
typedef struct epair_s
{
- struct epair_s *next;
- char *key, *value;
+ struct epair_s *next;
+ char *key, *value;
}
epair_t;
typedef struct
{
- vec3_t origin;
- brush_t *brushes, *lastBrush, *colorModBrushes;
- parseMesh_t *patches;
- int mapEntityNum, firstDrawSurf;
- int firstBrush, numBrushes; /* only valid during BSP compile */
- epair_t *epairs;
- vec3_t originbrush_origin;
+ vec3_t origin;
+ brush_t *brushes, *lastBrush, *colorModBrushes;
+ parseMesh_t *patches;
+ int mapEntityNum, firstDrawSurf;
+ int firstBrush, numBrushes; /* only valid during BSP compile */
+ epair_t *epairs;
+ vec3_t originbrush_origin;
}
entity_t;
typedef struct node_s
{
/* both leafs and nodes */
- int planenum; /* -1 = leaf node */
- struct node_s *parent;
- vec3_t mins, maxs; /* valid after portalization */
- brush_t *volume; /* one for each leaf/node */
+ int planenum; /* -1 = leaf node */
+ struct node_s *parent;
+ vec3_t mins, maxs; /* valid after portalization */
+ brush_t *volume; /* one for each leaf/node */
/* nodes only */
- side_t *side; /* the side that created the node */
- struct node_s *children[ 2 ];
- int compileFlags; /* ydnar: hint, antiportal */
- int tinyportals;
- vec3_t referencepoint;
+ side_t *side; /* the side that created the node */
+ struct node_s *children[ 2 ];
+ int compileFlags; /* ydnar: hint, antiportal */
+ int tinyportals;
+ vec3_t referencepoint;
/* leafs only */
- qboolean opaque; /* view can never be inside */
- qboolean areaportal;
- qboolean skybox; /* ydnar: a skybox leaf */
- qboolean sky; /* ydnar: a sky leaf */
- int cluster; /* for portalfile writing */
- int area; /* for areaportals */
- brush_t *brushlist; /* fragments of all brushes in this leaf */
- drawSurfRef_t *drawSurfReferences;
+ qboolean opaque; /* view can never be inside */
+ qboolean areaportal;
+ qboolean skybox; /* ydnar: a skybox leaf */
+ qboolean sky; /* ydnar: a sky leaf */
+ int cluster; /* for portalfile writing */
+ int area; /* for areaportals */
+ brush_t *brushlist; /* fragments of all brushes in this leaf */
+ drawSurfRef_t *drawSurfReferences;
- int occupied; /* 1 or greater can reach entity */
- entity_t *occupant; /* for leak file testing */
+ int occupied; /* 1 or greater can reach entity */
+ entity_t *occupant; /* for leak file testing */
- struct portal_s *portals; /* also on nodes during construction */
+ struct portal_s *portals; /* also on nodes during construction */
- qboolean has_structural_children;
+ qboolean has_structural_children;
}
node_t;
typedef struct portal_s
{
- plane_t plane;
- node_t *onnode; /* NULL = outside box */
- node_t *nodes[ 2 ]; /* [ 0 ] = front side of plane */
- struct portal_s *next[ 2 ];
- winding_t *winding;
-
- qboolean sidefound; /* false if ->side hasn't been checked */
- int compileFlags; /* from original face that caused the split */
- side_t *side; /* NULL = non-visible */
+ plane_t plane;
+ node_t *onnode; /* NULL = outside box */
+ node_t *nodes[ 2 ]; /* [ 0 ] = front side of plane */
+ struct portal_s *next[ 2 ];
+ winding_t *winding;
+
+ qboolean sidefound; /* false if ->side hasn't been checked */
+ int compileFlags; /* from original face that caused the split */
+ side_t *side; /* NULL = non-visible */
}
portal_t;
typedef struct
{
- node_t *headnode;
- node_t outside_node;
- vec3_t mins, maxs;
+ node_t *headnode;
+ node_t outside_node;
+ vec3_t mins, maxs;
}
tree_t;
typedef struct
{
- vec3_t normal;
- float dist;
+ vec3_t normal;
+ float dist;
}
visPlane_t;
typedef struct
{
- int numpoints;
- vec3_t points[ MAX_POINTS_ON_FIXED_WINDING ]; /* variable sized */
-}
+ int numpoints;
+ vec3_t points[ MAX_POINTS_ON_FIXED_WINDING ]; /* variable sized */
+}
fixedWinding_t;
typedef struct passage_s
{
- struct passage_s *next;
- byte cansee[ 1 ]; /* all portals that can be seen through this passage */
+ struct passage_s *next;
+ byte cansee[ 1 ]; /* all portals that can be seen through this passage */
} passage_t;
typedef struct
{
- int num;
- qboolean hint; /* true if this portal was created from a hint splitter */
- qboolean removed;
- visPlane_t plane; /* normal pointing into neighbor */
- int leaf; /* neighbor */
-
- vec3_t origin; /* for fast clip testing */
- float radius;
-
- fixedWinding_t *winding;
- vstatus_t status;
- byte *portalfront; /* [portals], preliminary */
- byte *portalflood; /* [portals], intermediate */
- byte *portalvis; /* [portals], final */
-
- int nummightsee; /* bit count on portalflood for sort */
- passage_t *passages; /* there are just as many passages as there */
- /* are portals in the leaf this portal leads */
+ int num;
+ qboolean hint; /* true if this portal was created from a hint splitter */
+ qboolean removed;
+ visPlane_t plane; /* normal pointing into neighbor */
+ int leaf; /* neighbor */
+
+ vec3_t origin; /* for fast clip testing */
+ float radius;
+
+ fixedWinding_t *winding;
+ vstatus_t status;
+ byte *portalfront; /* [portals], preliminary */
+ byte *portalflood; /* [portals], intermediate */
+ byte *portalvis; /* [portals], final */
+
+ int nummightsee; /* bit count on portalflood for sort */
+ passage_t *passages; /* there are just as many passages as there */
+ /* are portals in the leaf this portal leads */
}
vportal_t;
typedef struct leaf_s
{
- int numportals;
- int merged;
- vportal_t *portals[MAX_PORTALS_ON_LEAF];
+ int numportals;
+ int merged;
+ vportal_t *portals[MAX_PORTALS_ON_LEAF];
}
leaf_t;
-
+
typedef struct pstack_s
{
- byte mightsee[ MAX_PORTALS / 8 ];
- struct pstack_s *next;
- leaf_t *leaf;
- vportal_t *portal; /* portal exiting */
- fixedWinding_t *source;
- fixedWinding_t *pass;
+ byte mightsee[ MAX_PORTALS / 8 ];
+ struct pstack_s *next;
+ leaf_t *leaf;
+ vportal_t *portal; /* portal exiting */
+ fixedWinding_t *source;
+ fixedWinding_t *pass;
- fixedWinding_t windings[ 3 ]; /* source, pass, temp in any order */
- int freewindings[ 3 ];
+ fixedWinding_t windings[ 3 ]; /* source, pass, temp in any order */
+ int freewindings[ 3 ];
- visPlane_t portalplane;
+ visPlane_t portalplane;
int depth;
#ifdef SEPERATORCACHE
- visPlane_t seperators[ 2 ][ MAX_SEPERATORS ];
- int numseperators[ 2 ];
+ visPlane_t seperators[ 2 ][ MAX_SEPERATORS ];
+ int numseperators[ 2 ];
#endif
}
pstack_t;
typedef struct
{
- vportal_t *base;
- int c_chains;
- pstack_t pstack_head;
+ vportal_t *base;
+ int c_chains;
+ pstack_t pstack_head;
}
threaddata_t;
/* ydnar: new light struct with flags */
typedef struct light_s
{
- struct light_s *next;
-
- int type;
- int flags; /* ydnar: condensed all the booleans into one flags int */
- shaderInfo_t *si;
-
- vec3_t origin;
- vec3_t normal; /* for surfaces, spotlights, and suns */
- float dist; /* plane location along normal */
-
- float photons;
- int style;
- vec3_t color;
- float radiusByDist; /* for spotlights */
- float fade; /* ydnar: from wolf, for linear lights */
- float angleScale; /* ydnar: stolen from vlight for K */
- float extraDist; /* "extra dimension" distance of the light, to kill hot spots */
-
- float add; /* ydnar: used for area lights */
- float envelope; /* ydnar: units until falloff < tolerance */
- float envelope2; /* ydnar: envelope squared (tiny optimization) */
- vec3_t mins, maxs; /* ydnar: pvs envelope */
- int cluster; /* ydnar: cluster light falls into */
-
- winding_t *w;
- vec3_t emitColor; /* full out-of-gamut value */
-
- float falloffTolerance; /* ydnar: minimum attenuation threshold */
- float filterRadius; /* ydnar: lightmap filter radius in world units, 0 == default */
+ struct light_s *next;
+
+ int type;
+ int flags; /* ydnar: condensed all the booleans into one flags int */
+ shaderInfo_t *si;
+
+ vec3_t origin;
+ vec3_t normal; /* for surfaces, spotlights, and suns */
+ float dist; /* plane location along normal */
+
+ float photons;
+ int style;
+ vec3_t color;
+ float radiusByDist; /* for spotlights */
+ float fade; /* ydnar: from wolf, for linear lights */
+ float angleScale; /* ydnar: stolen from vlight for K */
+ float extraDist; /* "extra dimension" distance of the light, to kill hot spots */
+
+ float add; /* ydnar: used for area lights */
+ float envelope; /* ydnar: units until falloff < tolerance */
+ float envelope2; /* ydnar: envelope squared (tiny optimization) */
+ vec3_t mins, maxs; /* ydnar: pvs envelope */
+ int cluster; /* ydnar: cluster light falls into */
+
+ winding_t *w;
+ vec3_t emitColor; /* full out-of-gamut value */
+
+ float falloffTolerance; /* ydnar: minimum attenuation threshold */
+ float filterRadius; /* ydnar: lightmap filter radius in world units, 0 == default */
}
light_t;
typedef struct
{
/* constant input */
- qboolean testOcclusion, forceSunlight, testAll;
- int recvShadows;
-
- int numSurfaces;
- int *surfaces;
-
- int numLights;
- light_t **lights;
-
- qboolean twoSided;
-
+ qboolean testOcclusion, forceSunlight, testAll;
+ int recvShadows;
+
+ int numSurfaces;
+ int *surfaces;
+
+ int numLights;
+ light_t **lights;
+
+ qboolean twoSided;
+
/* per-sample input */
- int cluster;
- vec3_t origin, normal;
- vec_t inhibitRadius; /* sphere in which occluding geometry is ignored */
-
+ int cluster;
+ vec3_t origin, normal;
+ vec_t inhibitRadius; /* sphere in which occluding geometry is ignored */
+
/* per-light input */
- light_t *light;
- vec3_t end;
-
+ light_t *light;
+ vec3_t end;
+
/* calculated input */
- vec3_t displacement, direction;
- vec_t distance;
-
+ vec3_t displacement, direction;
+ vec_t distance;
+
/* input and output */
- vec3_t color; /* starts out at full color, may be reduced if transparent surfaces are crossed */
- vec3_t colorNoShadow; /* result color with no shadow casting */
- vec3_t directionContribution; /* result contribution to the deluxe map */
+ vec3_t color; /* starts out at full color, may be reduced if transparent surfaces are crossed */
+ vec3_t colorNoShadow; /* result color with no shadow casting */
+ vec3_t directionContribution; /* result contribution to the deluxe map */
/* output */
- vec3_t hit;
- int compileFlags; /* for determining surface compile flags traced through */
- qboolean passSolid;
- qboolean opaque;
- vec_t forceSubsampling; /* needs subsampling (alphashadow), value = max color contribution possible from it */
-
+ vec3_t hit;
+ int compileFlags; /* for determining surface compile flags traced through */
+ qboolean passSolid;
+ qboolean opaque;
+ vec_t forceSubsampling; /* needs subsampling (alphashadow), value = max color contribution possible from it */
+
/* working data */
- int numTestNodes;
- int testNodes[ MAX_TRACE_TEST_NODES ];
+ int numTestNodes;
+ int testNodes[ MAX_TRACE_TEST_NODES ];
}
trace_t;
/* must be identical to bspDrawVert_t except for float color! */
typedef struct
{
- vec3_t xyz;
- float st[ 2 ];
- float lightmap[ MAX_LIGHTMAPS ][ 2 ];
- vec3_t normal;
- float color[ MAX_LIGHTMAPS ][ 4 ];
+ vec3_t xyz;
+ float st[ 2 ];
+ float lightmap[ MAX_LIGHTMAPS ][ 2 ];
+ vec3_t normal;
+ float color[ MAX_LIGHTMAPS ][ 4 ];
}
radVert_t;
typedef struct
{
- int numVerts;
- radVert_t verts[ MAX_POINTS_ON_WINDING ];
+ int numVerts;
+ radVert_t verts[ MAX_POINTS_ON_WINDING ];
}
radWinding_t;
/* crutch for poor local allocations in win32 smp */
typedef struct
{
- vec_t dists[ MAX_POINTS_ON_WINDING + 4 ];
- int sides[ MAX_POINTS_ON_WINDING + 4 ];
+ vec_t dists[ MAX_POINTS_ON_WINDING + 4 ];
+ int sides[ MAX_POINTS_ON_WINDING + 4 ];
}
clipWork_t;
/* ydnar: new lightmap handling code */
typedef struct outLightmap_s
{
- int lightmapNum, extLightmapNum;
- int customWidth, customHeight;
- int numLightmaps;
- int freeLuxels;
- int numShaders;
- shaderInfo_t *shaders[ MAX_LIGHTMAP_SHADERS ];
- byte *lightBits;
- byte *bspLightBytes;
- byte *bspDirBytes;
+ int lightmapNum, extLightmapNum;
+ int customWidth, customHeight;
+ int numLightmaps;
+ int freeLuxels;
+ int numShaders;
+ shaderInfo_t *shaders[ MAX_LIGHTMAP_SHADERS ];
+ byte *lightBits;
+ byte *bspLightBytes;
+ byte *bspDirBytes;
}
outLightmap_t;
typedef struct rawLightmap_s
{
- qboolean finished, splotchFix, wrap[ 2 ];
- int customWidth, customHeight;
- float brightness;
- float filterRadius;
-
- int firstLightSurface, numLightSurfaces; /* index into lightSurfaces */
- int numLightClusters, *lightClusters;
-
- int sampleSize, actualSampleSize, axisNum;
+ qboolean finished, splotchFix, wrap[ 2 ];
+ int customWidth, customHeight;
+ float brightness;
+ float filterRadius;
+
+ int firstLightSurface, numLightSurfaces; /* index into lightSurfaces */
+ int numLightClusters, *lightClusters;
+
+ int sampleSize, actualSampleSize, axisNum;
/* vortex: per-surface floodlight */
- float floodlightDirectionScale;
- vec3_t floodlightRGB;
- float floodlightIntensity;
- float floodlightDistance;
-
- int entityNum;
- int recvShadows;
- vec3_t mins, maxs, axis, origin, *vecs;
- float *plane;
- int w, h, sw, sh, used;
-
- qboolean solid[ MAX_LIGHTMAPS ];
- vec3_t solidColor[ MAX_LIGHTMAPS ];
-
- int numStyledTwins;
- struct rawLightmap_s *twins[ MAX_LIGHTMAPS ];
-
- int outLightmapNums[ MAX_LIGHTMAPS ];
- int twinNums[ MAX_LIGHTMAPS ];
- int lightmapX[ MAX_LIGHTMAPS ], lightmapY[ MAX_LIGHTMAPS ];
- byte styles[ MAX_LIGHTMAPS ];
- float *bspLuxels[ MAX_LIGHTMAPS ];
- float *radLuxels[ MAX_LIGHTMAPS ];
- float *superLuxels[ MAX_LIGHTMAPS ];
- unsigned char *superFlags;
- float *superOrigins;
- float *superNormals;
- int *superClusters;
-
- float *superDeluxels; /* average light direction */
- float *bspDeluxels;
- float *superFloodLight;
+ float floodlightDirectionScale;
+ vec3_t floodlightRGB;
+ float floodlightIntensity;
+ float floodlightDistance;
+
+ int entityNum;
+ int recvShadows;
+ vec3_t mins, maxs, axis, origin, *vecs;
+ float *plane;
+ int w, h, sw, sh, used;
+
+ qboolean solid[ MAX_LIGHTMAPS ];
+ vec3_t solidColor[ MAX_LIGHTMAPS ];
+
+ int numStyledTwins;
+ struct rawLightmap_s *twins[ MAX_LIGHTMAPS ];
+
+ int outLightmapNums[ MAX_LIGHTMAPS ];
+ int twinNums[ MAX_LIGHTMAPS ];
+ int lightmapX[ MAX_LIGHTMAPS ], lightmapY[ MAX_LIGHTMAPS ];
+ byte styles[ MAX_LIGHTMAPS ];
+ float *bspLuxels[ MAX_LIGHTMAPS ];
+ float *radLuxels[ MAX_LIGHTMAPS ];
+ float *superLuxels[ MAX_LIGHTMAPS ];
+ unsigned char *superFlags;
+ float *superOrigins;
+ float *superNormals;
+ int *superClusters;
+
+ float *superDeluxels; /* average light direction */
+ float *bspDeluxels;
+ float *superFloodLight;
}
rawLightmap_t;
typedef struct rawGridPoint_s
{
- vec3_t ambient[ MAX_LIGHTMAPS ];
- vec3_t directed[ MAX_LIGHTMAPS ];
- vec3_t dir;
- byte styles[ MAX_LIGHTMAPS ];
+ vec3_t ambient[ MAX_LIGHTMAPS ];
+ vec3_t directed[ MAX_LIGHTMAPS ];
+ vec3_t dir;
+ byte styles[ MAX_LIGHTMAPS ];
}
rawGridPoint_t;
typedef struct surfaceInfo_s
{
- int modelindex;
- shaderInfo_t *si;
- rawLightmap_t *lm;
- int parentSurfaceNum, childSurfaceNum;
- int entityNum, castShadows, recvShadows, sampleSize, patchIterations;
- float longestCurve;
- float *plane;
- vec3_t axis, mins, maxs;
- qboolean hasLightmap, approximated;
- int firstSurfaceCluster, numSurfaceClusters;
+ int modelindex;
+ shaderInfo_t *si;
+ rawLightmap_t *lm;
+ int parentSurfaceNum, childSurfaceNum;
+ int entityNum, castShadows, recvShadows, sampleSize, patchIterations;
+ float longestCurve;
+ float *plane;
+ vec3_t axis, mins, maxs;
+ qboolean hasLightmap, approximated;
+ int firstSurfaceCluster, numSurfaceClusters;
}
surfaceInfo_t;
------------------------------------------------------------------------------- */
/* main.c */
-vec_t Random( void );
+vec_t Random( void );
char *Q_strncpyz( char *dst, const char *src, size_t len );
char *Q_strcat( char *dst, size_t dlen, const char *src );
char *Q_strncat( char *dst, size_t dlen, const char *src, size_t slen );
-int BSPInfo( int count, char **fileNames );
-int ScaleBSPMain( int argc, char **argv );
-int ConvertMain( int argc, char **argv );
+int BSPInfo( int count, char **fileNames );
+int ScaleBSPMain( int argc, char **argv );
+int ConvertMain( int argc, char **argv );
/* path_init.c */
-game_t *GetGame( char *arg );
-void InitPaths( int *argc, char **argv );
+game_t *GetGame( char *arg );
+void InitPaths( int *argc, char **argv );
/* bsp.c */
-int BSPMain( int argc, char **argv );
+int BSPMain( int argc, char **argv );
/* convert_map.c */
-int ConvertBSPToMap( char *bspName );
-int ConvertBSPToMap_BP( char *bspName );
+int ConvertBSPToMap( char *bspName );
+int ConvertBSPToMap_BP( char *bspName );
/* convert_ase.c */
-int ConvertBSPToASE( char *bspName );
+int ConvertBSPToASE( char *bspName );
/* convert_obj.c */
-int ConvertBSPToOBJ( char *bspName );
+int ConvertBSPToOBJ( char *bspName );
/* brush.c */
-sideRef_t *AllocSideRef( side_t *side, sideRef_t *next );
-int CountBrushList( brush_t *brushes );
-brush_t *AllocBrush( int numsides );
-void FreeBrush( brush_t *brushes );
-void FreeBrushList( brush_t *brushes );
-brush_t *CopyBrush( brush_t *brush );
-qboolean BoundBrush( brush_t *brush );
-qboolean CreateBrushWindings( brush_t *brush );
-brush_t *BrushFromBounds( vec3_t mins, vec3_t maxs );
-vec_t BrushVolume( brush_t *brush );
-void WriteBSPBrushMap( char *name, brush_t *list );
-
-void FilterDetailBrushesIntoTree( entity_t *e, tree_t *tree );
-void FilterStructuralBrushesIntoTree( entity_t *e, tree_t *tree );
-
-int BoxOnPlaneSide( vec3_t mins, vec3_t maxs, plane_t *plane );
-qboolean WindingIsTiny( winding_t *w );
+sideRef_t *AllocSideRef( side_t *side, sideRef_t *next );
+int CountBrushList( brush_t *brushes );
+brush_t *AllocBrush( int numsides );
+void FreeBrush( brush_t *brushes );
+void FreeBrushList( brush_t *brushes );
+brush_t *CopyBrush( brush_t *brush );
+qboolean BoundBrush( brush_t *brush );
+qboolean CreateBrushWindings( brush_t *brush );
+brush_t *BrushFromBounds( vec3_t mins, vec3_t maxs );
+vec_t BrushVolume( brush_t *brush );
+void WriteBSPBrushMap( char *name, brush_t *list );
+
+void FilterDetailBrushesIntoTree( entity_t *e, tree_t *tree );
+void FilterStructuralBrushesIntoTree( entity_t *e, tree_t *tree );
+
+int BoxOnPlaneSide( vec3_t mins, vec3_t maxs, plane_t *plane );
+qboolean WindingIsTiny( winding_t *w );
void SplitBrush( brush_t *brush, int planenum, brush_t **front, brush_t **back );
-tree_t *AllocTree( void );
-node_t *AllocNode( void );
+tree_t *AllocTree( void );
+node_t *AllocNode( void );
/* mesh.c */
-void LerpDrawVert( bspDrawVert_t *a, bspDrawVert_t *b, bspDrawVert_t *out );
-void LerpDrawVertAmount( bspDrawVert_t *a, bspDrawVert_t *b, float amount, bspDrawVert_t *out );
-void FreeMesh( mesh_t *m );
-mesh_t *CopyMesh( mesh_t *mesh );
-void PrintMesh( mesh_t *m );
-mesh_t *TransposeMesh( mesh_t *in );
-void InvertMesh( mesh_t *m );
-mesh_t *SubdivideMesh( mesh_t in, float maxError, float minLength );
-int IterationsForCurve( float len, int subdivisions );
-mesh_t *SubdivideMesh2( mesh_t in, int iterations );
-mesh_t *SubdivideMeshQuads( mesh_t *in, float minLength, int maxsize, int *widthtable, int *heighttable );
-mesh_t *RemoveLinearMeshColumnsRows( mesh_t *in );
-void MakeMeshNormals( mesh_t in );
-void PutMeshOnCurve( mesh_t in );
-
-void MakeNormalVectors( vec3_t forward, vec3_t right, vec3_t up );
+void LerpDrawVert( bspDrawVert_t *a, bspDrawVert_t *b, bspDrawVert_t *out );
+void LerpDrawVertAmount( bspDrawVert_t *a, bspDrawVert_t *b, float amount, bspDrawVert_t *out );
+void FreeMesh( mesh_t *m );
+mesh_t *CopyMesh( mesh_t *mesh );
+void PrintMesh( mesh_t *m );
+mesh_t *TransposeMesh( mesh_t *in );
+void InvertMesh( mesh_t *m );
+mesh_t *SubdivideMesh( mesh_t in, float maxError, float minLength );
+int IterationsForCurve( float len, int subdivisions );
+mesh_t *SubdivideMesh2( mesh_t in, int iterations );
+mesh_t *SubdivideMeshQuads( mesh_t *in, float minLength, int maxsize, int *widthtable, int *heighttable );
+mesh_t *RemoveLinearMeshColumnsRows( mesh_t *in );
+void MakeMeshNormals( mesh_t in );
+void PutMeshOnCurve( mesh_t in );
+
+void MakeNormalVectors( vec3_t forward, vec3_t right, vec3_t up );
/* map.c */
-void LoadMapFile( char *filename, qboolean onlyLights, qboolean noCollapseGroups );
-int FindFloatPlane( vec3_t normal, vec_t dist, int numPoints, vec3_t *points );
-int PlaneTypeForNormal( vec3_t normal );
-void AddBrushBevels( void );
+void LoadMapFile( char *filename, qboolean onlyLights, qboolean noCollapseGroups );
+int FindFloatPlane( vec3_t normal, vec_t dist, int numPoints, vec3_t *points );
+int PlaneTypeForNormal( vec3_t normal );
+void AddBrushBevels( void );
brush_t *FinishBrush( qboolean noCollapseGroups );
/* portals.c */
-void MakeHeadnodePortals( tree_t *tree );
-void MakeNodePortal( node_t *node );
-void SplitNodePortals( node_t *node );
+void MakeHeadnodePortals( tree_t *tree );
+void MakeNodePortal( node_t *node );
+void SplitNodePortals( node_t *node );
-qboolean PortalPassable( portal_t *p );
+qboolean PortalPassable( portal_t *p );
#define FLOODENTITIES_LEAKED 1
#define FLOODENTITIES_GOOD 0
int FloodEntities( tree_t *tree );
void FillOutside( node_t *headnode );
void FloodAreas( tree_t *tree );
-face_t *VisibleFaces( entity_t *e, tree_t *tree );
-void FreePortal( portal_t *p );
+face_t *VisibleFaces( entity_t *e, tree_t *tree );
+void FreePortal( portal_t *p );
-void MakeTreePortals( tree_t *tree );
+void MakeTreePortals( tree_t *tree );
/* leakfile.c */
-xmlNodePtr LeakFile( tree_t *tree );
+xmlNodePtr LeakFile( tree_t *tree );
/* prtfile.c */
-void NumberClusters( tree_t *tree );
-void WritePortalFile( tree_t *tree );
+void NumberClusters( tree_t *tree );
+void WritePortalFile( tree_t *tree );
/* writebsp.c */
-void SetModelNumbers( void );
-void SetLightStyles( void );
+void SetModelNumbers( void );
+void SetLightStyles( void );
-int EmitShader( const char *shader, int *contentFlags, int *surfaceFlags );
+int EmitShader( const char *shader, int *contentFlags, int *surfaceFlags );
-void BeginBSPFile( void );
-void EndBSPFile( qboolean do_write );
-void EmitBrushes( brush_t *brushes, int *firstBrush, int *numBrushes );
-void EmitFogs( void );
+void BeginBSPFile( void );
+void EndBSPFile( qboolean do_write );
+void EmitBrushes( brush_t *brushes, int *firstBrush, int *numBrushes );
+void EmitFogs( void );
-void BeginModel( void );
-void EndModel( entity_t *e, node_t *headnode );
+void BeginModel( void );
+void EndModel( entity_t *e, node_t *headnode );
/* tree.c */
-void FreeTree( tree_t *tree );
-void FreeTree_r( node_t *node );
-void PrintTree_r( node_t *node, int depth );
-void FreeTreePortals_r( node_t *node );
+void FreeTree( tree_t *tree );
+void FreeTree_r( node_t *node );
+void PrintTree_r( node_t *node, int depth );
+void FreeTreePortals_r( node_t *node );
/* patch.c */
-void ParsePatch( qboolean onlyLights );
-mesh_t *SubdivideMesh( mesh_t in, float maxError, float minLength );
-void PatchMapDrawSurfs( entity_t *e );
+void ParsePatch( qboolean onlyLights );
+mesh_t *SubdivideMesh( mesh_t in, float maxError, float minLength );
+void PatchMapDrawSurfs( entity_t *e );
void TriangulatePatchSurface( entity_t *e, mapDrawSurface_t *ds );
/* tjunction.c */
-void FixTJunctions( entity_t *e );
+void FixTJunctions( entity_t *e );
/* fog.c */
-winding_t *WindingFromDrawSurf( mapDrawSurface_t *ds );
-void FogDrawSurfaces( entity_t *e );
-int FogForPoint( vec3_t point, float epsilon );
-int FogForBounds( vec3_t mins, vec3_t maxs, float epsilon );
-void CreateMapFogs( void );
+winding_t *WindingFromDrawSurf( mapDrawSurface_t *ds );
+void FogDrawSurfaces( entity_t *e );
+int FogForPoint( vec3_t point, float epsilon );
+int FogForBounds( vec3_t mins, vec3_t maxs, float epsilon );
+void CreateMapFogs( void );
/* facebsp.c */
-face_t *MakeStructuralBSPFaceList( brush_t *list );
-face_t *MakeVisibleBSPFaceList( brush_t *list );
-tree_t *FaceBSP( face_t *list );
+face_t *MakeStructuralBSPFaceList( brush_t *list );
+face_t *MakeVisibleBSPFaceList( brush_t *list );
+tree_t *FaceBSP( face_t *list );
/* model.c */
-void PicoPrintFunc( int level, const char *str );
-void PicoLoadFileFunc( const char *name, byte **buffer, int *bufSize );
-picoModel_t *FindModel( const char *name, int frame );
-picoModel_t *LoadModel( const char *name, int frame );
+void PicoPrintFunc( int level, const char *str );
+void PicoLoadFileFunc( const char *name, byte **buffer, int *bufSize );
+picoModel_t *FindModel( const char *name, int frame );
+picoModel_t *LoadModel( const char *name, int frame );
void InsertModel( const char *name, int skin, int frame, m4x4_t transform, remap_t *remap, shaderInfo_t *celShader, int eNum, int castShadows, int recvShadows, int spawnFlags, float lightmapScale, int lightmapSampleSize, float shadeAngle, vec3_t colormod );
-void AddTriangleModels( entity_t *e );
+void AddTriangleModels( entity_t *e );
/* surface.c */
-mapDrawSurface_t *AllocDrawSurface( surfaceType_t type );
-void FinishSurface( mapDrawSurface_t *ds );
-void StripFaceSurface( mapDrawSurface_t *ds );
-void MaxAreaFaceSurface( mapDrawSurface_t *ds );
-qboolean CalcSurfaceTextureRange( mapDrawSurface_t *ds );
-qboolean CalcLightmapAxis( vec3_t normal, vec3_t axis );
-void ClassifySurfaces( int numSurfs, mapDrawSurface_t *ds );
-void ClassifyEntitySurfaces( entity_t *e );
-void TidyEntitySurfaces( entity_t *e );
-mapDrawSurface_t *CloneSurface( mapDrawSurface_t *src, shaderInfo_t *si );
-mapDrawSurface_t *MakeCelSurface( mapDrawSurface_t *src, shaderInfo_t *si );
-qboolean IsTriangleDegenerate( bspDrawVert_t *points, int a, int b, int c );
-void ClearSurface( mapDrawSurface_t *ds );
-void AddEntitySurfaceModels( entity_t *e );
-mapDrawSurface_t *DrawSurfaceForSide( entity_t *e, brush_t *b, side_t *s, winding_t *w );
-mapDrawSurface_t *DrawSurfaceForMesh( entity_t *e, parseMesh_t *p, mesh_t *mesh );
-mapDrawSurface_t *DrawSurfaceForFlare( int entNum, vec3_t origin, vec3_t normal, vec3_t color, const char *flareShader, int lightStyle );
-mapDrawSurface_t *DrawSurfaceForShader( char *shader );
-void ClipSidesIntoTree( entity_t *e, tree_t *tree );
-void MakeDebugPortalSurfs( tree_t *tree );
-void MakeFogHullSurfs( entity_t *e, tree_t *tree, char *shader );
-void SubdivideFaceSurfaces( entity_t *e, tree_t *tree );
-void AddEntitySurfaceModels( entity_t *e );
-int AddSurfaceModels( mapDrawSurface_t *ds );
-void FilterDrawsurfsIntoTree( entity_t *e, tree_t *tree );
-void EmitPatchSurface( entity_t *e, mapDrawSurface_t *ds );
-void EmitTriangleSurface( mapDrawSurface_t *ds );
+mapDrawSurface_t *AllocDrawSurface( surfaceType_t type );
+void FinishSurface( mapDrawSurface_t *ds );
+void StripFaceSurface( mapDrawSurface_t *ds );
+void MaxAreaFaceSurface( mapDrawSurface_t *ds );
+qboolean CalcSurfaceTextureRange( mapDrawSurface_t *ds );
+qboolean CalcLightmapAxis( vec3_t normal, vec3_t axis );
+void ClassifySurfaces( int numSurfs, mapDrawSurface_t *ds );
+void ClassifyEntitySurfaces( entity_t *e );
+void TidyEntitySurfaces( entity_t *e );
+mapDrawSurface_t *CloneSurface( mapDrawSurface_t *src, shaderInfo_t *si );
+mapDrawSurface_t *MakeCelSurface( mapDrawSurface_t *src, shaderInfo_t *si );
+qboolean IsTriangleDegenerate( bspDrawVert_t *points, int a, int b, int c );
+void ClearSurface( mapDrawSurface_t *ds );
+void AddEntitySurfaceModels( entity_t *e );
+mapDrawSurface_t *DrawSurfaceForSide( entity_t *e, brush_t *b, side_t *s, winding_t *w );
+mapDrawSurface_t *DrawSurfaceForMesh( entity_t *e, parseMesh_t *p, mesh_t *mesh );
+mapDrawSurface_t *DrawSurfaceForFlare( int entNum, vec3_t origin, vec3_t normal, vec3_t color, const char *flareShader, int lightStyle );
+mapDrawSurface_t *DrawSurfaceForShader( char *shader );
+void ClipSidesIntoTree( entity_t *e, tree_t *tree );
+void MakeDebugPortalSurfs( tree_t *tree );
+void MakeFogHullSurfs( entity_t *e, tree_t *tree, char *shader );
+void SubdivideFaceSurfaces( entity_t *e, tree_t *tree );
+void AddEntitySurfaceModels( entity_t *e );
+int AddSurfaceModels( mapDrawSurface_t *ds );
+void FilterDrawsurfsIntoTree( entity_t *e, tree_t *tree );
+void EmitPatchSurface( entity_t *e, mapDrawSurface_t *ds );
+void EmitTriangleSurface( mapDrawSurface_t *ds );
/* surface_fur.c */
-void Fur( mapDrawSurface_t *src );
+void Fur( mapDrawSurface_t *src );
/* surface_foliage.c */
-void Foliage( mapDrawSurface_t *src );
+void Foliage( mapDrawSurface_t *src );
/* ydnar: surface_meta.c */
-void ClearMetaTriangles( void );
-int FindMetaTriangle( metaTriangle_t *src, bspDrawVert_t *a, bspDrawVert_t *b, bspDrawVert_t *c, int planeNum );
-void MakeEntityMetaTriangles( entity_t *e );
-void FixMetaTJunctions( void );
-void SmoothMetaTriangles( void );
-void MergeMetaTriangles( void );
-void EmitMetaStats(); // vortex: print meta statistics even in no-verbose mode
+void ClearMetaTriangles( void );
+int FindMetaTriangle( metaTriangle_t *src, bspDrawVert_t *a, bspDrawVert_t *b, bspDrawVert_t *c, int planeNum );
+void MakeEntityMetaTriangles( entity_t *e );
+void FixMetaTJunctions( void );
+void SmoothMetaTriangles( void );
+void MergeMetaTriangles( void );
+void EmitMetaStats(); // vortex: print meta statistics even in no-verbose mode
/* surface_extra.c */
-void SetDefaultSampleSize( int sampleSize );
+void SetDefaultSampleSize( int sampleSize );
-void SetSurfaceExtra( mapDrawSurface_t *ds, int num );
+void SetSurfaceExtra( mapDrawSurface_t *ds, int num );
-shaderInfo_t *GetSurfaceExtraShaderInfo( int num );
-int GetSurfaceExtraParentSurfaceNum( int num );
-int GetSurfaceExtraEntityNum( int num );
-int GetSurfaceExtraCastShadows( int num );
-int GetSurfaceExtraRecvShadows( int num );
-int GetSurfaceExtraSampleSize( int num );
-int GetSurfaceExtraMinSampleSize( int num );
-float GetSurfaceExtraLongestCurve( int num );
-void GetSurfaceExtraLightmapAxis( int num, vec3_t lightmapAxis );
+shaderInfo_t *GetSurfaceExtraShaderInfo( int num );
+int GetSurfaceExtraParentSurfaceNum( int num );
+int GetSurfaceExtraEntityNum( int num );
+int GetSurfaceExtraCastShadows( int num );
+int GetSurfaceExtraRecvShadows( int num );
+int GetSurfaceExtraSampleSize( int num );
+int GetSurfaceExtraMinSampleSize( int num );
+float GetSurfaceExtraLongestCurve( int num );
+void GetSurfaceExtraLightmapAxis( int num, vec3_t lightmapAxis );
-void WriteSurfaceExtraFile( const char *path );
-void LoadSurfaceExtraFile( const char *path );
+void WriteSurfaceExtraFile( const char *path );
+void LoadSurfaceExtraFile( const char *path );
/* decals.c */
-void ProcessDecals( void );
-void MakeEntityDecals( entity_t *e );
+void ProcessDecals( void );
+void MakeEntityDecals( entity_t *e );
/* map.c */
-void TextureAxisFromPlane( plane_t *pln, vec3_t xv, vec3_t yv );
+void TextureAxisFromPlane( plane_t *pln, vec3_t xv, vec3_t yv );
/* brush_primit.c */
void ComputeAxisBase( vec3_t normal, vec3_t texX, vec3_t texY );
/* vis.c */
-fixedWinding_t *NewFixedWinding( int points );
-int VisMain( int argc, char **argv );
+fixedWinding_t *NewFixedWinding( int points );
+int VisMain( int argc, char **argv );
/* visflow.c */
-int CountBits( byte *bits, int numbits );
-void PassageFlow( int portalnum );
-void CreatePassages( int portalnum );
-void PassageMemory( void );
-void BasePortalVis( int portalnum );
-void BetterPortalVis( int portalnum );
-void PortalFlow( int portalnum );
-void PassagePortalFlow( int portalnum );
+int CountBits( byte *bits, int numbits );
+void PassageFlow( int portalnum );
+void CreatePassages( int portalnum );
+void PassageMemory( void );
+void BasePortalVis( int portalnum );
+void BetterPortalVis( int portalnum );
+void PortalFlow( int portalnum );
+void PassagePortalFlow( int portalnum );
/* light.c */
-float PointToPolygonFormFactor( const vec3_t point, const vec3_t normal, const winding_t *w );
-int LightContributionToSample( trace_t *trace );
+float PointToPolygonFormFactor( const vec3_t point, const vec3_t normal, const winding_t *w );
+int LightContributionToSample( trace_t *trace );
void LightingAtSample( trace_t * trace, byte styles[ MAX_LIGHTMAPS ], vec3_t colors[ MAX_LIGHTMAPS ] );
-int LightContributionToPoint( trace_t *trace );
-int LightMain( int argc, char **argv );
+int LightContributionToPoint( trace_t *trace );
+int LightMain( int argc, char **argv );
/* light_trace.c */
-void SetupTraceNodes( void );
-void TraceLine( trace_t *trace );
-float SetupTrace( trace_t *trace );
+void SetupTraceNodes( void );
+void TraceLine( trace_t *trace );
+float SetupTrace( trace_t *trace );
/* light_bounce.c */
qboolean RadSampleImage( byte * pixels, int width, int height, float st[ 2 ], float color[ 4 ] );
-void RadLightForTriangles( int num, int lightmapNum, rawLightmap_t *lm, shaderInfo_t *si, float scale, float subdivide, clipWork_t *cw );
-void RadLightForPatch( int num, int lightmapNum, rawLightmap_t *lm, shaderInfo_t *si, float scale, float subdivide, clipWork_t *cw );
-void RadCreateDiffuseLights( void );
-void RadFreeLights();
+void RadLightForTriangles( int num, int lightmapNum, rawLightmap_t *lm, shaderInfo_t *si, float scale, float subdivide, clipWork_t *cw );
+void RadLightForPatch( int num, int lightmapNum, rawLightmap_t *lm, shaderInfo_t *si, float scale, float subdivide, clipWork_t *cw );
+void RadCreateDiffuseLights( void );
+void RadFreeLights();
/* light_ydnar.c */
-void ColorToBytes( const float *color, byte *colorBytes, float scale );
-void SmoothNormals( void );
+void ColorToBytes( const float *color, byte *colorBytes, float scale );
+void SmoothNormals( void );
-void MapRawLightmap( int num );
+void MapRawLightmap( int num );
-void SetupDirt();
-float DirtForSample( trace_t *trace );
-void DirtyRawLightmap( int num );
+void SetupDirt();
+float DirtForSample( trace_t *trace );
+void DirtyRawLightmap( int num );
-void SetupFloodLight();
-void FloodlightRawLightmaps();
-void FloodlightIlluminateLightmap( rawLightmap_t *lm );
+void SetupFloodLight();
+void FloodlightRawLightmaps();
+void FloodlightIlluminateLightmap( rawLightmap_t *lm );
float FloodLightForSample( trace_t *trace, float floodLightDistance, qboolean floodLightLowQuality );
-void FloodLightRawLightmap( int num );
+void FloodLightRawLightmap( int num );
-void IlluminateRawLightmap( int num );
-void IlluminateVertexes( int num );
+void IlluminateRawLightmap( int num );
+void IlluminateVertexes( int num );
void SetupBrushesFlags( int mask_any, int test_any, int mask_all, int test_all );
-void SetupBrushes( void );
-void SetupClusters( void );
-qboolean ClusterVisible( int a, int b );
-qboolean ClusterVisibleToPoint( vec3_t point, int cluster );
-int ClusterForPoint( vec3_t point );
-int ClusterForPointExt( vec3_t point, float epsilon );
-int ClusterForPointExtFilter( vec3_t point, float epsilon, int numClusters, int *clusters );
-int ShaderForPointInLeaf( vec3_t point, int leafNum, float epsilon, int wantContentFlags, int wantSurfaceFlags, int *contentFlags, int *surfaceFlags );
-void SetupEnvelopes( qboolean forGrid, qboolean fastFlag );
-void FreeTraceLights( trace_t *trace );
-void CreateTraceLightsForBounds( vec3_t mins, vec3_t maxs, vec3_t normal, int numClusters, int *clusters, int flags, trace_t *trace );
-void CreateTraceLightsForSurface( int num, trace_t *trace );
+void SetupBrushes( void );
+void SetupClusters( void );
+qboolean ClusterVisible( int a, int b );
+qboolean ClusterVisibleToPoint( vec3_t point, int cluster );
+int ClusterForPoint( vec3_t point );
+int ClusterForPointExt( vec3_t point, float epsilon );
+int ClusterForPointExtFilter( vec3_t point, float epsilon, int numClusters, int *clusters );
+int ShaderForPointInLeaf( vec3_t point, int leafNum, float epsilon, int wantContentFlags, int wantSurfaceFlags, int *contentFlags, int *surfaceFlags );
+void SetupEnvelopes( qboolean forGrid, qboolean fastFlag );
+void FreeTraceLights( trace_t *trace );
+void CreateTraceLightsForBounds( vec3_t mins, vec3_t maxs, vec3_t normal, int numClusters, int *clusters, int flags, trace_t *trace );
+void CreateTraceLightsForSurface( int num, trace_t *trace );
/* lightmaps_ydnar.c */
-void ExportLightmaps( void );
+void ExportLightmaps( void );
-int ExportLightmapsMain( int argc, char **argv );
-int ImportLightmapsMain( int argc, char **argv );
+int ExportLightmapsMain( int argc, char **argv );
+int ImportLightmapsMain( int argc, char **argv );
-void SetupSurfaceLightmaps( void );
-void StitchSurfaceLightmaps( void );
-void StoreSurfaceLightmaps( void );
+void SetupSurfaceLightmaps( void );
+void StitchSurfaceLightmaps( void );
+void StoreSurfaceLightmaps( void );
/* image.c */
-void ImageFree( image_t *image );
-image_t *ImageFind( const char *filename );
-image_t *ImageLoad( const char *filename );
+void ImageFree( image_t *image );
+image_t *ImageFind( const char *filename );
+image_t *ImageLoad( const char *filename );
/* shaders.c */
-void ColorMod( colorMod_t *am, int numVerts, bspDrawVert_t *drawVerts );
+void ColorMod( colorMod_t *am, int numVerts, bspDrawVert_t *drawVerts );
-void TCMod( tcMod_t mod, float st[ 2 ] );
-void TCModIdentity( tcMod_t mod );
-void TCModMultiply( tcMod_t a, tcMod_t b, tcMod_t out );
-void TCModTranslate( tcMod_t mod, float s, float t );
-void TCModScale( tcMod_t mod, float s, float t );
-void TCModRotate( tcMod_t mod, float euler );
+void TCMod( tcMod_t mod, float st[ 2 ] );
+void TCModIdentity( tcMod_t mod );
+void TCModMultiply( tcMod_t a, tcMod_t b, tcMod_t out );
+void TCModTranslate( tcMod_t mod, float s, float t );
+void TCModScale( tcMod_t mod, float s, float t );
+void TCModRotate( tcMod_t mod, float euler );
-qboolean ApplySurfaceParm( char *name, int *contentFlags, int *surfaceFlags, int *compileFlags );
+qboolean ApplySurfaceParm( char *name, int *contentFlags, int *surfaceFlags, int *compileFlags );
-void BeginMapShaderFile( const char *mapFile );
-void WriteMapShaderFile( void );
-shaderInfo_t *CustomShader( shaderInfo_t *si, char *find, char *replace );
-void EmitVertexRemapShader( char *from, char *to );
+void BeginMapShaderFile( const char *mapFile );
+void WriteMapShaderFile( void );
+shaderInfo_t *CustomShader( shaderInfo_t *si, char *find, char *replace );
+void EmitVertexRemapShader( char *from, char *to );
-void LoadShaderInfo( void );
-shaderInfo_t *ShaderInfoForShader( const char *shader );
+void LoadShaderInfo( void );
+shaderInfo_t *ShaderInfoForShader( const char *shader );
shaderInfo_t *ShaderInfoForShaderNull( const char *shader );
/* bspfile_abstract.c */
-void SetGridPoints( int n );
-void SetDrawVerts( int n );
-void IncDrawVerts();
+void SetGridPoints( int n );
+void SetDrawVerts( int n );
+void IncDrawVerts();
void SetDrawSurfaces( int n );
-void SetDrawSurfacesBuffer();
-void BSPFilesCleanup();
-
-void SwapBlock( int *block, int size );
-
-int GetLumpElements( bspHeader_t *header, int lump, int size );
-void *GetLump( bspHeader_t *header, int lump );
-int CopyLump( bspHeader_t *header, int lump, void *dest, int size );
-int CopyLump_Allocate( bspHeader_t *header, int lump, void **dest, int size, int *allocationVariable );
-void AddLump( FILE *file, bspHeader_t *header, int lumpNum, const void *data, int length );
-
-void LoadBSPFile( const char *filename );
-void WriteBSPFile( const char *filename );
-void PrintBSPFileSizes( void );
-
-epair_t *ParseEPair( void );
-void ParseEntities( void );
-void UnparseEntities( void );
-void PrintEntity( const entity_t *ent );
-void SetKeyValue( entity_t *ent, const char *key, const char *value );
-qboolean KeyExists( const entity_t *ent, const char *key ); /* VorteX: check if key exists */
-const char *ValueForKey( const entity_t *ent, const char *key );
-int IntForKey( const entity_t *ent, const char *key );
-vec_t FloatForKey( const entity_t *ent, const char *key );
-void GetVectorForKey( const entity_t *ent, const char *key, vec3_t vec );
-entity_t *FindTargetEntity( const char *target );
-void GetEntityShadowFlags( const entity_t *ent, const entity_t *ent2, int *castShadows, int *recvShadows );
+void SetDrawSurfacesBuffer();
+void BSPFilesCleanup();
+
+void SwapBlock( int *block, int size );
+
+int GetLumpElements( bspHeader_t *header, int lump, int size );
+void *GetLump( bspHeader_t *header, int lump );
+int CopyLump( bspHeader_t *header, int lump, void *dest, int size );
+int CopyLump_Allocate( bspHeader_t *header, int lump, void **dest, int size, int *allocationVariable );
+void AddLump( FILE *file, bspHeader_t *header, int lumpNum, const void *data, int length );
+
+void LoadBSPFile( const char *filename );
+void WriteBSPFile( const char *filename );
+void PrintBSPFileSizes( void );
+
+epair_t *ParseEPair( void );
+void ParseEntities( void );
+void UnparseEntities( void );
+void PrintEntity( const entity_t *ent );
+void SetKeyValue( entity_t *ent, const char *key, const char *value );
+qboolean KeyExists( const entity_t *ent, const char *key ); /* VorteX: check if key exists */
+const char *ValueForKey( const entity_t *ent, const char *key );
+int IntForKey( const entity_t *ent, const char *key );
+vec_t FloatForKey( const entity_t *ent, const char *key );
+void GetVectorForKey( const entity_t *ent, const char *key, vec3_t vec );
+entity_t *FindTargetEntity( const char *target );
+void GetEntityShadowFlags( const entity_t *ent, const entity_t *ent2, int *castShadows, int *recvShadows );
void InjectCommandLine( char **argv, int beginArgs, int endArgs );
-
+
/* bspfile_ibsp.c */
-void LoadIBSPFile( const char *filename );
-void WriteIBSPFile( const char *filename );
+void LoadIBSPFile( const char *filename );
+void WriteIBSPFile( const char *filename );
/* bspfile_rbsp.c */
-void LoadRBSPFile( const char *filename );
-void WriteRBSPFile( const char *filename );
+void LoadRBSPFile( const char *filename );
+void WriteRBSPFile( const char *filename );
#ifdef MAIN_C
#define Q_EXTERN
- #define Q_ASSIGN( a ) = a
+ #define Q_ASSIGN( a ) = a
#else
#define Q_EXTERN extern
- #define Q_ASSIGN( a )
+ #define Q_ASSIGN( a )
#endif
/* game support */
-Q_EXTERN game_t games[]
+Q_EXTERN game_t games[]
#ifndef MAIN_C
;
#else
- =
- {
+ =
+ {
#include "game_quake3.h"
- ,
+ ,
#include "game_quakelive.h" /* most be after game_quake3.h as they share defines! */
- ,
+ ,
#include "game_nexuiz.h" /* most be after game_quake3.h as they share defines! */
- ,
+ ,
#include "game_xonotic.h" /* most be after game_quake3.h as they share defines! */
- ,
+ ,
#include "game_tremulous.h" /*LinuxManMikeC: must be after game_quake3.h, depends on #define's set in it */
- ,
+ ,
#include "game_tenebrae.h"
- ,
+ ,
#include "game_wolf.h"
- ,
+ ,
#include "game_wolfet.h" /* most be after game_wolf.h as they share defines! */
- ,
+ ,
#include "game_etut.h"
- ,
+ ,
#include "game_ef.h"
- ,
+ ,
#include "game_sof2.h"
- ,
- #include "game_jk2.h" /* most be after game_sof2.h as they share defines! */
- ,
- #include "game_ja.h" /* most be after game_jk2.h as they share defines! */
- ,
- #include "game_qfusion.h" /* qfusion game */
- ,
+ ,
+ #include "game_jk2.h" /* most be after game_sof2.h as they share defines! */
+ ,
+ #include "game_ja.h" /* most be after game_jk2.h as they share defines! */
+ ,
+ #include "game_qfusion.h" /* qfusion game */
+ ,
#include "game_reaction.h" /* must be after game_quake3.h */
- ,
- #include "game_darkplaces.h" /* vortex: darkplaces q1 engine */
- ,
- #include "game_dq.h" /* vortex: deluxe quake game ( darkplaces q1 engine) */
- ,
- #include "game_prophecy.h" /* vortex: prophecy game ( darkplaces q1 engine) */
- ,
- #include "game__null.h" /* null game (must be last item) */
- };
+ ,
+ #include "game_darkplaces.h" /* vortex: darkplaces q1 engine */
+ ,
+ #include "game_dq.h" /* vortex: deluxe quake game ( darkplaces q1 engine) */
+ ,
+ #include "game_prophecy.h" /* vortex: prophecy game ( darkplaces q1 engine) */
+ ,
+ #include "game__null.h" /* null game (must be last item) */
+ };
#endif
-Q_EXTERN game_t *game Q_ASSIGN( &games[ 0 ] );
+Q_EXTERN game_t *game Q_ASSIGN( &games[ 0 ] );
/* general */
-Q_EXTERN int numImages Q_ASSIGN( 0 );
-Q_EXTERN image_t images[ MAX_IMAGES ];
+Q_EXTERN int numImages Q_ASSIGN( 0 );
+Q_EXTERN image_t images[ MAX_IMAGES ];
-Q_EXTERN int numPicoModels Q_ASSIGN( 0 );
-Q_EXTERN picoModel_t *picoModels[ MAX_MODELS ];
+Q_EXTERN int numPicoModels Q_ASSIGN( 0 );
+Q_EXTERN picoModel_t *picoModels[ MAX_MODELS ];
-Q_EXTERN shaderInfo_t *shaderInfo Q_ASSIGN( NULL );
-Q_EXTERN int numShaderInfo Q_ASSIGN( 0 );
-Q_EXTERN int numVertexRemaps Q_ASSIGN( 0 );
+Q_EXTERN shaderInfo_t *shaderInfo Q_ASSIGN( NULL );
+Q_EXTERN int numShaderInfo Q_ASSIGN( 0 );
+Q_EXTERN int numVertexRemaps Q_ASSIGN( 0 );
-Q_EXTERN surfaceParm_t custSurfaceParms[ MAX_CUST_SURFACEPARMS ];
-Q_EXTERN int numCustSurfaceParms Q_ASSIGN( 0 );
+Q_EXTERN surfaceParm_t custSurfaceParms[ MAX_CUST_SURFACEPARMS ];
+Q_EXTERN int numCustSurfaceParms Q_ASSIGN( 0 );
-Q_EXTERN char mapName[ MAX_QPATH ]; /* ydnar: per-map custom shaders for larger lightmaps */
-Q_EXTERN char mapShaderFile[ 1024 ];
-Q_EXTERN qboolean warnImage Q_ASSIGN( qtrue );
+Q_EXTERN char mapName[ MAX_QPATH ]; /* ydnar: per-map custom shaders for larger lightmaps */
+Q_EXTERN char mapShaderFile[ 1024 ];
+Q_EXTERN qboolean warnImage Q_ASSIGN( qtrue );
/* ydnar: sinusoid samples */
-Q_EXTERN float jitters[ MAX_JITTERS ];
+Q_EXTERN float jitters[ MAX_JITTERS ];
/* commandline arguments */
-Q_EXTERN qboolean verbose;
-Q_EXTERN qboolean verboseEntities Q_ASSIGN( qfalse );
-Q_EXTERN qboolean force Q_ASSIGN( qfalse );
-Q_EXTERN qboolean infoMode Q_ASSIGN( qfalse );
-Q_EXTERN qboolean useCustomInfoParms Q_ASSIGN( qfalse );
-Q_EXTERN qboolean noprune Q_ASSIGN( qfalse );
-Q_EXTERN qboolean leaktest Q_ASSIGN( qfalse );
-Q_EXTERN qboolean nodetail Q_ASSIGN( qfalse );
-Q_EXTERN qboolean nosubdivide Q_ASSIGN( qfalse );
-Q_EXTERN qboolean notjunc Q_ASSIGN( qfalse );
-Q_EXTERN qboolean fulldetail Q_ASSIGN( qfalse );
-Q_EXTERN qboolean nowater Q_ASSIGN( qfalse );
-Q_EXTERN qboolean noCurveBrushes Q_ASSIGN( qfalse );
-Q_EXTERN qboolean fakemap Q_ASSIGN( qfalse );
-Q_EXTERN qboolean coplanar Q_ASSIGN( qfalse );
-Q_EXTERN qboolean nofog Q_ASSIGN( qfalse );
-Q_EXTERN qboolean noHint Q_ASSIGN( qfalse ); /* ydnar */
-Q_EXTERN qboolean renameModelShaders Q_ASSIGN( qfalse ); /* ydnar */
-Q_EXTERN qboolean skyFixHack Q_ASSIGN( qfalse ); /* ydnar */
-Q_EXTERN qboolean bspAlternateSplitWeights Q_ASSIGN( qfalse ); /* 27 */
-Q_EXTERN qboolean deepBSP Q_ASSIGN( qfalse ); /* div0 */
-Q_EXTERN qboolean maxAreaFaceSurface Q_ASSIGN( qfalse ); /* divVerent */
-
-Q_EXTERN int patchSubdivisions Q_ASSIGN( 8 ); /* ydnar: -patchmeta subdivisions */
-
-Q_EXTERN int maxLMSurfaceVerts Q_ASSIGN( 64 ); /* ydnar */
-Q_EXTERN int maxSurfaceVerts Q_ASSIGN( 999 ); /* ydnar */
-Q_EXTERN int maxSurfaceIndexes Q_ASSIGN( 6000 ); /* ydnar */
-Q_EXTERN float npDegrees Q_ASSIGN( 0.0f ); /* ydnar: nonplanar degrees */
-Q_EXTERN int bevelSnap Q_ASSIGN( 0 ); /* ydnar: bevel plane snap */
-Q_EXTERN int texRange Q_ASSIGN( 0 );
-Q_EXTERN qboolean flat Q_ASSIGN( qfalse );
-Q_EXTERN qboolean meta Q_ASSIGN( qfalse );
-Q_EXTERN qboolean patchMeta Q_ASSIGN( qfalse );
-Q_EXTERN qboolean emitFlares Q_ASSIGN( qfalse );
-Q_EXTERN qboolean debugSurfaces Q_ASSIGN( qfalse );
-Q_EXTERN qboolean debugInset Q_ASSIGN( qfalse );
-Q_EXTERN qboolean debugPortals Q_ASSIGN( qfalse );
+Q_EXTERN qboolean verbose;
+Q_EXTERN qboolean verboseEntities Q_ASSIGN( qfalse );
+Q_EXTERN qboolean force Q_ASSIGN( qfalse );
+Q_EXTERN qboolean infoMode Q_ASSIGN( qfalse );
+Q_EXTERN qboolean useCustomInfoParms Q_ASSIGN( qfalse );
+Q_EXTERN qboolean noprune Q_ASSIGN( qfalse );
+Q_EXTERN qboolean leaktest Q_ASSIGN( qfalse );
+Q_EXTERN qboolean nodetail Q_ASSIGN( qfalse );
+Q_EXTERN qboolean nosubdivide Q_ASSIGN( qfalse );
+Q_EXTERN qboolean notjunc Q_ASSIGN( qfalse );
+Q_EXTERN qboolean fulldetail Q_ASSIGN( qfalse );
+Q_EXTERN qboolean nowater Q_ASSIGN( qfalse );
+Q_EXTERN qboolean noCurveBrushes Q_ASSIGN( qfalse );
+Q_EXTERN qboolean fakemap Q_ASSIGN( qfalse );
+Q_EXTERN qboolean coplanar Q_ASSIGN( qfalse );
+Q_EXTERN qboolean nofog Q_ASSIGN( qfalse );
+Q_EXTERN qboolean noHint Q_ASSIGN( qfalse ); /* ydnar */
+Q_EXTERN qboolean renameModelShaders Q_ASSIGN( qfalse ); /* ydnar */
+Q_EXTERN qboolean skyFixHack Q_ASSIGN( qfalse ); /* ydnar */
+Q_EXTERN qboolean bspAlternateSplitWeights Q_ASSIGN( qfalse ); /* 27 */
+Q_EXTERN qboolean deepBSP Q_ASSIGN( qfalse ); /* div0 */
+Q_EXTERN qboolean maxAreaFaceSurface Q_ASSIGN( qfalse ); /* divVerent */
+
+Q_EXTERN int patchSubdivisions Q_ASSIGN( 8 ); /* ydnar: -patchmeta subdivisions */
+
+Q_EXTERN int maxLMSurfaceVerts Q_ASSIGN( 64 ); /* ydnar */
+Q_EXTERN int maxSurfaceVerts Q_ASSIGN( 999 ); /* ydnar */
+Q_EXTERN int maxSurfaceIndexes Q_ASSIGN( 6000 ); /* ydnar */
+Q_EXTERN float npDegrees Q_ASSIGN( 0.0f ); /* ydnar: nonplanar degrees */
+Q_EXTERN int bevelSnap Q_ASSIGN( 0 ); /* ydnar: bevel plane snap */
+Q_EXTERN int texRange Q_ASSIGN( 0 );
+Q_EXTERN qboolean flat Q_ASSIGN( qfalse );
+Q_EXTERN qboolean meta Q_ASSIGN( qfalse );
+Q_EXTERN qboolean patchMeta Q_ASSIGN( qfalse );
+Q_EXTERN qboolean emitFlares Q_ASSIGN( qfalse );
+Q_EXTERN qboolean debugSurfaces Q_ASSIGN( qfalse );
+Q_EXTERN qboolean debugInset Q_ASSIGN( qfalse );
+Q_EXTERN qboolean debugPortals Q_ASSIGN( qfalse );
Q_EXTERN qboolean lightmapTriangleCheck Q_ASSIGN( qfalse );
Q_EXTERN qboolean lightmapExtraVisClusterNudge Q_ASSIGN( qfalse );
Q_EXTERN qboolean lightmapFill Q_ASSIGN( qfalse );
// of this writing, FindFloatPlane() and AddBrushBevels()).
Q_EXTERN double normalEpsilon Q_ASSIGN( 0.00005 );
#else
-Q_EXTERN double normalEpsilon Q_ASSIGN( 0.00001 );
+Q_EXTERN double normalEpsilon Q_ASSIGN( 0.00001 );
#endif
#if Q3MAP2_EXPERIMENTAL_HIGH_PRECISION_MATH_FIXES
// (or even 2^14).
Q_EXTERN double distanceEpsilon Q_ASSIGN( 0.005 );
#else
-Q_EXTERN double distanceEpsilon Q_ASSIGN( 0.01 );
+Q_EXTERN double distanceEpsilon Q_ASSIGN( 0.01 );
#endif
/* bsp */
-Q_EXTERN int numMapEntities Q_ASSIGN( 0 );
+Q_EXTERN int numMapEntities Q_ASSIGN( 0 );
-Q_EXTERN int blockSize[ 3 ] /* should be the same as in radiant */
+Q_EXTERN int blockSize[ 3 ] /* should be the same as in radiant */
#ifndef MAIN_C
;
#else
- = { 1024, 1024, 1024 };
+ = { 1024, 1024, 1024 };
#endif
-Q_EXTERN char name[ 1024 ];
-Q_EXTERN char source[ 1024 ];
-Q_EXTERN char outbase[ 32 ];
+Q_EXTERN char name[ 1024 ];
+Q_EXTERN char source[ 1024 ];
+Q_EXTERN char outbase[ 32 ];
-Q_EXTERN int sampleSize; /* lightmap sample size in units */
-Q_EXTERN int minSampleSize; /* minimum sample size to use at all */
-Q_EXTERN int sampleScale; /* vortex: lightmap sample scale (ie quality)*/
+Q_EXTERN int sampleSize; /* lightmap sample size in units */
+Q_EXTERN int minSampleSize; /* minimum sample size to use at all */
+Q_EXTERN int sampleScale; /* vortex: lightmap sample scale (ie quality)*/
-Q_EXTERN int mapEntityNum Q_ASSIGN( 0 );
+Q_EXTERN int mapEntityNum Q_ASSIGN( 0 );
-Q_EXTERN int entitySourceBrushes;
+Q_EXTERN int entitySourceBrushes;
Q_EXTERN plane_t *mapplanes Q_ASSIGN( NULL ); /* mapplanes[ num ^ 1 ] will always be the mirror or mapplanes[ num ] */
Q_EXTERN int nummapplanes Q_ASSIGN( 0 ); /* nummapplanes will always be even */
Q_EXTERN int allocatedmapplanes Q_ASSIGN( 0 );
-Q_EXTERN int numMapPatches;
-Q_EXTERN vec3_t mapMins, mapMaxs;
+Q_EXTERN int numMapPatches;
+Q_EXTERN vec3_t mapMins, mapMaxs;
-Q_EXTERN int defaultFogNum Q_ASSIGN( -1 ); /* ydnar: cleaner fog handling */
-Q_EXTERN int numMapFogs Q_ASSIGN( 0 );
-Q_EXTERN fog_t mapFogs[ MAX_MAP_FOGS ];
+Q_EXTERN int defaultFogNum Q_ASSIGN( -1 ); /* ydnar: cleaner fog handling */
+Q_EXTERN int numMapFogs Q_ASSIGN( 0 );
+Q_EXTERN fog_t mapFogs[ MAX_MAP_FOGS ];
-Q_EXTERN entity_t *mapEnt;
-Q_EXTERN brush_t *buildBrush;
-Q_EXTERN int numActiveBrushes;
-Q_EXTERN int g_bBrushPrimit;
+Q_EXTERN entity_t *mapEnt;
+Q_EXTERN brush_t *buildBrush;
+Q_EXTERN int numActiveBrushes;
+Q_EXTERN int g_bBrushPrimit;
-Q_EXTERN int numStrippedLights Q_ASSIGN( 0 );
+Q_EXTERN int numStrippedLights Q_ASSIGN( 0 );
/* surface stuff */
-Q_EXTERN mapDrawSurface_t *mapDrawSurfs Q_ASSIGN( NULL );
-Q_EXTERN int numMapDrawSurfs;
+Q_EXTERN mapDrawSurface_t *mapDrawSurfs Q_ASSIGN( NULL );
+Q_EXTERN int numMapDrawSurfs;
-Q_EXTERN int numSurfacesByType[ NUM_SURFACE_TYPES ];
-Q_EXTERN int numClearedSurfaces;
-Q_EXTERN int numStripSurfaces;
-Q_EXTERN int numMaxAreaSurfaces;
-Q_EXTERN int numFanSurfaces;
-Q_EXTERN int numMergedSurfaces;
-Q_EXTERN int numMergedVerts;
+Q_EXTERN int numSurfacesByType[ NUM_SURFACE_TYPES ];
+Q_EXTERN int numClearedSurfaces;
+Q_EXTERN int numStripSurfaces;
+Q_EXTERN int numMaxAreaSurfaces;
+Q_EXTERN int numFanSurfaces;
+Q_EXTERN int numMergedSurfaces;
+Q_EXTERN int numMergedVerts;
-Q_EXTERN int numRedundantIndexes;
+Q_EXTERN int numRedundantIndexes;
-Q_EXTERN int numSurfaceModels Q_ASSIGN( 0 );
+Q_EXTERN int numSurfaceModels Q_ASSIGN( 0 );
-Q_EXTERN byte debugColors[ 12 ][ 3 ]
+Q_EXTERN byte debugColors[ 12 ][ 3 ]
#ifndef MAIN_C
;
#else
- =
- {
- { 255, 0, 0 },
- { 192, 128, 128 },
- { 255, 255, 0 },
- { 192, 192, 128 },
- { 0, 255, 255 },
- { 128, 192, 192 },
- { 0, 0, 255 },
- { 128, 128, 192 },
- { 255, 0, 255 },
- { 192, 128, 192 },
- { 0, 255, 0 },
- { 128, 192, 128 }
- };
+ =
+ {
+ { 255, 0, 0 },
+ { 192, 128, 128 },
+ { 255, 255, 0 },
+ { 192, 192, 128 },
+ { 0, 255, 255 },
+ { 128, 192, 192 },
+ { 0, 0, 255 },
+ { 128, 128, 192 },
+ { 255, 0, 255 },
+ { 192, 128, 192 },
+ { 0, 255, 0 },
+ { 128, 192, 128 }
+ };
#endif
-Q_EXTERN qboolean skyboxPresent Q_ASSIGN( qfalse );
-Q_EXTERN int skyboxArea Q_ASSIGN( -1 );
-Q_EXTERN m4x4_t skyboxTransform;
+Q_EXTERN qboolean skyboxPresent Q_ASSIGN( qfalse );
+Q_EXTERN int skyboxArea Q_ASSIGN( -1 );
+Q_EXTERN m4x4_t skyboxTransform;
------------------------------------------------------------------------------- */
/* commandline arguments */
-Q_EXTERN qboolean fastvis;
-Q_EXTERN qboolean noPassageVis;
-Q_EXTERN qboolean passageVisOnly;
-Q_EXTERN qboolean mergevis;
-Q_EXTERN qboolean mergevisportals;
-Q_EXTERN qboolean nosort;
-Q_EXTERN qboolean saveprt;
-Q_EXTERN qboolean hint; /* ydnar */
-Q_EXTERN char inbase[ MAX_QPATH ];
-Q_EXTERN char globalCelShader[ MAX_QPATH ];
+Q_EXTERN qboolean fastvis;
+Q_EXTERN qboolean noPassageVis;
+Q_EXTERN qboolean passageVisOnly;
+Q_EXTERN qboolean mergevis;
+Q_EXTERN qboolean mergevisportals;
+Q_EXTERN qboolean nosort;
+Q_EXTERN qboolean saveprt;
+Q_EXTERN qboolean hint; /* ydnar */
+Q_EXTERN char inbase[ MAX_QPATH ];
+Q_EXTERN char globalCelShader[ MAX_QPATH ];
-Q_EXTERN float farPlaneDist; /* rr2do2, rf, mre, ydnar all contributed to this one... */
+Q_EXTERN float farPlaneDist; /* rr2do2, rf, mre, ydnar all contributed to this one... */
-Q_EXTERN int numportals;
-Q_EXTERN int portalclusters;
+Q_EXTERN int numportals;
+Q_EXTERN int portalclusters;
-Q_EXTERN vportal_t *portals;
-Q_EXTERN leaf_t *leafs;
+Q_EXTERN vportal_t *portals;
+Q_EXTERN leaf_t *leafs;
-Q_EXTERN vportal_t *faces;
-Q_EXTERN leaf_t *faceleafs;
+Q_EXTERN vportal_t *faces;
+Q_EXTERN leaf_t *faceleafs;
-Q_EXTERN int numfaces;
+Q_EXTERN int numfaces;
-Q_EXTERN int c_portaltest, c_portalpass, c_portalcheck;
-Q_EXTERN int c_portalskip, c_leafskip;
-Q_EXTERN int c_vistest, c_mighttest;
-Q_EXTERN int c_chains;
+Q_EXTERN int c_portaltest, c_portalpass, c_portalcheck;
+Q_EXTERN int c_portalskip, c_leafskip;
+Q_EXTERN int c_vistest, c_mighttest;
+Q_EXTERN int c_chains;
-Q_EXTERN byte *vismap, *vismap_p, *vismap_end;
+Q_EXTERN byte *vismap, *vismap_p, *vismap_end;
-Q_EXTERN int testlevel;
+Q_EXTERN int testlevel;
-Q_EXTERN byte *uncompressed;
+Q_EXTERN byte *uncompressed;
-Q_EXTERN int leafbytes, leaflongs;
-Q_EXTERN int portalbytes, portallongs;
+Q_EXTERN int leafbytes, leaflongs;
+Q_EXTERN int portalbytes, portallongs;
-Q_EXTERN vportal_t *sorted_portals[ MAX_MAP_PORTALS * 2 ];
+Q_EXTERN vportal_t *sorted_portals[ MAX_MAP_PORTALS * 2 ];
------------------------------------------------------------------------------- */
/* commandline arguments */
-Q_EXTERN qboolean wolfLight Q_ASSIGN( qfalse );
-Q_EXTERN float extraDist Q_ASSIGN( 0.0f );
-Q_EXTERN qboolean loMem Q_ASSIGN( qfalse );
-Q_EXTERN qboolean noStyles Q_ASSIGN( qfalse );
-Q_EXTERN qboolean keepLights Q_ASSIGN( qfalse );
-
-Q_EXTERN int sampleSize Q_ASSIGN( DEFAULT_LIGHTMAP_SAMPLE_SIZE );
-Q_EXTERN int minSampleSize Q_ASSIGN( DEFAULT_LIGHTMAP_MIN_SAMPLE_SIZE );
-Q_EXTERN qboolean noVertexLighting Q_ASSIGN( qfalse );
-Q_EXTERN qboolean noGridLighting Q_ASSIGN( qfalse );
-
-Q_EXTERN qboolean noTrace Q_ASSIGN( qfalse );
-Q_EXTERN qboolean noSurfaces Q_ASSIGN( qfalse );
-Q_EXTERN qboolean patchShadows Q_ASSIGN( qfalse );
-Q_EXTERN qboolean cpmaHack Q_ASSIGN( qfalse );
-
-Q_EXTERN qboolean deluxemap Q_ASSIGN( qfalse );
-Q_EXTERN qboolean debugDeluxemap Q_ASSIGN( qfalse );
-Q_EXTERN int deluxemode Q_ASSIGN( 0 ); /* deluxemap format (0 - modelspace, 1 - tangentspace with renormalization, 2 - tangentspace without renormalization) */
-
-Q_EXTERN qboolean fast Q_ASSIGN( qfalse );
+Q_EXTERN qboolean wolfLight Q_ASSIGN( qfalse );
+Q_EXTERN float extraDist Q_ASSIGN( 0.0f );
+Q_EXTERN qboolean loMem Q_ASSIGN( qfalse );
+Q_EXTERN qboolean noStyles Q_ASSIGN( qfalse );
+Q_EXTERN qboolean keepLights Q_ASSIGN( qfalse );
+
+Q_EXTERN int sampleSize Q_ASSIGN( DEFAULT_LIGHTMAP_SAMPLE_SIZE );
+Q_EXTERN int minSampleSize Q_ASSIGN( DEFAULT_LIGHTMAP_MIN_SAMPLE_SIZE );
+Q_EXTERN qboolean noVertexLighting Q_ASSIGN( qfalse );
+Q_EXTERN qboolean noGridLighting Q_ASSIGN( qfalse );
+
+Q_EXTERN qboolean noTrace Q_ASSIGN( qfalse );
+Q_EXTERN qboolean noSurfaces Q_ASSIGN( qfalse );
+Q_EXTERN qboolean patchShadows Q_ASSIGN( qfalse );
+Q_EXTERN qboolean cpmaHack Q_ASSIGN( qfalse );
+
+Q_EXTERN qboolean deluxemap Q_ASSIGN( qfalse );
+Q_EXTERN qboolean debugDeluxemap Q_ASSIGN( qfalse );
+Q_EXTERN int deluxemode Q_ASSIGN( 0 ); /* deluxemap format (0 - modelspace, 1 - tangentspace with renormalization, 2 - tangentspace without renormalization) */
+
+Q_EXTERN qboolean fast Q_ASSIGN( qfalse );
Q_EXTERN qboolean fastpoint Q_ASSIGN( qtrue );
-Q_EXTERN qboolean faster Q_ASSIGN( qfalse );
-Q_EXTERN qboolean fastgrid Q_ASSIGN( qfalse );
-Q_EXTERN qboolean fastbounce Q_ASSIGN( qfalse );
-Q_EXTERN qboolean cheap Q_ASSIGN( qfalse );
-Q_EXTERN qboolean cheapgrid Q_ASSIGN( qfalse );
-Q_EXTERN int bounce Q_ASSIGN( 0 );
-Q_EXTERN qboolean bounceOnly Q_ASSIGN( qfalse );
-Q_EXTERN qboolean bouncing Q_ASSIGN( qfalse );
-Q_EXTERN qboolean bouncegrid Q_ASSIGN( qfalse );
-Q_EXTERN qboolean normalmap Q_ASSIGN( qfalse );
-Q_EXTERN qboolean trisoup Q_ASSIGN( qfalse );
-Q_EXTERN qboolean shade Q_ASSIGN( qfalse );
-Q_EXTERN float shadeAngleDegrees Q_ASSIGN( 0.0f );
-Q_EXTERN int superSample Q_ASSIGN( 0 );
-Q_EXTERN int lightSamples Q_ASSIGN( 1 );
-Q_EXTERN qboolean lightRandomSamples Q_ASSIGN( qfalse );
-Q_EXTERN int lightSamplesSearchBoxSize Q_ASSIGN( 1 );
-Q_EXTERN qboolean filter Q_ASSIGN( qfalse );
-Q_EXTERN qboolean dark Q_ASSIGN( qfalse );
-Q_EXTERN qboolean sunOnly Q_ASSIGN( qfalse );
-Q_EXTERN int approximateTolerance Q_ASSIGN( 0 );
-Q_EXTERN qboolean noCollapse Q_ASSIGN( qfalse );
-Q_EXTERN int lightmapSearchBlockSize Q_ASSIGN( 0 );
-Q_EXTERN qboolean exportLightmaps Q_ASSIGN( qfalse );
-Q_EXTERN qboolean externalLightmaps Q_ASSIGN( qfalse );
-Q_EXTERN int lmCustomSize Q_ASSIGN( LIGHTMAP_WIDTH );
-Q_EXTERN char * lmCustomDir Q_ASSIGN( NULL );
-Q_EXTERN int lmLimitSize Q_ASSIGN( 0 );
-
-Q_EXTERN qboolean dirty Q_ASSIGN( qfalse );
-Q_EXTERN qboolean dirtDebug Q_ASSIGN( qfalse );
-Q_EXTERN int dirtMode Q_ASSIGN( 0 );
-Q_EXTERN float dirtDepth Q_ASSIGN( 128.0f );
-Q_EXTERN float dirtScale Q_ASSIGN( 1.0f );
-Q_EXTERN float dirtGain Q_ASSIGN( 1.0f );
+Q_EXTERN qboolean faster Q_ASSIGN( qfalse );
+Q_EXTERN qboolean fastgrid Q_ASSIGN( qfalse );
+Q_EXTERN qboolean fastbounce Q_ASSIGN( qfalse );
+Q_EXTERN qboolean cheap Q_ASSIGN( qfalse );
+Q_EXTERN qboolean cheapgrid Q_ASSIGN( qfalse );
+Q_EXTERN int bounce Q_ASSIGN( 0 );
+Q_EXTERN qboolean bounceOnly Q_ASSIGN( qfalse );
+Q_EXTERN qboolean bouncing Q_ASSIGN( qfalse );
+Q_EXTERN qboolean bouncegrid Q_ASSIGN( qfalse );
+Q_EXTERN qboolean normalmap Q_ASSIGN( qfalse );
+Q_EXTERN qboolean trisoup Q_ASSIGN( qfalse );
+Q_EXTERN qboolean shade Q_ASSIGN( qfalse );
+Q_EXTERN float shadeAngleDegrees Q_ASSIGN( 0.0f );
+Q_EXTERN int superSample Q_ASSIGN( 0 );
+Q_EXTERN int lightSamples Q_ASSIGN( 1 );
+Q_EXTERN qboolean lightRandomSamples Q_ASSIGN( qfalse );
+Q_EXTERN int lightSamplesSearchBoxSize Q_ASSIGN( 1 );
+Q_EXTERN qboolean filter Q_ASSIGN( qfalse );
+Q_EXTERN qboolean dark Q_ASSIGN( qfalse );
+Q_EXTERN qboolean sunOnly Q_ASSIGN( qfalse );
+Q_EXTERN int approximateTolerance Q_ASSIGN( 0 );
+Q_EXTERN qboolean noCollapse Q_ASSIGN( qfalse );
+Q_EXTERN int lightmapSearchBlockSize Q_ASSIGN( 0 );
+Q_EXTERN qboolean exportLightmaps Q_ASSIGN( qfalse );
+Q_EXTERN qboolean externalLightmaps Q_ASSIGN( qfalse );
+Q_EXTERN int lmCustomSize Q_ASSIGN( LIGHTMAP_WIDTH );
+Q_EXTERN char * lmCustomDir Q_ASSIGN( NULL );
+Q_EXTERN int lmLimitSize Q_ASSIGN( 0 );
+
+Q_EXTERN qboolean dirty Q_ASSIGN( qfalse );
+Q_EXTERN qboolean dirtDebug Q_ASSIGN( qfalse );
+Q_EXTERN int dirtMode Q_ASSIGN( 0 );
+Q_EXTERN float dirtDepth Q_ASSIGN( 128.0f );
+Q_EXTERN float dirtScale Q_ASSIGN( 1.0f );
+Q_EXTERN float dirtGain Q_ASSIGN( 1.0f );
/* 27: floodlighting */
-Q_EXTERN qboolean debugnormals Q_ASSIGN( qfalse );
-Q_EXTERN qboolean floodlighty Q_ASSIGN( qfalse );
-Q_EXTERN qboolean floodlight_lowquality Q_ASSIGN( qfalse );
-Q_EXTERN vec3_t floodlightRGB;
-Q_EXTERN float floodlightIntensity Q_ASSIGN( 512.0f );
-Q_EXTERN float floodlightDistance Q_ASSIGN( 1024.0f );
-Q_EXTERN float floodlightDirectionScale Q_ASSIGN( 1.0f );
-
-Q_EXTERN qboolean dump Q_ASSIGN( qfalse );
-Q_EXTERN qboolean debug Q_ASSIGN( qfalse );
-Q_EXTERN qboolean debugUnused Q_ASSIGN( qfalse );
-Q_EXTERN qboolean debugAxis Q_ASSIGN( qfalse );
-Q_EXTERN qboolean debugCluster Q_ASSIGN( qfalse );
-Q_EXTERN qboolean debugOrigin Q_ASSIGN( qfalse );
-Q_EXTERN qboolean lightmapBorder Q_ASSIGN( qfalse );
+Q_EXTERN qboolean debugnormals Q_ASSIGN( qfalse );
+Q_EXTERN qboolean floodlighty Q_ASSIGN( qfalse );
+Q_EXTERN qboolean floodlight_lowquality Q_ASSIGN( qfalse );
+Q_EXTERN vec3_t floodlightRGB;
+Q_EXTERN float floodlightIntensity Q_ASSIGN( 512.0f );
+Q_EXTERN float floodlightDistance Q_ASSIGN( 1024.0f );
+Q_EXTERN float floodlightDirectionScale Q_ASSIGN( 1.0f );
+
+Q_EXTERN qboolean dump Q_ASSIGN( qfalse );
+Q_EXTERN qboolean debug Q_ASSIGN( qfalse );
+Q_EXTERN qboolean debugUnused Q_ASSIGN( qfalse );
+Q_EXTERN qboolean debugAxis Q_ASSIGN( qfalse );
+Q_EXTERN qboolean debugCluster Q_ASSIGN( qfalse );
+Q_EXTERN qboolean debugOrigin Q_ASSIGN( qfalse );
+Q_EXTERN qboolean lightmapBorder Q_ASSIGN( qfalse );
/* longest distance across the map */
-Q_EXTERN float maxMapDistance Q_ASSIGN( 0 );
+Q_EXTERN float maxMapDistance Q_ASSIGN( 0 );
/* for run time tweaking of light sources */
-Q_EXTERN float pointScale Q_ASSIGN( 7500.0f );
+Q_EXTERN float pointScale Q_ASSIGN( 7500.0f );
Q_EXTERN float spotScale Q_ASSIGN( 7500.0f );
-Q_EXTERN float areaScale Q_ASSIGN( 0.25f );
-Q_EXTERN float skyScale Q_ASSIGN( 1.0f );
-Q_EXTERN float bounceScale Q_ASSIGN( 0.25f );
+Q_EXTERN float areaScale Q_ASSIGN( 0.25f );
+Q_EXTERN float skyScale Q_ASSIGN( 1.0f );
+Q_EXTERN float bounceScale Q_ASSIGN( 0.25f );
/* jal: alternative angle attenuation curve */
-Q_EXTERN qboolean lightAngleHL Q_ASSIGN( qfalse );
-
+Q_EXTERN qboolean lightAngleHL Q_ASSIGN( qfalse );
+
/* vortex: gridscale and gridambientscale */
-Q_EXTERN float gridScale Q_ASSIGN( 1.0f );
-Q_EXTERN float gridAmbientScale Q_ASSIGN( 1.0f );
-Q_EXTERN float gridDirectionality Q_ASSIGN( 1.0f );
-Q_EXTERN float gridAmbientDirectionality Q_ASSIGN( 0.0f );
+Q_EXTERN float gridScale Q_ASSIGN( 1.0f );
+Q_EXTERN float gridAmbientScale Q_ASSIGN( 1.0f );
+Q_EXTERN float gridDirectionality Q_ASSIGN( 1.0f );
+Q_EXTERN float gridAmbientDirectionality Q_ASSIGN( 0.0f );
Q_EXTERN qboolean inGrid Q_ASSIGN( 0 );
/* ydnar: lightmap gamma/compensation */
-Q_EXTERN float lightmapGamma Q_ASSIGN( 1.0f );
+Q_EXTERN float lightmapGamma Q_ASSIGN( 1.0f );
Q_EXTERN float lightmapsRGB Q_ASSIGN( qfalse );
Q_EXTERN float texturesRGB Q_ASSIGN( qfalse );
Q_EXTERN float colorsRGB Q_ASSIGN( qfalse );
Q_EXTERN float lightmapExposure Q_ASSIGN( 0.0f );
-Q_EXTERN float lightmapCompensate Q_ASSIGN( 1.0f );
+Q_EXTERN float lightmapCompensate Q_ASSIGN( 1.0f );
/* ydnar: for runtime tweaking of falloff tolerance */
-Q_EXTERN float falloffTolerance Q_ASSIGN( 1.0f );
-Q_EXTERN qboolean exactPointToPolygon Q_ASSIGN( qtrue );
-Q_EXTERN float formFactorValueScale Q_ASSIGN( 3.0f );
-Q_EXTERN float linearScale Q_ASSIGN( 1.0f / 8000.0f );
+Q_EXTERN float falloffTolerance Q_ASSIGN( 1.0f );
+Q_EXTERN qboolean exactPointToPolygon Q_ASSIGN( qtrue );
+Q_EXTERN float formFactorValueScale Q_ASSIGN( 3.0f );
+Q_EXTERN float linearScale Q_ASSIGN( 1.0f / 8000.0f );
// for .ase conversion
-Q_EXTERN qboolean shadersAsBitmap Q_ASSIGN( qfalse );
-Q_EXTERN qboolean lightmapsAsTexcoord Q_ASSIGN( qfalse );
+Q_EXTERN qboolean shadersAsBitmap Q_ASSIGN( qfalse );
+Q_EXTERN qboolean lightmapsAsTexcoord Q_ASSIGN( qfalse );
-Q_EXTERN light_t *lights;
-Q_EXTERN int numPointLights;
-Q_EXTERN int numSpotLights;
-Q_EXTERN int numSunLights;
-Q_EXTERN int numAreaLights;
+Q_EXTERN light_t *lights;
+Q_EXTERN int numPointLights;
+Q_EXTERN int numSpotLights;
+Q_EXTERN int numSunLights;
+Q_EXTERN int numAreaLights;
/* ydnar: for luxel placement */
-Q_EXTERN int numSurfaceClusters, maxSurfaceClusters;
-Q_EXTERN int *surfaceClusters;
+Q_EXTERN int numSurfaceClusters, maxSurfaceClusters;
+Q_EXTERN int *surfaceClusters;
/* ydnar: for radiosity */
-Q_EXTERN int numDiffuseLights;
-Q_EXTERN int numBrushDiffuseLights;
-Q_EXTERN int numTriangleDiffuseLights;
-Q_EXTERN int numPatchDiffuseLights;
+Q_EXTERN int numDiffuseLights;
+Q_EXTERN int numBrushDiffuseLights;
+Q_EXTERN int numTriangleDiffuseLights;
+Q_EXTERN int numPatchDiffuseLights;
/* ydnar: general purpose extra copy of drawvert list */
-Q_EXTERN bspDrawVert_t *yDrawVerts;
+Q_EXTERN bspDrawVert_t *yDrawVerts;
/* ydnar: for tracing statistics */
-Q_EXTERN int minSurfacesTested;
-Q_EXTERN int maxSurfacesTested;
-Q_EXTERN int totalSurfacesTested;
-Q_EXTERN int totalTraces;
+Q_EXTERN int minSurfacesTested;
+Q_EXTERN int maxSurfacesTested;
+Q_EXTERN int totalSurfacesTested;
+Q_EXTERN int totalTraces;
-Q_EXTERN FILE *dumpFile;
+Q_EXTERN FILE *dumpFile;
-Q_EXTERN int c_visible, c_occluded;
-Q_EXTERN int c_subsampled; /* ydnar */
+Q_EXTERN int c_visible, c_occluded;
+Q_EXTERN int c_subsampled; /* ydnar */
-Q_EXTERN int defaultLightSubdivide Q_ASSIGN( 999 );
+Q_EXTERN int defaultLightSubdivide Q_ASSIGN( 999 );
-Q_EXTERN vec3_t ambientColor;
-Q_EXTERN vec3_t minLight, minVertexLight, minGridLight;
+Q_EXTERN vec3_t ambientColor;
+Q_EXTERN vec3_t minLight, minVertexLight, minGridLight;
-Q_EXTERN int *entitySurface;
-Q_EXTERN vec3_t *surfaceOrigin;
+Q_EXTERN int *entitySurface;
+Q_EXTERN vec3_t *surfaceOrigin;
-Q_EXTERN vec3_t sunDirection;
-Q_EXTERN vec3_t sunLight;
+Q_EXTERN vec3_t sunDirection;
+Q_EXTERN vec3_t sunLight;
/* tracing */
-Q_EXTERN int c_totalTrace;
-Q_EXTERN int c_cullTrace, c_testTrace;
-Q_EXTERN int c_testFacets;
+Q_EXTERN int c_totalTrace;
+Q_EXTERN int c_cullTrace, c_testTrace;
+Q_EXTERN int c_testFacets;
/* ydnar: light optimization */
-Q_EXTERN float subdivideThreshold Q_ASSIGN( DEFAULT_SUBDIVIDE_THRESHOLD );
+Q_EXTERN float subdivideThreshold Q_ASSIGN( DEFAULT_SUBDIVIDE_THRESHOLD );
-Q_EXTERN int numOpaqueBrushes, maxOpaqueBrush;
-Q_EXTERN byte *opaqueBrushes;
+Q_EXTERN int numOpaqueBrushes, maxOpaqueBrush;
+Q_EXTERN byte *opaqueBrushes;
-Q_EXTERN int numLights;
-Q_EXTERN int numCulledLights;
+Q_EXTERN int numLights;
+Q_EXTERN int numCulledLights;
-Q_EXTERN int gridBoundsCulled;
-Q_EXTERN int gridEnvelopeCulled;
+Q_EXTERN int gridBoundsCulled;
+Q_EXTERN int gridEnvelopeCulled;
-Q_EXTERN int lightsBoundsCulled;
-Q_EXTERN int lightsEnvelopeCulled;
-Q_EXTERN int lightsPlaneCulled;
-Q_EXTERN int lightsClusterCulled;
+Q_EXTERN int lightsBoundsCulled;
+Q_EXTERN int lightsEnvelopeCulled;
+Q_EXTERN int lightsPlaneCulled;
+Q_EXTERN int lightsClusterCulled;
/* ydnar: radiosity */
-Q_EXTERN float diffuseSubdivide Q_ASSIGN( 256.0f );
-Q_EXTERN float minDiffuseSubdivide Q_ASSIGN( 64.0f );
-Q_EXTERN int numDiffuseSurfaces Q_ASSIGN( 0 );
+Q_EXTERN float diffuseSubdivide Q_ASSIGN( 256.0f );
+Q_EXTERN float minDiffuseSubdivide Q_ASSIGN( 64.0f );
+Q_EXTERN int numDiffuseSurfaces Q_ASSIGN( 0 );
/* ydnar: list of surface information necessary for lightmap calculation */
-Q_EXTERN surfaceInfo_t *surfaceInfos Q_ASSIGN( NULL );
+Q_EXTERN surfaceInfo_t *surfaceInfos Q_ASSIGN( NULL );
/* ydnar: sorted list of surfaces */
-Q_EXTERN int *sortSurfaces Q_ASSIGN( NULL );
+Q_EXTERN int *sortSurfaces Q_ASSIGN( NULL );
/* clumps of surfaces that share a raw lightmap */
-Q_EXTERN int numLightSurfaces Q_ASSIGN( 0 );
-Q_EXTERN int *lightSurfaces Q_ASSIGN( NULL );
+Q_EXTERN int numLightSurfaces Q_ASSIGN( 0 );
+Q_EXTERN int *lightSurfaces Q_ASSIGN( NULL );
/* raw lightmaps */
-Q_EXTERN int numRawSuperLuxels Q_ASSIGN( 0 );
-Q_EXTERN int numRawLightmaps Q_ASSIGN( 0 );
-Q_EXTERN rawLightmap_t *rawLightmaps Q_ASSIGN( NULL );
-Q_EXTERN int *sortLightmaps Q_ASSIGN( NULL );
+Q_EXTERN int numRawSuperLuxels Q_ASSIGN( 0 );
+Q_EXTERN int numRawLightmaps Q_ASSIGN( 0 );
+Q_EXTERN rawLightmap_t *rawLightmaps Q_ASSIGN( NULL );
+Q_EXTERN int *sortLightmaps Q_ASSIGN( NULL );
/* vertex luxels */
-Q_EXTERN float *vertexLuxels[ MAX_LIGHTMAPS ];
-Q_EXTERN float *radVertexLuxels[ MAX_LIGHTMAPS ];
+Q_EXTERN float *vertexLuxels[ MAX_LIGHTMAPS ];
+Q_EXTERN float *radVertexLuxels[ MAX_LIGHTMAPS ];
/* bsp lightmaps */
-Q_EXTERN int numLightmapShaders Q_ASSIGN( 0 );
-Q_EXTERN int numSolidLightmaps Q_ASSIGN( 0 );
-Q_EXTERN int numOutLightmaps Q_ASSIGN( 0 );
-Q_EXTERN int numBSPLightmaps Q_ASSIGN( 0 );
-Q_EXTERN int numExtLightmaps Q_ASSIGN( 0 );
-Q_EXTERN outLightmap_t *outLightmaps Q_ASSIGN( NULL );
+Q_EXTERN int numLightmapShaders Q_ASSIGN( 0 );
+Q_EXTERN int numSolidLightmaps Q_ASSIGN( 0 );
+Q_EXTERN int numOutLightmaps Q_ASSIGN( 0 );
+Q_EXTERN int numBSPLightmaps Q_ASSIGN( 0 );
+Q_EXTERN int numExtLightmaps Q_ASSIGN( 0 );
+Q_EXTERN outLightmap_t *outLightmaps Q_ASSIGN( NULL );
/* vortex: per surface floodlight statictics */
-Q_EXTERN int numSurfacesFloodlighten Q_ASSIGN( 0 );
+Q_EXTERN int numSurfacesFloodlighten Q_ASSIGN( 0 );
/* grid points */
-Q_EXTERN int numRawGridPoints Q_ASSIGN( 0 );
-Q_EXTERN rawGridPoint_t *rawGridPoints Q_ASSIGN( NULL );
-
-Q_EXTERN int numSurfsVertexLit Q_ASSIGN( 0 );
-Q_EXTERN int numSurfsVertexForced Q_ASSIGN( 0 );
-Q_EXTERN int numSurfsVertexApproximated Q_ASSIGN( 0 );
-Q_EXTERN int numSurfsLightmapped Q_ASSIGN( 0 );
-Q_EXTERN int numPlanarsLightmapped Q_ASSIGN( 0 );
-Q_EXTERN int numNonPlanarsLightmapped Q_ASSIGN( 0 );
-Q_EXTERN int numPatchesLightmapped Q_ASSIGN( 0 );
-Q_EXTERN int numPlanarPatchesLightmapped Q_ASSIGN( 0 );
-
-Q_EXTERN int numLuxels Q_ASSIGN( 0 );
-Q_EXTERN int numLuxelsMapped Q_ASSIGN( 0 );
-Q_EXTERN int numLuxelsOccluded Q_ASSIGN( 0 );
-Q_EXTERN int numLuxelsIlluminated Q_ASSIGN( 0 );
-Q_EXTERN int numVertsIlluminated Q_ASSIGN( 0 );
+Q_EXTERN int numRawGridPoints Q_ASSIGN( 0 );
+Q_EXTERN rawGridPoint_t *rawGridPoints Q_ASSIGN( NULL );
+
+Q_EXTERN int numSurfsVertexLit Q_ASSIGN( 0 );
+Q_EXTERN int numSurfsVertexForced Q_ASSIGN( 0 );
+Q_EXTERN int numSurfsVertexApproximated Q_ASSIGN( 0 );
+Q_EXTERN int numSurfsLightmapped Q_ASSIGN( 0 );
+Q_EXTERN int numPlanarsLightmapped Q_ASSIGN( 0 );
+Q_EXTERN int numNonPlanarsLightmapped Q_ASSIGN( 0 );
+Q_EXTERN int numPatchesLightmapped Q_ASSIGN( 0 );
+Q_EXTERN int numPlanarPatchesLightmapped Q_ASSIGN( 0 );
+
+Q_EXTERN int numLuxels Q_ASSIGN( 0 );
+Q_EXTERN int numLuxelsMapped Q_ASSIGN( 0 );
+Q_EXTERN int numLuxelsOccluded Q_ASSIGN( 0 );
+Q_EXTERN int numLuxelsIlluminated Q_ASSIGN( 0 );
+Q_EXTERN int numVertsIlluminated Q_ASSIGN( 0 );
/* lightgrid */
-Q_EXTERN vec3_t gridMins;
-Q_EXTERN int gridBounds[ 3 ];
-Q_EXTERN vec3_t gridSize
+Q_EXTERN vec3_t gridMins;
+Q_EXTERN int gridBounds[ 3 ];
+Q_EXTERN vec3_t gridSize
#ifndef MAIN_C
;
#else
- = { 64, 64, 128 };
+ = { 64, 64, 128 };
#endif
------------------------------------------------------------------------------- */
-Q_EXTERN int numEntities Q_ASSIGN( 0 );
-Q_EXTERN int numBSPEntities Q_ASSIGN( 0 );
+Q_EXTERN int numEntities Q_ASSIGN( 0 );
+Q_EXTERN int numBSPEntities Q_ASSIGN( 0 );
Q_EXTERN int allocatedEntities Q_ASSIGN( 0 );
Q_EXTERN entity_t* entities Q_ASSIGN( NULL );
-Q_EXTERN int numBSPModels Q_ASSIGN( 0 );
-Q_EXTERN int allocatedBSPModels Q_ASSIGN( 0 );
+Q_EXTERN int numBSPModels Q_ASSIGN( 0 );
+Q_EXTERN int allocatedBSPModels Q_ASSIGN( 0 );
Q_EXTERN bspModel_t* bspModels Q_ASSIGN( NULL );
-Q_EXTERN int numBSPShaders Q_ASSIGN( 0 );
-Q_EXTERN int allocatedBSPShaders Q_ASSIGN( 0 );
+Q_EXTERN int numBSPShaders Q_ASSIGN( 0 );
+Q_EXTERN int allocatedBSPShaders Q_ASSIGN( 0 );
Q_EXTERN bspShader_t* bspShaders Q_ASSIGN( 0 );
-Q_EXTERN int bspEntDataSize Q_ASSIGN( 0 );
-Q_EXTERN int allocatedBSPEntData Q_ASSIGN( 0 );
+Q_EXTERN int bspEntDataSize Q_ASSIGN( 0 );
+Q_EXTERN int allocatedBSPEntData Q_ASSIGN( 0 );
Q_EXTERN char *bspEntData Q_ASSIGN( 0 );
-Q_EXTERN int numBSPLeafs Q_ASSIGN( 0 );
-Q_EXTERN bspLeaf_t bspLeafs[ MAX_MAP_LEAFS ];
+Q_EXTERN int numBSPLeafs Q_ASSIGN( 0 );
+Q_EXTERN bspLeaf_t bspLeafs[ MAX_MAP_LEAFS ];
-Q_EXTERN int numBSPPlanes Q_ASSIGN( 0 );
+Q_EXTERN int numBSPPlanes Q_ASSIGN( 0 );
Q_EXTERN int allocatedBSPPlanes Q_ASSIGN( 0 );
-Q_EXTERN bspPlane_t *bspPlanes;
+Q_EXTERN bspPlane_t *bspPlanes;
-Q_EXTERN int numBSPNodes Q_ASSIGN( 0 );
-Q_EXTERN int allocatedBSPNodes Q_ASSIGN( 0 );
+Q_EXTERN int numBSPNodes Q_ASSIGN( 0 );
+Q_EXTERN int allocatedBSPNodes Q_ASSIGN( 0 );
Q_EXTERN bspNode_t* bspNodes Q_ASSIGN( NULL );
-Q_EXTERN int numBSPLeafSurfaces Q_ASSIGN( 0 );
-Q_EXTERN int allocatedBSPLeafSurfaces Q_ASSIGN( 0 );
+Q_EXTERN int numBSPLeafSurfaces Q_ASSIGN( 0 );
+Q_EXTERN int allocatedBSPLeafSurfaces Q_ASSIGN( 0 );
Q_EXTERN int* bspLeafSurfaces Q_ASSIGN( NULL );
-Q_EXTERN int numBSPLeafBrushes Q_ASSIGN( 0 );
-Q_EXTERN int allocatedBSPLeafBrushes Q_ASSIGN( 0 );
+Q_EXTERN int numBSPLeafBrushes Q_ASSIGN( 0 );
+Q_EXTERN int allocatedBSPLeafBrushes Q_ASSIGN( 0 );
Q_EXTERN int* bspLeafBrushes Q_ASSIGN( NULL );
-Q_EXTERN int numBSPBrushes Q_ASSIGN( 0 );
-Q_EXTERN int allocatedBSPBrushes Q_ASSIGN( 0 );
+Q_EXTERN int numBSPBrushes Q_ASSIGN( 0 );
+Q_EXTERN int allocatedBSPBrushes Q_ASSIGN( 0 );
Q_EXTERN bspBrush_t* bspBrushes Q_ASSIGN( NULL );
-Q_EXTERN int numBSPBrushSides Q_ASSIGN( 0 );
-Q_EXTERN int allocatedBSPBrushSides Q_ASSIGN( 0 );
+Q_EXTERN int numBSPBrushSides Q_ASSIGN( 0 );
+Q_EXTERN int allocatedBSPBrushSides Q_ASSIGN( 0 );
Q_EXTERN bspBrushSide_t* bspBrushSides Q_ASSIGN( NULL );
-Q_EXTERN int numBSPLightBytes Q_ASSIGN( 0 );
-Q_EXTERN byte *bspLightBytes Q_ASSIGN( NULL );
+Q_EXTERN int numBSPLightBytes Q_ASSIGN( 0 );
+Q_EXTERN byte *bspLightBytes Q_ASSIGN( NULL );
//% Q_EXTERN int numBSPGridPoints Q_ASSIGN( 0 );
//% Q_EXTERN byte *bspGridPoints Q_ASSIGN( NULL );
-Q_EXTERN int numBSPGridPoints Q_ASSIGN( 0 );
-Q_EXTERN bspGridPoint_t *bspGridPoints Q_ASSIGN( NULL );
+Q_EXTERN int numBSPGridPoints Q_ASSIGN( 0 );
+Q_EXTERN bspGridPoint_t *bspGridPoints Q_ASSIGN( NULL );
-Q_EXTERN int numBSPVisBytes Q_ASSIGN( 0 );
-Q_EXTERN byte bspVisBytes[ MAX_MAP_VISIBILITY ];
+Q_EXTERN int numBSPVisBytes Q_ASSIGN( 0 );
+Q_EXTERN byte bspVisBytes[ MAX_MAP_VISIBILITY ];
-Q_EXTERN int numBSPDrawVerts Q_ASSIGN( 0 );
-Q_EXTERN bspDrawVert_t *bspDrawVerts Q_ASSIGN( NULL );
+Q_EXTERN int numBSPDrawVerts Q_ASSIGN( 0 );
+Q_EXTERN bspDrawVert_t *bspDrawVerts Q_ASSIGN( NULL );
-Q_EXTERN int numBSPDrawIndexes Q_ASSIGN( 0 );
+Q_EXTERN int numBSPDrawIndexes Q_ASSIGN( 0 );
Q_EXTERN int allocatedBSPDrawIndexes Q_ASSIGN( 0 );
Q_EXTERN int *bspDrawIndexes Q_ASSIGN( NULL );
-Q_EXTERN int numBSPDrawSurfaces Q_ASSIGN( 0 );
-Q_EXTERN bspDrawSurface_t *bspDrawSurfaces Q_ASSIGN( NULL );
+Q_EXTERN int numBSPDrawSurfaces Q_ASSIGN( 0 );
+Q_EXTERN bspDrawSurface_t *bspDrawSurfaces Q_ASSIGN( NULL );
-Q_EXTERN int numBSPFogs Q_ASSIGN( 0 );
-Q_EXTERN bspFog_t bspFogs[ MAX_MAP_FOGS ];
+Q_EXTERN int numBSPFogs Q_ASSIGN( 0 );
+Q_EXTERN bspFog_t bspFogs[ MAX_MAP_FOGS ];
-Q_EXTERN int numBSPAds Q_ASSIGN( 0 );
-Q_EXTERN bspAdvertisement_t bspAds[ MAX_MAP_ADVERTISEMENTS ];
+Q_EXTERN int numBSPAds Q_ASSIGN( 0 );
+Q_EXTERN bspAdvertisement_t bspAds[ MAX_MAP_ADVERTISEMENTS ];
#define AUTOEXPAND_BY_REALLOC( ptr, reqitem, allocated, def ) \
do \
if ( allocated == 0 ) { \
allocated = def; } \
while ( reqitem >= allocated && allocated ) \
- allocated *= 2; \
+ allocated *= 2; \
if ( !allocated || allocated > 2147483647 / (int)sizeof( *ptr ) ) \
{ \
Error( # ptr " over 2 GB" ); \
*/
mapDrawSurface_t *AllocDrawSurface( surfaceType_t type ){
- mapDrawSurface_t *ds;
-
-
+ mapDrawSurface_t *ds;
+
+
/* ydnar: gs mods: only allocate valid types */
if ( type <= SURFACE_BAD || type >= NUM_SURFACE_TYPES ) {
Error( "AllocDrawSurface: Invalid surface type %d specified", type );
}
-
+
/* bounds check */
if ( numMapDrawSurfs >= MAX_MAP_DRAW_SURFS ) {
Error( "MAX_MAP_DRAW_SURFS (%d) exceeded", MAX_MAP_DRAW_SURFS );
}
ds = &mapDrawSurfs[ numMapDrawSurfs ];
numMapDrawSurfs++;
-
+
/* ydnar: do initial surface setup */
memset( ds, 0, sizeof( mapDrawSurface_t ) );
ds->type = type;
ds->planeNum = -1;
- ds->fogNum = defaultFogNum; /* ydnar 2003-02-12 */
- ds->outputNum = -1; /* ydnar 2002-08-13 */
- ds->surfaceNum = numMapDrawSurfs - 1; /* ydnar 2003-02-16 */
-
+ ds->fogNum = defaultFogNum; /* ydnar 2003-02-12 */
+ ds->outputNum = -1; /* ydnar 2002-08-13 */
+ ds->surfaceNum = numMapDrawSurfs - 1; /* ydnar 2003-02-16 */
+
return ds;
}
*/
void FinishSurface( mapDrawSurface_t *ds ){
- mapDrawSurface_t *ds2;
-
-
+ mapDrawSurface_t *ds2;
+
+
/* dummy check */
if ( ds->type <= SURFACE_BAD || ds->type >= NUM_SURFACE_TYPES || ds == NULL || ds->shaderInfo == NULL ) {
return;
}
-
+
/* ydnar: rocking tek-fu celshading */
if ( ds->celShader != NULL ) {
MakeCelSurface( ds, ds->celShader );
}
-
+
/* backsides stop here */
if ( ds->backSide ) {
return;
}
-
+
/* ydnar: rocking surface cloning (fur baby yeah!) */
if ( ds->shaderInfo->cloneShader != NULL && ds->shaderInfo->cloneShader[ 0 ] != '\0' ) {
CloneSurface( ds, ShaderInfoForShader( ds->shaderInfo->cloneShader ) );
}
-
+
/* ydnar: q3map_backShader support */
if ( ds->shaderInfo->backShader != NULL && ds->shaderInfo->backShader[ 0 ] != '\0' ) {
ds2 = CloneSurface( ds, ShaderInfoForShader( ds->shaderInfo->backShader ) );
*/
mapDrawSurface_t *CloneSurface( mapDrawSurface_t *src, shaderInfo_t *si ){
- mapDrawSurface_t *ds;
-
-
+ mapDrawSurface_t *ds;
+
+
/* dummy check */
if ( src == NULL || si == NULL ) {
return NULL;
}
-
+
/* allocate a new surface */
ds = AllocDrawSurface( src->type );
if ( ds == NULL ) {
return NULL;
}
-
+
/* copy it */
memcpy( ds, src, sizeof( *ds ) );
-
+
/* destroy side reference */
ds->sideRef = NULL;
-
+
/* set shader */
ds->shaderInfo = si;
-
+
/* copy verts */
if ( ds->numVerts > 0 ) {
ds->verts = safe_malloc( ds->numVerts * sizeof( *ds->verts ) );
memcpy( ds->verts, src->verts, ds->numVerts * sizeof( *ds->verts ) );
}
-
+
/* copy indexes */
if ( ds->numIndexes <= 0 ) {
return ds;
}
ds->indexes = safe_malloc( ds->numIndexes * sizeof( *ds->indexes ) );
memcpy( ds->indexes, src->indexes, ds->numIndexes * sizeof( *ds->indexes ) );
-
+
/* return the surface */
return ds;
}
*/
mapDrawSurface_t *MakeCelSurface( mapDrawSurface_t *src, shaderInfo_t *si ){
- mapDrawSurface_t *ds;
-
-
+ mapDrawSurface_t *ds;
+
+
/* dummy check */
if ( src == NULL || si == NULL ) {
return NULL;
}
-
+
/* don't create cel surfaces for certain types of shaders */
if ( ( src->shaderInfo->compileFlags & C_TRANSLUCENT ) ||
( src->shaderInfo->compileFlags & C_SKY ) ) {
return NULL;
}
-
+
/* make a copy */
ds = CloneSurface( src, si );
if ( ds == NULL ) {
return NULL;
}
-
+
/* do some fixups for celshading */
ds->planar = qfalse;
ds->planeNum = -1;
ds->celShader = NULL; /* don't cel shade cels :P */
-
+
/* return the surface */
return ds;
}
*/
mapDrawSurface_t *MakeSkyboxSurface( mapDrawSurface_t *src ){
- int i;
- mapDrawSurface_t *ds;
-
-
+ int i;
+ mapDrawSurface_t *ds;
+
+
/* dummy check */
if ( src == NULL ) {
return NULL;
}
-
+
/* make a copy */
ds = CloneSurface( src, src->shaderInfo );
if ( ds == NULL ) {
return NULL;
}
-
+
/* set parent */
ds->parent = src;
-
+
/* scale the surface vertexes */
for ( i = 0; i < ds->numVerts; i++ )
{
m4x4_transform_point( skyboxTransform, ds->verts[ i ].xyz );
-
+
/* debug code */
//% bspDrawVerts[ bspDrawSurfaces[ ds->outputNum ].firstVert + i ].color[ 0 ][ 1 ] = 0;
//% bspDrawVerts[ bspDrawSurfaces[ ds->outputNum ].firstVert + i ].color[ 0 ][ 2 ] = 0;
}
-
+
/* so backface culling creep doesn't bork the surface */
VectorClear( ds->lightmapVecs[ 2 ] );
-
+
/* return the surface */
return ds;
}
returns qtrue if all three points are colinear, backwards, or the triangle is just plain bogus
*/
-#define TINY_AREA 1.0f
+#define TINY_AREA 1.0f
qboolean IsTriangleDegenerate( bspDrawVert_t *points, int a, int b, int c ){
- vec3_t v1, v2, v3;
- float d;
-
-
+ vec3_t v1, v2, v3;
+ float d;
+
+
/* calcuate the area of the triangle */
VectorSubtract( points[ b ].xyz, points[ a ].xyz, v1 );
VectorSubtract( points[ c ].xyz, points[ a ].xyz, v2 );
CrossProduct( v1, v2, v3 );
d = VectorLength( v3 );
-
+
/* assume all very small or backwards triangles will cause problems */
if ( d < TINY_AREA ) {
return qtrue;
}
-
+
/* must be a good triangle */
return qfalse;
}
*/
void TidyEntitySurfaces( entity_t *e ){
- int i, j, deleted;
- mapDrawSurface_t *out, *in = NULL;
-
-
+ int i, j, deleted;
+ mapDrawSurface_t *out, *in = NULL;
+
+
/* note it */
Sys_FPrintf( SYS_VRB, "--- TidyEntitySurfaces ---\n" );
-
+
/* walk the surface list */
deleted = 0;
for ( i = e->firstDrawSurf, j = e->firstDrawSurf; j < numMapDrawSurfs; i++, j++ )
{
/* get out surface */
out = &mapDrawSurfs[ i ];
-
+
/* walk the surface list again until a proper surface is found */
for ( ; j < numMapDrawSurfs; j++ )
{
/* get in surface */
in = &mapDrawSurfs[ j ];
-
+
/* this surface ok? */
if ( in->type == SURFACE_FLARE || in->type == SURFACE_SHADER ||
( in->type != SURFACE_BAD && in->numVerts > 0 ) ) {
break;
}
-
+
/* nuke it */
ClearSurface( in );
deleted++;
}
-
+
/* copy if necessary */
if ( i != j ) {
memcpy( out, in, sizeof( mapDrawSurface_t ) );
+ }
}
- }
-
+
/* set the new number of drawsurfs */
numMapDrawSurfs = i;
-
+
/* emit some stats */
Sys_FPrintf( SYS_VRB, "%9d empty or malformed surfaces deleted\n", deleted );
}
*/
qboolean CalcSurfaceTextureRange( mapDrawSurface_t *ds ){
- int i, j, v, size[ 2 ];
- float mins[ 2 ], maxs[ 2 ];
-
-
+ int i, j, v, size[ 2 ];
+ float mins[ 2 ], maxs[ 2 ];
+
+
/* try to early out */
if ( ds->numVerts <= 0 ) {
return qtrue;
}
-
+
/* walk the verts and determine min/max st values */
mins[ 0 ] = 999999;
mins[ 1 ] = 999999;
}
if ( ds->verts[ i ].st[ j ] > maxs[ j ] ) {
maxs[ j ] = ds->verts[ i ].st[ j ];
+ }
}
}
- }
-
+
/* clamp to integer range and calculate surface bias values */
for ( j = 0; j < 2; j++ )
ds->bias[ j ] = -floor( 0.5f * ( mins[ j ] + maxs[ j ] ) );
-
+
/* find biased texture coordinate mins/maxs */
size[ 0 ] = ds->shaderInfo->shaderWidth;
size[ 1 ] = ds->shaderInfo->shaderHeight;
}
if ( v > ds->texMaxs[ j ] ) {
ds->texMaxs[ j ] = v;
+ }
}
}
- }
-
+
/* calc ranges */
for ( j = 0; j < 2; j++ )
ds->texRange[ j ] = ( ds->texMaxs[ j ] - ds->texMins[ j ] );
-
+
/* if range is zero, then assume unlimited precision */
if ( texRange == 0 ) {
return qtrue;
}
-
+
/* within range? */
for ( j = 0; j < 2; j++ )
{
if ( ds->texMins[ j ] < -texRange || ds->texMaxs[ j ] > texRange ) {
return qfalse;
+ }
}
- }
-
+
/* within range */
return qtrue;
}
*/
qboolean CalcLightmapAxis( vec3_t normal, vec3_t axis ){
- vec3_t absolute;
-
-
+ vec3_t absolute;
+
+
/* test */
if ( normal[ 0 ] == 0.0f && normal[ 1 ] == 0.0f && normal[ 2 ] == 0.0f ) {
VectorClear( axis );
return qfalse;
}
-
+
/* get absolute normal */
absolute[ 0 ] = fabs( normal[ 0 ] );
absolute[ 1 ] = fabs( normal[ 1 ] );
absolute[ 2 ] = fabs( normal[ 2 ] );
-
+
/* test and set */
if ( absolute[ 2 ] > absolute[ 0 ] - 0.0001f && absolute[ 2 ] > absolute[ 1 ] - 0.0001f ) {
if ( normal[ 2 ] > 0.0f ) {
}
else{
VectorSet( axis, 0.0f, 0.0f, -1.0f );
- }
+ }
}
else if ( absolute[ 0 ] > absolute[ 1 ] - 0.0001f && absolute[ 0 ] > absolute[ 2 ] - 0.0001f ) {
if ( normal[ 0 ] > 0.0f ) {
}
else{
VectorSet( axis, -1.0f, 0.0f, 0.0f );
- }
+ }
}
else
{
}
else{
VectorSet( axis, 0.0f, -1.0f, 0.0f );
+ }
}
- }
-
+
/* return ok */
return qtrue;
}
fills out a bunch of info in the surfaces, including planar status, lightmap projection, and bounding box
*/
-#define PLANAR_EPSILON 0.5f //% 0.126f 0.25f
+#define PLANAR_EPSILON 0.5f //% 0.126f 0.25f
void ClassifySurfaces( int numSurfs, mapDrawSurface_t *ds ){
- int i, bestAxis;
- float dist;
- vec4_t plane;
- shaderInfo_t *si;
- static vec3_t axii[ 6 ] =
- {
- { 0, 0, -1 },
- { 0, 0, 1 },
- { -1, 0, 0 },
- { 1, 0, 0 },
- { 0, -1, 0 },
- { 0, 1, 0 }
- };
-
-
+ int i, bestAxis;
+ float dist;
+ vec4_t plane;
+ shaderInfo_t *si;
+ static vec3_t axii[ 6 ] =
+ {
+ { 0, 0, -1 },
+ { 0, 0, 1 },
+ { -1, 0, 0 },
+ { 1, 0, 0 },
+ { 0, -1, 0 },
+ { 0, 1, 0 }
+ };
+
+
/* walk the list of surfaces */
for ( ; numSurfs > 0; numSurfs--, ds++ )
{
if ( ds->type == SURFACE_BAD || ds->numVerts <= 0 ) {
continue;
}
-
+
/* get shader */
si = ds->shaderInfo;
-
+
/* -----------------------------------------------------------------
force meta if vertex count is too high or shader requires it
----------------------------------------------------------------- */
-
+
if ( ds->type != SURFACE_PATCH && ds->type != SURFACE_FACE ) {
if ( ds->numVerts > SHADER_MAX_VERTEXES ) {
ds->type = SURFACE_FORCED_META;
+ }
}
- }
-
+
/* -----------------------------------------------------------------
- plane and bounding box classification
+ plane and bounding box classification
----------------------------------------------------------------- */
-
+
/* set surface bounding box */
ClearBounds( ds->mins, ds->maxs );
for ( i = 0; i < ds->numVerts; i++ )
AddPointToBounds( ds->verts[ i ].xyz, ds->mins, ds->maxs );
-
+
/* try to get an existing plane */
if ( ds->planeNum >= 0 ) {
VectorCopy( mapplanes[ ds->planeNum ].normal, plane );
plane[ 3 ] = mapplanes[ ds->planeNum ].dist;
}
-
+
/* construct one from the first vert with a valid normal */
else
{
VectorClear( plane );
plane[ 3 ] = 0.0f;
for ( i = 0; i < ds->numVerts; i++ )
- {
+ {
if ( ds->verts[ i ].normal[ 0 ] != 0.0f && ds->verts[ i ].normal[ 1 ] != 0.0f && ds->verts[ i ].normal[ 2 ] != 0.0f ) {
VectorCopy( ds->verts[ i ].normal, plane );
plane[ 3 ] = DotProduct( ds->verts[ i ].xyz, plane );
}
}
}
-
+
/* test for bogus plane */
if ( VectorLength( plane ) <= 0.0f ) {
ds->planar = qfalse;
{
/* determine if surface is planar */
ds->planar = qtrue;
-
+
/* test each vert */
for ( i = 0; i < ds->numVerts; i++ )
{
}
}
}
-
+
/* find map plane if necessary */
if ( ds->planar ) {
if ( ds->planeNum < 0 ) {
//% if( ds->type == SURF_META || ds->type == SURF_FACE )
//% Sys_Printf( "WARNING: Non-planar face (%d): %s\n", ds->planeNum, ds->shaderInfo->shader );
}
-
+
/* -----------------------------------------------------------------
lightmap bounds and axis projection
----------------------------------------------------------------- */
-
+
/* vertex lit surfaces don't need this information */
if ( si->compileFlags & C_VERTEXLIT || ds->type == SURFACE_TRIANGLES ) {
VectorClear( ds->lightmapAxis );
ds->sampleSize = 0;
continue;
}
-
+
/* the shader can specify an explicit lightmap axis */
if ( si->lightmapAxis[ 0 ] || si->lightmapAxis[ 1 ] || si->lightmapAxis[ 2 ] ) {
VectorCopy( si->lightmapAxis, ds->lightmapAxis );
for ( i = 0; i < ds->numVerts && bestAxis < 6; i++ )
{
//% Sys_Printf( "Comparing %1.3f %1.3f %1.3f to %1.3f %1.3f %1.3f\n",
- //% ds->verts[ i ].normal[ 0 ], ds->verts[ i ].normal[ 1 ], ds->verts[ i ].normal[ 2 ],
- //% axii[ bestAxis ][ 0 ], axii[ bestAxis ][ 1 ], axii[ bestAxis ][ 2 ] );
+ //% ds->verts[ i ].normal[ 0 ], ds->verts[ i ].normal[ 1 ], ds->verts[ i ].normal[ 2 ],
+ //% axii[ bestAxis ][ 0 ], axii[ bestAxis ][ 1 ], axii[ bestAxis ][ 2 ] );
if ( DotProduct( ds->verts[ i ].normal, axii[ bestAxis ] ) < 0.25f ) { /* fixme: adjust this tolerance to taste */
break;
+ }
}
- }
-
+
if ( i == ds->numVerts ) {
break;
+ }
}
- }
-
+
/* set axis if possible */
if ( bestAxis < 6 ) {
//% if( ds->type == SURFACE_PATCH )
- //% Sys_Printf( "Mapped axis %d onto patch\n", bestAxis );
+ //% Sys_Printf( "Mapped axis %d onto patch\n", bestAxis );
VectorCopy( axii[ bestAxis ], ds->lightmapAxis );
}
-
+
/* debug code */
//% if( ds->type == SURFACE_PATCH )
- //% Sys_Printf( "Failed to map axis %d onto patch\n", bestAxis );
+ //% Sys_Printf( "Failed to map axis %d onto patch\n", bestAxis );
}
-
+
/* calculate lightmap sample size */
if ( ds->shaderInfo->lightmapSampleSize > 0 ) { /* shader value overrides every other */
ds->sampleSize = ds->shaderInfo->lightmapSampleSize;
if ( ds->sampleSize > 16384 ) { /* powers of 2 are preferred */
ds->sampleSize = 16384;
- }
+ }
}
}
*/
void ClassifyEntitySurfaces( entity_t *e ){
- int i;
-
-
+ int i;
+
+
/* note it */
Sys_FPrintf( SYS_VRB, "--- ClassifyEntitySurfaces ---\n" );
-
+
/* walk the surface list */
for ( i = e->firstDrawSurf; i < numMapDrawSurfs; i++ )
{
FinishSurface( &mapDrawSurfs[ i ] );
ClassifySurfaces( 1, &mapDrawSurfs[ i ] );
}
-
+
/* tidy things up */
TidyEntitySurfaces( e );
}
*/
byte GetShaderIndexForPoint( indexMap_t *im, vec3_t eMins, vec3_t eMaxs, vec3_t point ){
- int i, x, y;
- float s, t;
- vec3_t mins, maxs, size;
-
-
+ int i, x, y;
+ float s, t;
+ vec3_t mins, maxs, size;
+
+
/* early out if no indexmap */
if ( im == NULL ) {
return 0;
}
-
+
/* this code is really broken */
#if 0
- /* legacy precision fudges for terrain */
+ /* legacy precision fudges for terrain */
for ( i = 0; i < 3; i++ )
- {
- mins[ i ] = floor( eMins[ i ] + 0.1 );
- maxs[ i ] = floor( eMaxs[ i ] + 0.1 );
- size[ i ] = maxs[ i ] - mins[ i ];
- }
-
- /* find st (fixme: support more than just z-axis projection) */
- s = floor( point[ 0 ] + 0.1f - mins[ 0 ] ) / size[ 0 ];
- t = floor( maxs[ 1 ] - point[ 1 ] + 0.1f ) / size[ 1 ];
+ {
+ mins[ i ] = floor( eMins[ i ] + 0.1 );
+ maxs[ i ] = floor( eMaxs[ i ] + 0.1 );
+ size[ i ] = maxs[ i ] - mins[ i ];
+ }
+
+ /* find st (fixme: support more than just z-axis projection) */
+ s = floor( point[ 0 ] + 0.1f - mins[ 0 ] ) / size[ 0 ];
+ t = floor( maxs[ 1 ] - point[ 1 ] + 0.1f ) / size[ 1 ];
if ( s < 0.0f ) {
- s = 0.0f;
+ s = 0.0f;
}
else if ( s > 1.0f ) {
- s = 1.0f;
+ s = 1.0f;
}
if ( t < 0.0f ) {
- t = 0.0f;
+ t = 0.0f;
}
else if ( t > 1.0f ) {
- t = 1.0f;
+ t = 1.0f;
}
-
- /* make xy */
+
+ /* make xy */
x = ( im->w - 1 ) * s;
y = ( im->h - 1 ) * t;
#else
- /* get size */
+ /* get size */
for ( i = 0; i < 3; i++ )
- {
- mins[ i ] = eMins[ i ];
- maxs[ i ] = eMaxs[ i ];
- size[ i ] = maxs[ i ] - mins[ i ];
- }
-
- /* calc st */
+ {
+ mins[ i ] = eMins[ i ];
+ maxs[ i ] = eMaxs[ i ];
+ size[ i ] = maxs[ i ] - mins[ i ];
+ }
+
+ /* calc st */
s = ( point[ 0 ] - mins[ 0 ] ) / size[ 0 ];
t = ( maxs[ 1 ] - point[ 1 ] ) / size[ 1 ];
-
- /* calc xy */
- x = s * im->w;
- y = t * im->h;
+
+ /* calc xy */
+ x = s * im->w;
+ y = t * im->h;
if ( x < 0 ) {
- x = 0;
+ x = 0;
}
else if ( x > ( im->w - 1 ) ) {
x = ( im->w - 1 );
}
if ( y < 0 ) {
- y = 0;
+ y = 0;
}
else if ( y > ( im->h - 1 ) ) {
y = ( im->h - 1 );
}
#endif
-
+
/* return index */
return im->pixels[ y * im->w + x ];
}
*/
shaderInfo_t *GetIndexedShader( shaderInfo_t *parent, indexMap_t *im, int numPoints, byte *shaderIndexes ){
- int i;
- byte minShaderIndex, maxShaderIndex;
- char shader[ MAX_QPATH ];
- shaderInfo_t *si;
-
-
+ int i;
+ byte minShaderIndex, maxShaderIndex;
+ char shader[ MAX_QPATH ];
+ shaderInfo_t *si;
+
+
/* early out if bad data */
if ( im == NULL || numPoints <= 0 || shaderIndexes == NULL ) {
return ShaderInfoForShader( "default" );
}
-
+
/* determine min/max index */
minShaderIndex = 255;
maxShaderIndex = 0;
}
if ( shaderIndexes[ i ] > maxShaderIndex ) {
maxShaderIndex = shaderIndexes[ i ];
+ }
}
- }
-
+
/* set alpha inline */
for ( i = 0; i < numPoints; i++ )
{
}
else{
shaderIndexes[ i ] = 255;
+ }
}
- }
-
+
/* make a shader name */
if ( minShaderIndex == maxShaderIndex ) {
sprintf( shader, "textures/%s_%d", im->shader, maxShaderIndex );
else{
sprintf( shader, "textures/%s_%dto%d", im->shader, minShaderIndex, maxShaderIndex );
}
-
+
/* get the shader */
si = ShaderInfoForShader( shader );
-
+
/* inherit a few things from parent shader */
if ( parent->globalTexture ) {
si->globalTexture = qtrue;
/* set lightmap projection axis */
VectorCopy( parent->lightmapAxis, si->lightmapAxis );
}
-
+
/* return the shader */
return si;
}
creates a SURF_FACE drawsurface from a given brush side and winding
*/
-#define SNAP_FLOAT_TO_INT 8
+#define SNAP_FLOAT_TO_INT 8
#define SNAP_INT_TO_FLOAT ( 1.0 / SNAP_FLOAT_TO_INT )
mapDrawSurface_t *DrawSurfaceForSide( entity_t *e, brush_t *b, side_t *s, winding_t *w ){
- int i, j, k;
- mapDrawSurface_t *ds;
- shaderInfo_t *si, *parent;
- bspDrawVert_t *dv;
- vec3_t texX, texY;
- vec_t x, y;
- vec3_t vTranslated;
- qboolean indexed;
- byte shaderIndexes[ 256 ];
- float offsets[ 256 ];
- char tempShader[ MAX_QPATH ];
-
-
+ int i, j, k;
+ mapDrawSurface_t *ds;
+ shaderInfo_t *si, *parent;
+ bspDrawVert_t *dv;
+ vec3_t texX, texY;
+ vec_t x, y;
+ vec3_t vTranslated;
+ qboolean indexed;
+ byte shaderIndexes[ 256 ];
+ float offsets[ 256 ];
+ char tempShader[ MAX_QPATH ];
+
+
/* ydnar: don't make a drawsurf for culled sides */
if ( s->culled ) {
return NULL;
}
-
+
/* range check */
if ( w->numpoints > MAX_POINTS_ON_WINDING ) {
Error( "DrawSurfaceForSide: w->numpoints = %d (> %d)", w->numpoints, MAX_POINTS_ON_WINDING );
}
-
+
/* get shader */
si = s->shaderInfo;
-
+
/* ydnar: gs mods: check for indexed shader */
if ( si->indexed && b->im != NULL ) {
/* indexed */
indexed = qtrue;
-
+
/* get shader indexes for each point */
for ( i = 0; i < w->numpoints; i++ )
{
offsets[ i ] = b->im->offsets[ shaderIndexes[ i ] ];
//% Sys_Printf( "%f ", offsets[ i ] );
}
-
+
/* get matching shader and set alpha */
parent = si;
si = GetIndexedShader( parent, b->im, w->numpoints, shaderIndexes );
else{
indexed = qfalse;
}
-
+
/* ydnar: sky hack/fix for GL_CLAMP borders on ati cards */
if ( skyFixHack && si->skyParmsImageBase[ 0 ] != '\0' ) {
//% Sys_FPrintf( SYS_VRB, "Enabling sky hack for shader %s using env %s\n", si->shader, si->skyParmsImageBase );
sprintf( tempShader, "%s_dn", si->skyParmsImageBase );
DrawSurfaceForShader( tempShader );
}
-
+
/* ydnar: gs mods */
ds = AllocDrawSurface( SURFACE_FACE );
ds->entityNum = b->entityNum;
ds->castShadows = b->castShadows;
ds->recvShadows = b->recvShadows;
-
+
ds->planar = qtrue;
ds->planeNum = s->planenum;
VectorCopy( mapplanes[ s->planenum ].normal, ds->lightmapVecs[ 2 ] );
-
+
ds->shaderInfo = si;
ds->mapBrush = b;
ds->sideRef = AllocSideRef( s, NULL );
ds->numVerts = w->numpoints;
ds->verts = safe_malloc( ds->numVerts * sizeof( *ds->verts ) );
memset( ds->verts, 0, ds->numVerts * sizeof( *ds->verts ) );
-
+
/* compute s/t coordinates from brush primitive texture matrix (compute axis base) */
ComputeAxisBase( mapplanes[ s->planenum ].normal, texX, texY );
-
+
/* create the vertexes */
for ( j = 0; j < w->numpoints; j++ )
{
/* get the drawvert */
dv = ds->verts + j;
-
+
/* copy xyz and do potential z offset */
VectorCopy( w->p[ j ], dv->xyz );
if ( indexed ) {
dv->xyz[ 2 ] += offsets[ j ];
}
-
+
/* round the xyz to a given precision and translate by origin */
for ( i = 0 ; i < 3 ; i++ )
dv->xyz[ i ] = SNAP_INT_TO_FLOAT * floor( dv->xyz[ i ] * SNAP_FLOAT_TO_INT + 0.5f );
VectorAdd( dv->xyz, e->origin, vTranslated );
-
+
/* ydnar: tek-fu celshading support for flat shaded shit */
if ( flat ) {
dv->st[ 0 ] = si->stFlat[ 0 ];
dv->st[ 1 ] = si->stFlat[ 1 ];
}
-
+
/* ydnar: gs mods: added support for explicit shader texcoord generation */
else if ( si->tcGen ) {
dv->st[ 0 ] = DotProduct( si->vecs[ 0 ], vTranslated );
dv->st[ 1 ] = DotProduct( si->vecs[ 1 ], vTranslated );
}
-
+
/* old quake-style texturing */
else if ( g_bBrushPrimit == BPRIMIT_OLDBRUSHES ) {
/* nearest-axial projection */
dv->st[ 0 ] /= si->shaderWidth;
dv->st[ 1 ] /= si->shaderHeight;
}
-
+
/* brush primitive texturing */
else
{
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 ];
}
-
+
/* copy normal */
VectorCopy( mapplanes[ s->planenum ].normal, dv->normal );
-
+
/* ydnar: set color */
for ( k = 0; k < MAX_LIGHTMAPS; k++ )
{
dv->color[ k ][ 0 ] = 255;
dv->color[ k ][ 1 ] = 255;
dv->color[ k ][ 2 ] = 255;
-
+
/* ydnar: gs mods: handle indexed shader blending */
dv->color[ k ][ 3 ] = ( indexed ? shaderIndexes[ j ] : 255 );
}
}
-
+
/* set cel shader */
ds->celShader = b->celShader;
if ( b->shadeAngleDegrees > 0.0f ) {
ds->shadeAngleDegrees = b->shadeAngleDegrees;
}
-
+
/* ydnar: gs mods: moved st biasing elsewhere */
return ds;
}
#define YDNAR_NORMAL_EPSILON 0.50f
qboolean VectorCompareExt( vec3_t n1, vec3_t n2, float epsilon ){
- int i;
-
-
+ int i;
+
+
/* test */
for ( i = 0; i < 3; i++ )
if ( fabs( n1[ i ] - n2[ i ] ) > epsilon ) {
}
mapDrawSurface_t *DrawSurfaceForMesh( entity_t *e, parseMesh_t *p, mesh_t *mesh ){
- int i, k, numVerts;
- vec4_t plane;
- qboolean planar;
- float dist;
- mapDrawSurface_t *ds;
- shaderInfo_t *si, *parent;
- bspDrawVert_t *dv;
- vec3_t vTranslated;
- mesh_t *copy;
- qboolean indexed;
- byte shaderIndexes[ MAX_EXPANDED_AXIS * MAX_EXPANDED_AXIS ];
- float offsets[ MAX_EXPANDED_AXIS * MAX_EXPANDED_AXIS ];
-
-
+ int i, k, numVerts;
+ vec4_t plane;
+ qboolean planar;
+ float dist;
+ mapDrawSurface_t *ds;
+ shaderInfo_t *si, *parent;
+ bspDrawVert_t *dv;
+ vec3_t vTranslated;
+ mesh_t *copy;
+ qboolean indexed;
+ byte shaderIndexes[ MAX_EXPANDED_AXIS * MAX_EXPANDED_AXIS ];
+ float offsets[ MAX_EXPANDED_AXIS * MAX_EXPANDED_AXIS ];
+
+
/* get mesh and shader shader */
if ( mesh == NULL ) {
mesh = &p->mesh;
if ( mesh == NULL || si == NULL ) {
return NULL;
}
-
+
/* get vertex count */
numVerts = mesh->width * mesh->height;
-
+
/* to make valid normals for patches with degenerate edges,
we need to make a copy of the mesh and put the aproximating
points onto the curve */
-
+
/* create a copy of the mesh */
copy = CopyMesh( mesh );
-
+
/* store off the original (potentially bad) normals */
MakeMeshNormals( *copy );
for ( i = 0; i < numVerts; i++ )
VectorCopy( copy->verts[ i ].normal, mesh->verts[ i ].normal );
-
+
/* put the mesh on the curve */
PutMeshOnCurve( *copy );
/* ydnar: only copy normals that are significantly different from the originals */
if ( DotProduct( copy->verts[ i ].normal, mesh->verts[ i ].normal ) < 0.75f ) {
VectorCopy( copy->verts[ i ].normal, mesh->verts[ i ].normal );
+ }
}
- }
-
+
/* free the old mesh */
FreeMesh( copy );
-
+
/* ydnar: gs mods: check for indexed shader */
if ( si->indexed && p->im != NULL ) {
/* indexed */
shaderIndexes[ i ] = GetShaderIndexForPoint( p->im, p->eMins, p->eMaxs, mesh->verts[ i ].xyz );
offsets[ i ] = p->im->offsets[ shaderIndexes[ i ] ];
}
-
+
/* get matching shader and set alpha */
parent = si;
si = GetIndexedShader( parent, p->im, numVerts, shaderIndexes );
else{
indexed = qfalse;
}
-
-
+
+
/* ydnar: gs mods */
ds = AllocDrawSurface( SURFACE_PATCH );
ds->entityNum = p->entityNum;
ds->castShadows = p->castShadows;
ds->recvShadows = p->recvShadows;
-
+
ds->shaderInfo = si;
ds->mapMesh = p;
ds->sampleSize = p->lightmapSampleSize;
- ds->lightmapScale = p->lightmapScale; /* ydnar */
+ ds->lightmapScale = p->lightmapScale; /* ydnar */
ds->colormod = p->colormod;
ds->patchWidth = mesh->width;
ds->patchHeight = mesh->height;
ds->numVerts = ds->patchWidth * ds->patchHeight;
ds->verts = safe_malloc( ds->numVerts * sizeof( *ds->verts ) );
memcpy( ds->verts, mesh->verts, ds->numVerts * sizeof( *ds->verts ) );
-
+
ds->fogNum = -1;
ds->planeNum = -1;
-
+
ds->longestCurve = p->longestCurve;
ds->maxIterations = p->maxIterations;
-
+
/* construct a plane from the first vert */
VectorCopy( mesh->verts[ 0 ].normal, plane );
plane[ 3 ] = DotProduct( mesh->verts[ 0 ].xyz, plane );
planar = qtrue;
-
+
/* spew forth errors */
if ( VectorLength( plane ) < 0.001f ) {
Sys_Printf( "BOGUS " );
}
-
+
/* test each vert */
for ( i = 1; i < ds->numVerts && planar; i++ )
{
if ( VectorCompare( plane, mesh->verts[ i ].normal ) == qfalse ) {
planar = qfalse;
}
-
+
/* point-plane test */
dist = DotProduct( mesh->verts[ i ].xyz, plane ) - plane[ 3 ];
if ( fabs( dist ) > EQUAL_EPSILON ) {
planar = qfalse;
+ }
}
- }
-
+
/* add a map plane */
if ( planar ) {
/* make a map plane */
ds->planeNum = FindFloatPlane( plane, plane[ 3 ], 1, &mesh->verts[ 0 ].xyz );
VectorCopy( plane, ds->lightmapVecs[ 2 ] );
-
+
/* push this normal to all verts (ydnar 2003-02-14: bad idea, small patches get screwed up) */
for ( i = 0; i < ds->numVerts; i++ )
VectorCopy( plane, ds->verts[ i ].normal );
}
-
+
/* walk the verts to do special stuff */
for ( i = 0; i < ds->numVerts; i++ )
{
/* get the drawvert */
dv = &ds->verts[ i ];
-
+
/* ydnar: tek-fu celshading support for flat shaded shit */
if ( flat ) {
dv->st[ 0 ] = si->stFlat[ 0 ];
dv->st[ 1 ] = si->stFlat[ 1 ];
}
-
+
/* ydnar: gs mods: added support for explicit shader texcoord generation */
else if ( si->tcGen ) {
/* translate by origin and project the texture */
dv->st[ 0 ] = DotProduct( si->vecs[ 0 ], vTranslated );
dv->st[ 1 ] = DotProduct( si->vecs[ 1 ], vTranslated );
}
-
+
/* ydnar: set color */
for ( k = 0; k < MAX_LIGHTMAPS; k++ )
{
dv->color[ k ][ 0 ] = 255;
dv->color[ k ][ 1 ] = 255;
dv->color[ k ][ 2 ] = 255;
-
+
/* ydnar: gs mods: handle indexed shader blending */
dv->color[ k ][ 3 ] = ( indexed ? shaderIndexes[ i ] : 255 );
}
-
+
/* ydnar: offset */
if ( indexed ) {
dv->xyz[ 2 ] += offsets[ i ];
+ }
}
- }
-
+
/* set cel shader */
ds->celShader = p->celShader;
-
+
/* return the drawsurface */
return ds;
}
*/
mapDrawSurface_t *DrawSurfaceForFlare( int entNum, vec3_t origin, vec3_t normal, vec3_t color, const char *flareShader, int lightStyle ){
- mapDrawSurface_t *ds;
-
-
+ mapDrawSurface_t *ds;
+
+
/* emit flares? */
if ( emitFlares == qfalse ) {
return NULL;
}
-
+
/* allocate drawsurface */
ds = AllocDrawSurface( SURFACE_FLARE );
ds->entityNum = entNum;
-
+
/* set it up */
if ( flareShader != NULL && flareShader[ 0 ] != '\0' ) {
ds->shaderInfo = ShaderInfoForShader( flareShader );
if ( color != NULL ) {
VectorCopy( color, ds->lightmapVecs[ 0 ] );
}
-
+
/* store light style */
ds->lightStyle = lightStyle;
if ( ds->lightStyle < 0 || ds->lightStyle >= LS_NONE ) {
ds->lightStyle = LS_NORMAL;
}
-
+
/* fixme: fog */
-
+
/* return to sender */
return ds;
}
*/
mapDrawSurface_t *DrawSurfaceForShader( char *shader ){
- int i;
- shaderInfo_t *si;
- mapDrawSurface_t *ds;
-
-
+ int i;
+ shaderInfo_t *si;
+ mapDrawSurface_t *ds;
+
+
/* get shader */
si = ShaderInfoForShader( shader );
{
/* get surface */
ds = &mapDrawSurfs[ i ];
-
+
/* check it */
if ( ds->shaderInfo == si ) {
return ds;
+ }
}
- }
-
+
/* create a new surface */
ds = AllocDrawSurface( SURFACE_SHADER );
ds->entityNum = 0;
ds->shaderInfo = ShaderInfoForShader( shader );
-
+
/* return to sender */
return ds;
}
*/
static void AddSurfaceFlare( mapDrawSurface_t *ds, vec3_t entityOrigin ){
- vec3_t origin;
- int i;
-
-
+ vec3_t origin;
+ int i;
+
+
/* find centroid */
VectorClear( origin );
for ( i = 0; i < ds->numVerts; i++ )
if ( entityOrigin != NULL ) {
VectorAdd( origin, entityOrigin, origin );
}
-
+
/* push origin off surface a bit */
VectorMA( origin, 2.0f, ds->lightmapVecs[ 2 ], origin );
-
+
/* create the drawsurface */
DrawSurfaceForFlare( ds->entityNum, origin, ds->lightmapVecs[ 2 ], ds->shaderInfo->color, ds->shaderInfo->flareShader, ds->shaderInfo->lightStyle );
}
*/
static void SubdivideFace_r( entity_t *e, brush_t *brush, side_t *side, winding_t *w, int fogNum, float subdivisions ){
- int i;
- int axis;
- vec3_t bounds[ 2 ];
- const float epsilon = 0.1;
- int subFloor, subCeil;
- winding_t *frontWinding, *backWinding;
- mapDrawSurface_t *ds;
-
-
+ int i;
+ int axis;
+ vec3_t bounds[ 2 ];
+ const float epsilon = 0.1;
+ int subFloor, subCeil;
+ winding_t *frontWinding, *backWinding;
+ mapDrawSurface_t *ds;
+
+
/* dummy check */
if ( w == NULL ) {
return;
if ( w->numpoints < 3 ) {
Error( "SubdivideFace_r: Bad w->numpoints (%d < 3)", w->numpoints );
}
-
+
/* determine surface bounds */
ClearBounds( bounds[ 0 ], bounds[ 1 ] );
for ( i = 0; i < w->numpoints; i++ )
AddPointToBounds( w->p[ i ], bounds[ 0 ], bounds[ 1 ] );
-
+
/* split the face */
for ( axis = 0; axis < 3; axis++ )
{
- vec3_t planePoint = { 0, 0, 0 };
- vec3_t planeNormal = { 0, 0, 0 };
- float d;
-
-
+ vec3_t planePoint = { 0, 0, 0 };
+ vec3_t planeNormal = { 0, 0, 0 };
+ float d;
+
+
/* create an axial clipping plane */
subFloor = floor( bounds[ 0 ][ axis ] / subdivisions ) * subdivisions;
subCeil = ceil( bounds[ 1 ][ axis ] / subdivisions ) * subdivisions;
}
}
}
-
+
/* create a face surface */
ds = DrawSurfaceForSide( e, brush, side, w );
-
+
/* set correct fog num */
ds->fogNum = fogNum;
}
*/
void SubdivideFaceSurfaces( entity_t *e, tree_t *tree ){
- int i, j, numBaseDrawSurfs, fogNum;
- mapDrawSurface_t *ds;
- brush_t *brush;
- side_t *side;
- shaderInfo_t *si;
- winding_t *w;
- float range, size, subdivisions, s2;
-
-
+ int i, j, numBaseDrawSurfs, fogNum;
+ mapDrawSurface_t *ds;
+ brush_t *brush;
+ side_t *side;
+ shaderInfo_t *si;
+ winding_t *w;
+ float range, size, subdivisions, s2;
+
+
/* note it */
Sys_FPrintf( SYS_VRB, "--- SubdivideFaceSurfaces ---\n" );
-
+
/* walk the list of surfaces */
numBaseDrawSurfs = numMapDrawSurfs;
for ( i = e->firstDrawSurf; i < numBaseDrawSurfs; i++ )
if ( ds->type != SURFACE_FACE || ds->mapBrush == NULL || ds->sideRef == NULL || ds->sideRef->side == NULL ) {
continue;
}
-
+
/* get bits */
brush = ds->mapBrush;
side = ds->sideRef->side;
-
+
/* check subdivision for shader */
si = side->shaderInfo;
if ( si == NULL ) {
continue;
}
-
+
/* ydnar: don't subdivide sky surfaces */
if ( si->compileFlags & C_SKY ) {
continue;
}
-
+
/* do texture coordinate range check */
ClassifySurfaces( 1, ds );
if ( CalcSurfaceTextureRange( ds ) == qfalse ) {
else{
subdivisions = si->subdivisions;
}
-
+
/* get subdivisions from shader */
if ( si->subdivisions > 0 && si->subdivisions < subdivisions ) {
subdivisions = si->subdivisions;
if ( subdivisions < 1.0f ) {
continue;
}
-
+
/* preserve fog num */
fogNum = ds->fogNum;
-
+
/* make a winding and free the surface */
w = WindingFromDrawSurf( ds );
ClearSurface( ds );
-
+
/* subdivide it */
SubdivideFace_r( e, brush, side, w, fogNum, subdivisions );
}
*/
void ClipSideIntoTree_r( winding_t *w, side_t *side, node_t *node ){
- plane_t *plane;
- winding_t *front, *back;
+ plane_t *plane;
+ winding_t *front, *back;
if ( !w ) {
return;
#define CULL_EPSILON 0.1f
qboolean CullVectorCompare( const vec3_t v1, const vec3_t v2 ){
- int i;
-
-
+ int i;
+
+
for ( i = 0; i < 3; i++ )
if ( fabs( v1[ i ] - v2[ i ] ) > CULL_EPSILON ) {
return qfalse;
*/
qboolean SideInBrush( side_t *side, brush_t *b ){
- int i, s;
- plane_t *plane;
-
-
+ int i, s;
+ plane_t *plane;
+
+
/* ignore sides w/o windings or shaders */
if ( side->winding == NULL || side->shaderInfo == NULL ) {
return qtrue;
s = WindingOnPlaneSide( side->winding, plane->normal, plane->dist );
if ( s == SIDE_FRONT || s == SIDE_CROSS ) {
return qfalse;
+ }
}
- }
-
+
/* don't cull autosprite or polygonoffset surfaces */
if ( side->shaderInfo ) {
if ( side->shaderInfo->autosprite || side->shaderInfo->polygonOffset ) {
return qfalse;
+ }
}
- }
-
+
/* inside */
side->culled = qtrue;
g_numHiddenFaces++;
*/
void CullSides( entity_t *e ){
- int numPoints;
- int i, j, k, l, first, second, dir;
- winding_t *w1, *w2;
- brush_t *b1, *b2;
- side_t *side1, *side2;
-
-
+ int numPoints;
+ int i, j, k, l, first, second, dir;
+ winding_t *w1, *w2;
+ brush_t *b1, *b2;
+ side_t *side1, *side2;
+
+
/* note it */
Sys_FPrintf( SYS_VRB, "--- CullSides ---\n" );
-
+
g_numHiddenFaces = 0;
g_numCoinFaces = 0;
-
+
/* brush interator 1 */
for ( b1 = e->brushes; b1; b1 = b1->next )
{
if ( b2->numsides < 1 ) {
continue;
}
-
+
/* original check */
if ( b1->original == b2->original && b1->original != NULL ) {
continue;
}
-
+
/* bbox check */
j = 0;
for ( i = 0; i < 3; i++ )
SideInBrush( &b1->sides[ i ], b2 );
for ( i = 0; i < b2->numsides; i++ )
SideInBrush( &b2->sides[ i ], b1 );
-
+
/* side iterator 1 */
for ( i = 0; i < b1->numsides; i++ )
{
if ( side1->shaderInfo == NULL ) {
continue;
}
-
+
/* side iterator 2 */
for ( j = 0; j < b2->numsides; j++ )
{
if ( side1->culled == qtrue && side2->culled == qtrue ) {
continue;
}
-
+
/* compare planes */
if ( ( side1->planenum & ~0x00000001 ) != ( side2->planenum & ~0x00000001 ) ) {
continue;
}
-
+
/* get autosprite and polygonoffset status */
if ( side1->shaderInfo &&
( side1->shaderInfo->autosprite || side1->shaderInfo->polygonOffset ) ) {
( side2->shaderInfo->autosprite || side2->shaderInfo->polygonOffset ) ) {
continue;
}
-
+
/* find first common point */
first = -1;
for ( k = 0; k < numPoints; k++ )
- {
+ {
if ( VectorCompare( w1->p[ 0 ], w2->p[ k ] ) ) {
first = k;
k = numPoints;
if ( first == -1 ) {
continue;
}
-
+
/* find second common point (regardless of winding order) */
second = -1;
dir = 0;
}
if ( CullVectorCompare( w1->p[ 1 ], w2->p[ second ] ) ) {
dir = -1;
- }
+ }
}
if ( dir == 0 ) {
continue;
}
-
+
/* compare the rest of the points */
l = first;
for ( k = 0; k < numPoints; k++ )
if ( !CullVectorCompare( w1->p[ k ], w2->p[ l ] ) ) {
k = 100000;
}
-
+
l += dir;
if ( l < 0 ) {
l = numPoints - 1;
}
else if ( l >= numPoints ) {
l = 0;
- }
+ }
}
if ( k >= 100000 ) {
continue;
}
-
+
/* cull face 1 */
if ( !side2->culled && !( side2->compileFlags & C_TRANSLUCENT ) && !( side2->compileFlags & C_NODRAW ) ) {
side1->culled = qtrue;
g_numCoinFaces++;
}
-
+
if ( side1->planenum == side2->planenum && side1->culled == qtrue ) {
continue;
}
-
+
/* cull face 2 */
if ( !side1->culled && !( side1->compileFlags & C_TRANSLUCENT ) && !( side1->compileFlags & C_NODRAW ) ) {
side2->culled = qtrue;
}
}
}
-
+
/* emit some stats */
Sys_FPrintf( SYS_VRB, "%9d hidden faces culled\n", g_numHiddenFaces );
Sys_FPrintf( SYS_VRB, "%9d coincident faces culled\n", g_numCoinFaces );
*/
void ClipSidesIntoTree( entity_t *e, tree_t *tree ){
- brush_t *b;
- int i;
- winding_t *w;
- side_t *side, *newSide;
- shaderInfo_t *si;
-
-
+ brush_t *b;
+ int i;
+ winding_t *w;
+ side_t *side, *newSide;
+ shaderInfo_t *si;
+
+
/* ydnar: cull brush sides */
CullSides( e );
-
+
/* note it */
Sys_FPrintf( SYS_VRB, "--- ClipSidesIntoTree ---\n" );
-
+
/* walk the brush list */
for ( b = e->brushes; b; b = b->next )
{
if ( side->winding == NULL ) {
continue;
}
-
+
/* copy the winding */
w = CopyWinding( side->winding );
side->visibleHull = NULL;
ClipSideIntoTree_r( w, side, tree->headnode );
-
+
/* anything left? */
w = side->visibleHull;
if ( w == NULL ) {
continue;
}
-
+
/* shader? */
si = side->shaderInfo;
if ( si == NULL ) {
continue;
}
-
+
/* don't create faces for non-visible sides */
/* ydnar: except indexed shaders, like common/terrain and nodraw fog surfaces */
if ( ( si->compileFlags & C_NODRAW ) && si->indexed == qfalse && !( si->compileFlags & C_FOG ) ) {
continue;
}
-
+
/* always use the original winding for autosprites and noclip faces */
if ( si->autosprite || si->noClip ) {
w = side->winding;
}
-
+
/* save this winding as a visible surface */
DrawSurfaceForSide( e, b, side, w );
if ( !( si->compileFlags & C_FOG ) ) {
continue;
}
-
+
/* duplicate the up-facing side */
w = ReverseWinding( w );
newSide = safe_malloc( sizeof( *side ) );
*newSide = *side;
newSide->visibleHull = w;
newSide->planenum ^= 1;
-
+
/* save this winding as a visible surface */
DrawSurfaceForSide( e, b, newSide, w );
}
*/
int AddReferenceToLeaf( mapDrawSurface_t *ds, node_t *node ){
- drawSurfRef_t *dsr;
-
-
+ drawSurfRef_t *dsr;
+
+
/* dummy check */
if ( node->planenum != PLANENUM_LEAF || node->opaque ) {
return 0;
}
-
+
/* try to find an existing reference */
for ( dsr = node->drawSurfReferences; dsr; dsr = dsr->nextRef )
{
if ( dsr->outputNum == numBSPDrawSurfaces ) {
return 0;
+ }
}
- }
-
+
/* add a new reference */
dsr = safe_malloc( sizeof( *dsr ) );
dsr->outputNum = numBSPDrawSurfaces;
dsr->nextRef = node->drawSurfReferences;
node->drawSurfReferences = dsr;
-
+
/* ydnar: sky/skybox surfaces */
if ( node->skybox ) {
ds->skybox = qtrue;
if ( ds->shaderInfo->compileFlags & C_SKY ) {
node->sky = qtrue;
}
-
+
/* return */
return 1;
}
*/
int AddReferenceToTree_r( mapDrawSurface_t *ds, node_t *node, qboolean skybox ){
- int i, refs = 0;
-
-
+ int i, refs = 0;
+
+
/* dummy check */
if ( node == NULL ) {
return 0;
}
-
+
/* is this a decision node? */
if ( node->planenum != PLANENUM_LEAF ) {
/* add to child nodes and return */
refs += AddReferenceToTree_r( ds, node->children[ 1 ], skybox );
return refs;
}
-
+
/* ydnar */
if ( skybox ) {
/* skybox surfaces only get added to sky leaves */
if ( !node->sky ) {
return 0;
}
-
+
/* increase the leaf bounds */
for ( i = 0; i < ds->numVerts; i++ )
AddPointToBounds( ds->verts[ i ].xyz, node->mins, node->maxs );
}
-
+
/* add a reference */
return AddReferenceToLeaf( ds, node );
}
*/
int FilterPointIntoTree_r( vec3_t point, mapDrawSurface_t *ds, node_t *node ){
- float d;
- plane_t *plane;
- int refs = 0;
-
-
+ float d;
+ plane_t *plane;
+ int refs = 0;
+
+
/* is this a decision node? */
if ( node->planenum != PLANENUM_LEAF ) {
/* classify the point in relation to the plane */
plane = &mapplanes[ node->planenum ];
d = DotProduct( point, plane->normal ) - plane->dist;
-
+
/* filter by this plane */
refs = 0;
if ( d >= -ON_EPSILON ) {
if ( d <= ON_EPSILON ) {
refs += FilterPointIntoTree_r( point, ds, node->children[ 1 ] );
}
-
+
/* return */
return refs;
}
-
+
/* add a reference */
return AddReferenceToLeaf( ds, node );
}
*/
int FilterPointConvexHullIntoTree_r( vec3_t **points, int npoints, mapDrawSurface_t *ds, node_t *node ){
- float d, dmin, dmax;
- plane_t *plane;
- int refs = 0;
- int i;
+ float d, dmin, dmax;
+ plane_t *plane;
+ int refs = 0;
+ int i;
if ( !points ) {
return 0;
}
-
+
/* is this a decision node? */
if ( node->planenum != PLANENUM_LEAF ) {
/* classify the point in relation to the plane */
}
if ( d < dmin ) {
dmin = d;
+ }
}
- }
-
+
/* filter by this plane */
refs = 0;
if ( dmax >= -ON_EPSILON ) {
if ( dmin <= ON_EPSILON ) {
refs += FilterPointConvexHullIntoTree_r( points, npoints, ds, node->children[ 1 ] );
}
-
+
/* return */
return refs;
}
-
+
/* add a reference */
return AddReferenceToLeaf( ds, node );
}
*/
int FilterWindingIntoTree_r( winding_t *w, mapDrawSurface_t *ds, node_t *node ){
- int i, refs = 0;
- plane_t *p1, *p2;
+ int i, refs = 0;
+ plane_t *p1, *p2;
vec4_t plane1, plane2;
- winding_t *fat, *front, *back;
- shaderInfo_t *si;
-
-
+ winding_t *fat, *front, *back;
+ shaderInfo_t *si;
+
+
/* get shaderinfo */
si = ds->shaderInfo;
-
+
/* ydnar: is this the head node? */
if ( node->parent == NULL && si != NULL &&
( si->mins[ 0 ] != 0.0f || si->maxs[ 0 ] != 0.0f ||
- si->mins[ 1 ] != 0.0f || si->maxs[ 1 ] != 0.0f ||
+ si->mins[ 1 ] != 0.0f || si->maxs[ 1 ] != 0.0f ||
si->mins[ 2 ] != 0.0f || si->maxs[ 2 ] != 0.0f ) ) {
static qboolean warned = qfalse;
if ( !warned ) {
* added to the three sub-windings, the fattening at least doesn't make
* it worse
*/
-
+
FreeWinding( w );
w = fat;
}
-
+
/* is this a decision node? */
if ( node->planenum != PLANENUM_LEAF ) {
/* get node plane */
p1 = &mapplanes[ node->planenum ];
VectorCopy( p1->normal, plane1 );
plane1[ 3 ] = p1->dist;
-
+
/* check if surface is planar */
if ( ds->planeNum >= 0 ) {
/* get surface plane */
p2 = &mapplanes[ ds->planeNum ];
VectorCopy( p2->normal, plane2 );
plane2[ 3 ] = p2->dist;
-
+
#if 0
/* div0: this is the plague (inaccurate) */
vec4_t reverse;
- /* invert surface plane */
- VectorSubtract( vec3_origin, plane2, reverse );
- reverse[ 3 ] = -plane2[ 3 ];
-
- /* compare planes */
+ /* invert surface plane */
+ VectorSubtract( vec3_origin, plane2, reverse );
+ reverse[ 3 ] = -plane2[ 3 ];
+
+ /* compare planes */
if ( DotProduct( plane1, plane2 ) > 0.999f && fabs( plane1[ 3 ] - plane2[ 3 ] ) < 0.001f ) {
- return FilterWindingIntoTree_r( w, ds, node->children[ 0 ] );
+ return FilterWindingIntoTree_r( w, ds, node->children[ 0 ] );
}
if ( DotProduct( plane1, reverse ) > 0.999f && fabs( plane1[ 3 ] - reverse[ 3 ] ) < 0.001f ) {
- return FilterWindingIntoTree_r( w, ds, node->children[ 1 ] );
+ return FilterWindingIntoTree_r( w, ds, node->children[ 1 ] );
}
#else
/* div0: this is the cholera (doesn't hit enough) */
- /* the drawsurf might have an associated plane, if so, force a filter here */
+ /* the drawsurf might have an associated plane, if so, force a filter here */
if ( ds->planeNum == node->planenum ) {
- return FilterWindingIntoTree_r( w, ds, node->children[ 0 ] );
+ return FilterWindingIntoTree_r( w, ds, node->children[ 0 ] );
}
if ( ds->planeNum == ( node->planenum ^ 1 ) ) {
- return FilterWindingIntoTree_r( w, ds, node->children[ 1 ] );
+ return FilterWindingIntoTree_r( w, ds, node->children[ 1 ] );
}
#endif
}
-
+
/* clip the winding by this plane */
ClipWindingEpsilonStrict( w, plane1, plane1[ 3 ], ON_EPSILON, &front, &back ); /* strict; we handle the "winding disappeared" case */
-
+
/* filter by this plane */
refs = 0;
if ( front == NULL && back == NULL ) {
refs += FilterWindingIntoTree_r( back, ds, node->children[ 1 ] );
}
FreeWinding( w );
-
+
/* return */
return refs;
}
-
+
/* add a reference */
return AddReferenceToLeaf( ds, node );
}
*/
int FilterFaceIntoTree( mapDrawSurface_t *ds, tree_t *tree ){
- winding_t *w;
- int refs = 0;
-
-
+ winding_t *w;
+ int refs = 0;
+
+
/* make a winding and filter it into the tree */
w = WindingFromDrawSurf( ds );
refs = FilterWindingIntoTree_r( w, ds, tree->headnode );
-
+
/* return */
return refs;
}
subdivides a patch into an approximate curve and filters it into the tree
*/
-#define FILTER_SUBDIVISION 8
+#define FILTER_SUBDIVISION 8
static int FilterPatchIntoTree( mapDrawSurface_t *ds, tree_t *tree ){
- int x, y, refs = 0;
-
+ int x, y, refs = 0;
+
for ( y = 0; y + 2 < ds->patchHeight; y += 2 )
for ( x = 0; x + 2 < ds->patchWidth; x += 2 )
{
*/
static int FilterTrianglesIntoTree( mapDrawSurface_t *ds, tree_t *tree ){
- int i, refs;
- winding_t *w;
-
-
+ int i, refs;
+ winding_t *w;
+
+
/* ydnar: gs mods: this was creating bogus triangles before */
refs = 0;
for ( i = 0; i < ds->numIndexes; i += 3 )
{
/* error check */
if ( ds->indexes[ i ] >= ds->numVerts ||
- ds->indexes[ i + 1 ] >= ds->numVerts ||
+ ds->indexes[ i + 1 ] >= ds->numVerts ||
ds->indexes[ i + 2 ] >= ds->numVerts ) {
Error( "Index %d greater than vertex count %d", ds->indexes[ i ], ds->numVerts );
}
-
+
/* make a triangle winding and filter it into the tree */
w = AllocWinding( 3 );
w->numpoints = 3;
VectorCopy( ds->verts[ ds->indexes[ i + 2 ] ].xyz, w->p[ 2 ] );
refs += FilterWindingIntoTree_r( w, ds, tree->headnode );
}
-
+
/* use point filtering as well */
for ( i = 0; i < ds->numVerts; i++ )
refs += FilterPointIntoTree_r( ds->verts[ i ].xyz, ds, tree->headnode );
*/
static int FilterFoliageIntoTree( mapDrawSurface_t *ds, tree_t *tree ){
- int f, i, refs;
- bspDrawVert_t *instance;
- vec3_t xyz;
- winding_t *w;
-
-
+ int f, i, refs;
+ bspDrawVert_t *instance;
+ vec3_t xyz;
+ winding_t *w;
+
+
/* walk origin list */
refs = 0;
for ( f = 0; f < ds->numFoliageInstances; f++ )
{
/* get instance */
instance = ds->verts + ds->patchHeight + f;
-
+
/* walk triangle list */
for ( i = 0; i < ds->numIndexes; i += 3 )
{
/* error check */
if ( ds->indexes[ i ] >= ds->numVerts ||
- ds->indexes[ i + 1 ] >= ds->numVerts ||
+ ds->indexes[ i + 1 ] >= ds->numVerts ||
ds->indexes[ i + 2 ] >= ds->numVerts ) {
Error( "Index %d greater than vertex count %d", ds->indexes[ i ], ds->numVerts );
}
-
+
/* make a triangle winding and filter it into the tree */
w = AllocWinding( 3 );
w->numpoints = 3;
VectorAdd( instance->xyz, ds->verts[ ds->indexes[ i + 2 ] ].xyz, w->p[ 2 ] );
refs += FilterWindingIntoTree_r( w, ds, tree->headnode );
}
-
+
/* use point filtering as well */
for ( i = 0; i < ( ds->numVerts - ds->numFoliageInstances ); i++ )
{
refs += FilterPointIntoTree_r( xyz, ds, tree->headnode );
}
}
-
+
return refs;
}
*/
void EmitDrawVerts( mapDrawSurface_t *ds, bspDrawSurface_t *out ){
- int i, k;
- bspDrawVert_t *dv;
- shaderInfo_t *si;
- float offset;
-
-
+ int i, k;
+ bspDrawVert_t *dv;
+ shaderInfo_t *si;
+ float offset;
+
+
/* get stuff */
si = ds->shaderInfo;
offset = si->offset;
-
+
/* copy the verts */
out->firstVert = numBSPDrawVerts;
out->numVerts = ds->numVerts;
/* allocate a new vert */
IncDrawVerts();
dv = &bspDrawVerts[ numBSPDrawVerts - 1 ];
-
+
/* copy it */
memcpy( dv, &ds->verts[ i ], sizeof( *dv ) );
-
+
/* offset? */
if ( offset != 0.0f ) {
VectorMA( dv->xyz, offset, dv->normal, dv->xyz );
}
-
+
/* expand model bounds
necessary because of misc_model surfaces on entities
note: does not happen on worldspawn as its bounds is only used for determining lightgrid bounds */
if ( numBSPModels > 0 ) {
AddPointToBounds( dv->xyz, bspModels[ numBSPModels ].mins, bspModels[ numBSPModels ].maxs );
}
-
+
/* debug color? */
if ( debugSurfaces ) {
for ( k = 0; k < MAX_LIGHTMAPS; k++ )
*/
int FindDrawIndexes( int numIndexes, int *indexes ){
- int i, j, numTestIndexes;
-
-
+ int i, j, numTestIndexes;
+
+
/* dummy check */
if ( numIndexes < 3 || numBSPDrawIndexes < numIndexes || indexes == NULL ) {
return numBSPDrawIndexes;
}
-
+
/* set limit */
numTestIndexes = 1 + numBSPDrawIndexes - numIndexes;
-
+
/* handle 3 indexes as a special case for performance */
if ( numIndexes == 3 ) {
/* run through all indexes */
{
/* test 3 indexes */
if ( indexes[ 0 ] == bspDrawIndexes[ i ] &&
- indexes[ 1 ] == bspDrawIndexes[ i + 1 ] &&
+ indexes[ 1 ] == bspDrawIndexes[ i + 1 ] &&
indexes[ 2 ] == bspDrawIndexes[ i + 2 ] ) {
numRedundantIndexes += numIndexes;
return i;
}
}
-
+
/* failed */
return numBSPDrawIndexes;
}
-
+
/* handle 4 or more indexes */
for ( i = 0; i < numTestIndexes; i++ )
{
/* test first 4 indexes */
if ( indexes[ 0 ] == bspDrawIndexes[ i ] &&
- indexes[ 1 ] == bspDrawIndexes[ i + 1 ] &&
- indexes[ 2 ] == bspDrawIndexes[ i + 2 ] &&
+ indexes[ 1 ] == bspDrawIndexes[ i + 1 ] &&
+ indexes[ 2 ] == bspDrawIndexes[ i + 2 ] &&
indexes[ 3 ] == bspDrawIndexes[ i + 3 ] ) {
/* handle 4 indexes */
if ( numIndexes == 4 ) {
return i;
}
-
+
/* test the remainder */
for ( j = 4; j < numIndexes; j++ )
{
}
}
}
-
+
/* failed */
return numBSPDrawIndexes;
}
*/
void EmitDrawIndexes( mapDrawSurface_t *ds, bspDrawSurface_t *out ){
- int i;
-
-
+ int i;
+
+
/* attempt to use redundant indexing */
out->firstIndex = FindDrawIndexes( ds->numIndexes, ds->indexes );
out->numIndexes = ds->numIndexes;
if ( ds->type != SURFACE_PATCH ) {
if ( bspDrawIndexes[ numBSPDrawIndexes ] < 0 || bspDrawIndexes[ numBSPDrawIndexes ] >= ds->numVerts ) {
Sys_Printf( "WARNING: %d %s has invalid index %d (%d)\n",
- numBSPDrawSurfaces,
- ds->shaderInfo->shader,
- bspDrawIndexes[ numBSPDrawIndexes ],
- i );
+ numBSPDrawSurfaces,
+ ds->shaderInfo->shader,
+ bspDrawIndexes[ numBSPDrawIndexes ],
+ i );
bspDrawIndexes[ numBSPDrawIndexes ] = 0;
}
}
-
+
/* increment index count */
numBSPDrawIndexes++;
}
*/
void EmitFlareSurface( mapDrawSurface_t *ds ){
- int i;
- bspDrawSurface_t *out;
-
-
+ int i;
+ bspDrawSurface_t *out;
+
+
/* ydnar: nuking useless flare drawsurfaces */
if ( emitFlares == qfalse && ds->type != SURFACE_SHADER ) {
return;
}
-
+
/* limit check */
if ( numBSPDrawSurfaces == MAX_MAP_DRAW_SURFS ) {
Error( "MAX_MAP_DRAW_SURFS" );
}
-
+
/* allocate a new surface */
if ( numBSPDrawSurfaces == MAX_MAP_DRAW_SURFS ) {
Error( "MAX_MAP_DRAW_SURFS" );
ds->outputNum = numBSPDrawSurfaces;
numBSPDrawSurfaces++;
memset( out, 0, sizeof( *out ) );
-
+
/* set it up */
out->surfaceType = MST_FLARE;
out->shaderNum = EmitShader( ds->shaderInfo->shader, &ds->shaderInfo->contentFlags, &ds->shaderInfo->surfaceFlags );
out->fogNum = ds->fogNum;
-
+
/* RBSP */
for ( i = 0; i < MAX_LIGHTMAPS; i++ )
{
}
out->lightmapStyles[ 0 ] = ds->lightStyle;
out->vertexStyles[ 0 ] = ds->lightStyle;
-
- VectorCopy( ds->lightmapOrigin, out->lightmapOrigin ); /* origin */
- VectorCopy( ds->lightmapVecs[ 0 ], out->lightmapVecs[ 0 ] ); /* color */
+
+ VectorCopy( ds->lightmapOrigin, out->lightmapOrigin ); /* origin */
+ VectorCopy( ds->lightmapVecs[ 0 ], out->lightmapVecs[ 0 ] ); /* color */
VectorCopy( ds->lightmapVecs[ 1 ], out->lightmapVecs[ 1 ] );
- VectorCopy( ds->lightmapVecs[ 2 ], out->lightmapVecs[ 2 ] ); /* normal */
-
+ VectorCopy( ds->lightmapVecs[ 2 ], out->lightmapVecs[ 2 ] ); /* normal */
+
/* add to count */
numSurfacesByType[ ds->type ]++;
}
*/
void EmitPatchSurface( entity_t *e, mapDrawSurface_t *ds ){
- int i, j;
- bspDrawSurface_t *out;
- int surfaceFlags, contentFlags;
- int forcePatchMeta;
+ int i, j;
+ bspDrawSurface_t *out;
+ int surfaceFlags, contentFlags;
+ int forcePatchMeta;
/* vortex: _patchMeta support */
forcePatchMeta = IntForKey( e, "_patchMeta" );
if ( !forcePatchMeta ) {
forcePatchMeta = IntForKey( e, "patchMeta" );
}
-
+
/* invert the surface if necessary */
if ( ds->backSide || ds->shaderInfo->invert ) {
- bspDrawVert_t *dv1, *dv2, temp;
+ bspDrawVert_t *dv1, *dv2, temp;
/* walk the verts, flip the normal */
for ( i = 0; i < ds->numVerts; i++ )
VectorScale( ds->verts[ i ].normal, -1.0f, ds->verts[ i ].normal );
-
+
/* walk the verts again, but this time reverse their order */
for ( j = 0; j < ds->patchHeight; j++ )
{
memcpy( dv2, &temp, sizeof( bspDrawVert_t ) );
}
}
-
+
/* invert facing */
VectorScale( ds->lightmapVecs[ 2 ], -1.0f, ds->lightmapVecs[ 2 ] );
}
contentFlags = ds->shaderInfo->contentFlags;
ApplySurfaceParm( "nodraw", &contentFlags, &surfaceFlags, NULL );
ApplySurfaceParm( "pointlight", &contentFlags, &surfaceFlags, NULL );
-
+
/* we don't want this patch getting lightmapped */
VectorClear( ds->lightmapVecs[ 2 ] );
VectorClear( ds->lightmapAxis );
out->patchWidth = ds->patchWidth;
out->patchHeight = ds->patchHeight;
out->fogNum = ds->fogNum;
-
+
/* RBSP */
for ( i = 0; i < MAX_LIGHTMAPS; i++ )
{
}
out->lightmapStyles[ 0 ] = LS_NORMAL;
out->vertexStyles[ 0 ] = LS_NORMAL;
-
+
/* ydnar: gs mods: previously, the lod bounds were stored in lightmapVecs[ 0 ] and [ 1 ], moved to bounds[ 0 ] and [ 1 ] */
VectorCopy( ds->lightmapOrigin, out->lightmapOrigin );
VectorCopy( ds->bounds[ 0 ], out->lightmapVecs[ 0 ] );
VectorCopy( ds->bounds[ 1 ], out->lightmapVecs[ 1 ] );
VectorCopy( ds->lightmapVecs[ 2 ], out->lightmapVecs[ 2 ] );
-
+
/* ydnar: gs mods: clear out the plane normal */
if ( ds->planar == qfalse ) {
VectorClear( out->lightmapVecs[ 2 ] );
}
-
+
/* emit the verts and indexes */
EmitDrawVerts( ds, out );
EmitDrawIndexes( ds, out );
-
+
/* add to count */
numSurfacesByType[ ds->type ]++;
}
optimizes the vertex/index data in a triangle surface
*/
-#define VERTEX_CACHE_SIZE 16
+#define VERTEX_CACHE_SIZE 16
static void OptimizeTriangleSurface( mapDrawSurface_t *ds ){
- int i, j, k, temp, first, best, bestScore, score;
- int vertexCache[ VERTEX_CACHE_SIZE + 1 ]; /* one more for optimizing insert */
- int *indexes;
-
-
+ int i, j, k, temp, first, best, bestScore, score;
+ int vertexCache[ VERTEX_CACHE_SIZE + 1 ]; /* one more for optimizing insert */
+ int *indexes;
+
+
/* certain surfaces don't get optimized */
if ( ds->numIndexes <= VERTEX_CACHE_SIZE ||
ds->shaderInfo->autosprite ) {
return;
}
-
+
/* create index scratch pad */
indexes = safe_malloc( ds->numIndexes * sizeof( *indexes ) );
memcpy( indexes, ds->indexes, ds->numIndexes * sizeof( *indexes ) );
-
+
/* setup */
for ( i = 0; i <= VERTEX_CACHE_SIZE && i < ds->numIndexes; i++ )
vertexCache[ i ] = indexes[ i ];
-
+
/* add triangles in a vertex cache-aware order */
for ( i = 0; i < ds->numIndexes; i += 3 )
{
if ( first < 0 ) {
first = j;
}
-
+
/* score the triangle */
score = 0;
for ( k = 0; k < VERTEX_CACHE_SIZE; k++ )
{
if ( indexes[ j ] == vertexCache[ k ] || indexes[ j + 1 ] == vertexCache[ k ] || indexes[ j + 2 ] == vertexCache[ k ] ) {
score++;
+ }
}
- }
-
+
/* better triangle? */
if ( score > bestScore ) {
bestScore = score;
best = j;
}
-
+
/* a perfect score of 3 means this triangle's verts are already present in the vertex cache */
if ( score == 3 ) {
break;
+ }
}
}
- }
-
+
/* check if no decent triangle was found, and use first available */
if ( best < 0 ) {
best = first;
}
-
+
/* valid triangle? */
if ( best >= 0 ) {
/* add triangle to vertex cache */
{
if ( indexes[ best + j ] == vertexCache[ k ] ) {
break;
+ }
}
- }
-
+
if ( k >= VERTEX_CACHE_SIZE ) {
/* pop off top of vertex cache */
for ( k = VERTEX_CACHE_SIZE; k > 0; k-- )
vertexCache[ k ] = vertexCache[ k - 1 ];
-
+
/* add vertex */
vertexCache[ 0 ] = indexes[ best + j ];
}
}
-
+
/* add triangle to surface */
ds->indexes[ i ] = indexes[ best ];
ds->indexes[ i + 1 ] = indexes[ best + 1 ];
ds->indexes[ i + 2 ] = indexes[ best + 2 ];
-
+
/* clear from input pool */
indexes[ best ] = -1;
indexes[ best + 1 ] = -1;
indexes[ best + 2 ] = -1;
-
+
/* sort triangle windings (312 -> 123) */
while ( ds->indexes[ i ] > ds->indexes[ i + 1 ] || ds->indexes[ i ] > ds->indexes[ i + 2 ] )
{
}
}
}
-
+
/* clean up */
free( indexes );
}
*/
void EmitTriangleSurface( mapDrawSurface_t *ds ){
- int i, temp;
- bspDrawSurface_t *out;
+ int i, temp;
+ bspDrawSurface_t *out;
/* invert the surface if necessary */
if ( ds->backSide || ds->shaderInfo->invert ) {
ds->indexes[ i ] = ds->indexes[ i + 1 ];
ds->indexes[ i + 1 ] = temp;
}
-
+
/* walk the verts, flip the normal */
for ( i = 0; i < ds->numVerts; i++ )
VectorScale( ds->verts[ i ].normal, -1.0f, ds->verts[ i ].normal );
-
+
/* invert facing */
VectorScale( ds->lightmapVecs[ 2 ], -1.0f, ds->lightmapVecs[ 2 ] );
}
-
+
/* allocate a new surface */
if ( numBSPDrawSurfaces == MAX_MAP_DRAW_SURFS ) {
Error( "MAX_MAP_DRAW_SURFS" );
ds->outputNum = numBSPDrawSurfaces;
numBSPDrawSurfaces++;
memset( out, 0, sizeof( *out ) );
-
+
/* ydnar/sd: handle wolf et foliage surfaces */
if ( ds->type == SURFACE_FOLIAGE ) {
out->surfaceType = MST_FOLIAGE;
}
-
+
/* ydnar: gs mods: handle lightmapped terrain (force to planar type) */
//% else if( VectorLength( ds->lightmapAxis ) <= 0.0f || ds->type == SURFACE_TRIANGLES || ds->type == SURFACE_FOGHULL || debugSurfaces )
else if ( ( VectorLength( ds->lightmapAxis ) <= 0.0f && ds->planar == qfalse ) ||
- ds->type == SURFACE_TRIANGLES ||
- ds->type == SURFACE_FOGHULL ||
- ds->numVerts > maxLMSurfaceVerts ||
+ ds->type == SURFACE_TRIANGLES ||
+ ds->type == SURFACE_FOGHULL ||
+ ds->numVerts > maxLMSurfaceVerts ||
debugSurfaces ) {
out->surfaceType = MST_TRIANGLE_SOUP;
}
-
+
/* set to a planar face */
else{
out->surfaceType = MST_PLANAR;
}
-
+
/* set it up */
if ( debugSurfaces ) {
out->shaderNum = EmitShader( "debugsurfaces", NULL, NULL );
out->patchWidth = ds->patchWidth;
out->patchHeight = ds->patchHeight;
out->fogNum = ds->fogNum;
-
+
/* debug inset (push each triangle vertex towards the center of each triangle it is on */
if ( debugInset ) {
- bspDrawVert_t *a, *b, *c;
- vec3_t cent, dir;
+ bspDrawVert_t *a, *b, *c;
+ vec3_t cent, dir;
+
-
/* walk triangle list */
for ( i = 0; i < ds->numIndexes; i += 3 )
{
a = &ds->verts[ ds->indexes[ i ] ];
b = &ds->verts[ ds->indexes[ i + 1 ] ];
c = &ds->verts[ ds->indexes[ i + 2 ] ];
-
+
/* calculate centroid */
VectorCopy( a->xyz, cent );
VectorAdd( cent, b->xyz, cent );
VectorAdd( cent, c->xyz, cent );
VectorScale( cent, 1.0f / 3.0f, cent );
-
+
/* offset each vertex */
VectorSubtract( cent, a->xyz, dir );
VectorNormalize( dir, dir );
VectorAdd( c->xyz, dir, c->xyz );
}
}
-
+
/* RBSP */
for ( i = 0; i < MAX_LIGHTMAPS; i++ )
{
}
out->lightmapStyles[ 0 ] = LS_NORMAL;
out->vertexStyles[ 0 ] = LS_NORMAL;
-
+
/* lightmap vectors (lod bounds for patches */
VectorCopy( ds->lightmapOrigin, out->lightmapOrigin );
VectorCopy( ds->lightmapVecs[ 0 ], out->lightmapVecs[ 0 ] );
VectorCopy( ds->lightmapVecs[ 1 ], out->lightmapVecs[ 1 ] );
VectorCopy( ds->lightmapVecs[ 2 ], out->lightmapVecs[ 2 ] );
-
+
/* ydnar: gs mods: clear out the plane normal */
if ( ds->planar == qfalse ) {
VectorClear( out->lightmapVecs[ 2 ] );
}
-
+
/* optimize the surface's triangles */
OptimizeTriangleSurface( ds );
-
+
/* emit the verts and indexes */
EmitDrawVerts( ds, out );
EmitDrawIndexes( ds, out );
-
+
/* add to count */
numSurfacesByType[ ds->type ]++;
}
*/
static void MakeDebugPortalSurfs_r( node_t *node, shaderInfo_t *si ){
- int i, k, c, s;
- portal_t *p;
- winding_t *w;
- mapDrawSurface_t *ds;
- bspDrawVert_t *dv;
-
-
+ int i, k, c, s;
+ portal_t *p;
+ winding_t *w;
+ mapDrawSurface_t *ds;
+ bspDrawVert_t *dv;
+
+
/* recurse if decision node */
if ( node->planenum != PLANENUM_LEAF ) {
MakeDebugPortalSurfs_r( node->children[ 0 ], si );
MakeDebugPortalSurfs_r( node->children[ 1 ], si );
return;
}
-
+
/* don't bother with opaque leaves */
if ( node->opaque ) {
return;
}
-
+
/* walk the list of portals */
for ( c = 0, p = node->portals; p != NULL; c++, p = p->next[ s ] )
{
/* get winding and side even/odd */
w = p->winding;
s = ( p->nodes[ 1 ] == node );
-
+
/* is this a valid portal for this leaf? */
if ( w && p->nodes[ 0 ] == node ) {
/* is this portal passable? */
if ( PortalPassable( p ) == qfalse ) {
continue;
}
-
+
/* check max points */
if ( w->numpoints > 64 ) {
Error( "MakePortalSurfs_r: w->numpoints = %d", w->numpoints );
}
-
+
/* allocate a drawsurface */
ds = AllocDrawSurface( SURFACE_FACE );
ds->shaderInfo = si;
ds->numVerts = w->numpoints;
ds->verts = safe_malloc( ds->numVerts * sizeof( *ds->verts ) );
memset( ds->verts, 0, ds->numVerts * sizeof( *ds->verts ) );
-
+
/* walk the winding */
for ( i = 0; i < ds->numVerts; i++ )
{
/* get vert */
dv = ds->verts + i;
-
+
/* set it */
VectorCopy( w->p[ i ], dv->xyz );
VectorCopy( p->plane.normal, dv->normal );
*/
void MakeDebugPortalSurfs( tree_t *tree ){
- shaderInfo_t *si;
-
-
+ shaderInfo_t *si;
+
+
/* note it */
Sys_FPrintf( SYS_VRB, "--- MakeDebugPortalSurfs ---\n" );
-
+
/* get portal debug shader */
si = ShaderInfoForShader( "debugportals" );
-
+
/* walk the tree */
MakeDebugPortalSurfs_r( tree->headnode, si );
}
*/
void MakeFogHullSurfs( entity_t *e, tree_t *tree, char *shader ){
- shaderInfo_t *si;
- mapDrawSurface_t *ds;
- vec3_t fogMins, fogMaxs;
- int i, indexes[] =
- {
- 0, 1, 2, 0, 2, 3,
- 4, 7, 5, 5, 7, 6,
- 1, 5, 6, 1, 6, 2,
- 0, 4, 5, 0, 5, 1,
- 2, 6, 7, 2, 7, 3,
- 3, 7, 4, 3, 4, 0
- };
-
-
+ shaderInfo_t *si;
+ mapDrawSurface_t *ds;
+ vec3_t fogMins, fogMaxs;
+ int i, indexes[] =
+ {
+ 0, 1, 2, 0, 2, 3,
+ 4, 7, 5, 5, 7, 6,
+ 1, 5, 6, 1, 6, 2,
+ 0, 4, 5, 0, 5, 1,
+ 2, 6, 7, 2, 7, 3,
+ 3, 7, 4, 3, 4, 0
+ };
+
+
/* dummy check */
if ( shader == NULL || shader[ 0 ] == '\0' ) {
return;
}
-
+
/* note it */
Sys_FPrintf( SYS_VRB, "--- MakeFogHullSurfs ---\n" );
-
+
/* get hull bounds */
VectorCopy( mapMins, fogMins );
VectorCopy( mapMaxs, fogMaxs );
fogMins[ i ] -= 128;
fogMaxs[ i ] += 128;
}
-
+
/* get foghull shader */
si = ShaderInfoForShader( shader );
-
+
/* allocate a drawsurface */
ds = AllocDrawSurface( SURFACE_FOGHULL );
ds->shaderInfo = si;
ds->numIndexes = 36;
ds->indexes = safe_malloc( ds->numIndexes * sizeof( *ds->indexes ) );
memset( ds->indexes, 0, ds->numIndexes * sizeof( *ds->indexes ) );
-
+
/* set verts */
VectorSet( ds->verts[ 0 ].xyz, fogMins[ 0 ], fogMins[ 1 ], fogMins[ 2 ] );
VectorSet( ds->verts[ 1 ].xyz, fogMins[ 0 ], fogMaxs[ 1 ], fogMins[ 2 ] );
VectorSet( ds->verts[ 2 ].xyz, fogMaxs[ 0 ], fogMaxs[ 1 ], fogMins[ 2 ] );
VectorSet( ds->verts[ 3 ].xyz, fogMaxs[ 0 ], fogMins[ 1 ], fogMins[ 2 ] );
-
+
VectorSet( ds->verts[ 4 ].xyz, fogMins[ 0 ], fogMins[ 1 ], fogMaxs[ 2 ] );
VectorSet( ds->verts[ 5 ].xyz, fogMins[ 0 ], fogMaxs[ 1 ], fogMaxs[ 2 ] );
VectorSet( ds->verts[ 6 ].xyz, fogMaxs[ 0 ], fogMaxs[ 1 ], fogMaxs[ 2 ] );
VectorSet( ds->verts[ 7 ].xyz, fogMaxs[ 0 ], fogMins[ 1 ], fogMaxs[ 2 ] );
-
+
/* set indexes */
memcpy( ds->indexes, indexes, ds->numIndexes * sizeof( *ds->indexes ) );
}
*/
void BiasSurfaceTextures( mapDrawSurface_t *ds ){
- int i;
-
-
+ int i;
+
+
/* calculate the surface texture bias */
CalcSurfaceTextureRange( ds );
-
+
/* don't bias globaltextured shaders */
if ( ds->shaderInfo->globalTexture ) {
return;
}
-
+
/* bias the texture coordinates */
for ( i = 0; i < ds->numVerts; i++ )
{
*/
int AddSurfaceModelsToTriangle_r( mapDrawSurface_t *ds, surfaceModel_t *model, bspDrawVert_t **tri ){
- bspDrawVert_t mid, *tri2[ 3 ];
- int max, n, localNumSurfaceModels;
-
-
+ bspDrawVert_t mid, *tri2[ 3 ];
+ int max, n, localNumSurfaceModels;
+
+
/* init */
localNumSurfaceModels = 0;
-
+
/* subdivide calc */
{
- int i;
- float *a, *b, dx, dy, dz, dist, maxDist;
-
-
+ int i;
+ float *a, *b, dx, dy, dz, dist, maxDist;
+
+
/* find the longest edge and split it */
max = -1;
maxDist = 0.0f;
/* get verts */
a = tri[ i ]->xyz;
b = tri[ ( i + 1 ) % 3 ]->xyz;
-
+
/* get dists */
dx = a[ 0 ] - b[ 0 ];
dy = a[ 1 ] - b[ 1 ];
dz = a[ 2 ] - b[ 2 ];
dist = ( dx * dx ) + ( dy * dy ) + ( dz * dz );
-
+
/* longer? */
if ( dist > maxDist ) {
maxDist = dist;
max = i;
}
}
-
+
/* is the triangle small enough? */
if ( max < 0 || maxDist <= ( model->density * model->density ) ) {
- float odds, r, angle;
- vec3_t origin, normal, scale, axis[ 3 ], angles;
- m4x4_t transform, temp;
+ float odds, r, angle;
+ vec3_t origin, normal, scale, axis[ 3 ], angles;
+ m4x4_t transform, temp;
+
-
/* roll the dice (model's odds scaled by vertex alpha) */
odds = model->odds * ( tri[ 0 ]->color[ 0 ][ 3 ] + tri[ 0 ]->color[ 0 ][ 3 ] + tri[ 0 ]->color[ 0 ][ 3 ] ) / 765.0f;
r = Random();
if ( r > odds ) {
return 0;
}
-
+
/* calculate scale */
r = model->minScale + Random() * ( model->maxScale - model->minScale );
VectorSet( scale, r, r, r );
-
+
/* calculate angle */
angle = model->minAngle + Random() * ( model->maxAngle - model->minAngle );
-
+
/* calculate average origin */
VectorCopy( tri[ 0 ]->xyz, origin );
VectorAdd( origin, tri[ 1 ]->xyz, origin );
VectorAdd( origin, tri[ 2 ]->xyz, origin );
VectorScale( origin, ( 1.0f / 3.0f ), origin );
-
+
/* clear transform matrix */
m4x4_identity( transform );
if ( model->oriented ) {
/* set angles */
VectorSet( angles, 0.0f, 0.0f, angle );
-
+
/* calculate average normal */
VectorCopy( tri[ 0 ]->normal, normal );
VectorAdd( normal, tri[ 1 ]->normal, normal );
if ( VectorNormalize( normal, axis[ 2 ] ) == 0.0f ) {
VectorCopy( tri[ 0 ]->normal, axis[ 2 ] );
}
-
+
/* make perpendicular vectors */
MakeNormalVectors( axis[ 2 ], axis[ 1 ], axis[ 0 ] );
-
+
/* copy to matrix */
m4x4_identity( temp );
- temp[ 0 ] = axis[ 0 ][ 0 ]; temp[ 1 ] = axis[ 0 ][ 1 ]; temp[ 2 ] = axis[ 0 ][ 2 ];
- temp[ 4 ] = axis[ 1 ][ 0 ]; temp[ 5 ] = axis[ 1 ][ 1 ]; temp[ 6 ] = axis[ 1 ][ 2 ];
- temp[ 8 ] = axis[ 2 ][ 0 ]; temp[ 9 ] = axis[ 2 ][ 1 ]; temp[ 10 ] = axis[ 2 ][ 2 ];
-
+ temp[ 0 ] = axis[ 0 ][ 0 ]; temp[ 1 ] = axis[ 0 ][ 1 ]; temp[ 2 ] = axis[ 0 ][ 2 ];
+ temp[ 4 ] = axis[ 1 ][ 0 ]; temp[ 5 ] = axis[ 1 ][ 1 ]; temp[ 6 ] = axis[ 1 ][ 2 ];
+ temp[ 8 ] = axis[ 2 ][ 0 ]; temp[ 9 ] = axis[ 2 ][ 1 ]; temp[ 10 ] = axis[ 2 ][ 2 ];
+
/* scale */
m4x4_scale_by_vec3( temp, scale );
-
+
/* rotate around z axis */
m4x4_rotate_by_vec3( temp, angles, eXYZ );
-
+
/* translate */
m4x4_translate_by_vec3( transform, origin );
-
+
/* tranform into axis space */
m4x4_multiply_by_m4x4( transform, temp );
}
-
+
/* handle z-up models */
else
{
/* set angles */
VectorSet( angles, 0.0f, 0.0f, angle );
-
+
/* set matrix */
m4x4_pivoted_transform_by_vec3( transform, origin, angles, eXYZ, scale, vec3_origin );
}
-
+
/* insert the model */
InsertModel( (char *) model->model, 0, 0, transform, NULL, ds->celShader, ds->entityNum, ds->castShadows, ds->recvShadows, 0, ds->lightmapScale, 0, 0, ds->colormod );
-
+
/* return to sender */
return 1;
}
}
-
+
/* split the longest edge and map it */
LerpDrawVert( tri[ max ], tri[ ( max + 1 ) % 3 ], &mid );
-
+
/* recurse to first triangle */
VectorCopy( tri, tri2 );
tri2[ max ] = ∣
return n;
}
localNumSurfaceModels += n;
-
+
/* recurse to second triangle */
VectorCopy( tri, tri2 );
tri2[ ( max + 1 ) % 3 ] = ∣
return n;
}
localNumSurfaceModels += n;
-
+
/* return count */
return localNumSurfaceModels;
}
*/
int AddSurfaceModels( mapDrawSurface_t *ds ){
- surfaceModel_t *model;
- int i, x, y, n, pw[ 5 ], r, localNumSurfaceModels, iterations;
- mesh_t src, *mesh, *subdivided;
- bspDrawVert_t centroid, *tri[ 3 ];
- float alpha;
-
-
+ surfaceModel_t *model;
+ int i, x, y, n, pw[ 5 ], r, localNumSurfaceModels, iterations;
+ mesh_t src, *mesh, *subdivided;
+ bspDrawVert_t centroid, *tri[ 3 ];
+ float alpha;
+
+
/* dummy check */
if ( ds == NULL || ds->shaderInfo == NULL || ds->shaderInfo->surfaceModel == NULL ) {
return 0;
}
-
+
/* init */
localNumSurfaceModels = 0;
-
+
/* walk the model list */
for ( model = ds->shaderInfo->surfaceModel; model != NULL; model = model->next )
{
/* switch on type */
switch ( ds->type )
{
- /* handle brush faces and decals */
- case SURFACE_FACE:
- case SURFACE_DECAL:
- /* calculate centroid */
- memset( ¢roid, 0, sizeof( centroid ) );
- alpha = 0.0f;
-
- /* walk verts */
+ /* handle brush faces and decals */
+ case SURFACE_FACE:
+ case SURFACE_DECAL:
+ /* calculate centroid */
+ memset( ¢roid, 0, sizeof( centroid ) );
+ alpha = 0.0f;
+
+ /* walk verts */
for ( i = 0; i < ds->numVerts; i++ )
- {
- VectorAdd( centroid.xyz, ds->verts[ i ].xyz, centroid.xyz );
- VectorAdd( centroid.normal, ds->verts[ i ].normal, centroid.normal );
- centroid.st[ 0 ] += ds->verts[ i ].st[ 0 ];
- centroid.st[ 1 ] += ds->verts[ i ].st[ 1 ];
- alpha += ds->verts[ i ].color[ 0 ][ 3 ];
- }
-
- /* average */
- centroid.xyz[ 0 ] /= ds->numVerts;
- centroid.xyz[ 1 ] /= ds->numVerts;
- centroid.xyz[ 2 ] /= ds->numVerts;
+ {
+ VectorAdd( centroid.xyz, ds->verts[ i ].xyz, centroid.xyz );
+ VectorAdd( centroid.normal, ds->verts[ i ].normal, centroid.normal );
+ centroid.st[ 0 ] += ds->verts[ i ].st[ 0 ];
+ centroid.st[ 1 ] += ds->verts[ i ].st[ 1 ];
+ alpha += ds->verts[ i ].color[ 0 ][ 3 ];
+ }
+
+ /* average */
+ centroid.xyz[ 0 ] /= ds->numVerts;
+ centroid.xyz[ 1 ] /= ds->numVerts;
+ centroid.xyz[ 2 ] /= ds->numVerts;
if ( VectorNormalize( centroid.normal, centroid.normal ) == 0.0f ) {
- VectorCopy( ds->verts[ 0 ].normal, centroid.normal );
- }
- centroid.st[ 0 ] /= ds->numVerts;
- centroid.st[ 1 ] /= ds->numVerts;
- alpha /= ds->numVerts;
- centroid.color[ 0 ][ 0 ] = 0xFF;
- centroid.color[ 0 ][ 1 ] = 0xFF;
- centroid.color[ 0 ][ 2 ] = 0xFF;
+ VectorCopy( ds->verts[ 0 ].normal, centroid.normal );
+ }
+ centroid.st[ 0 ] /= ds->numVerts;
+ centroid.st[ 1 ] /= ds->numVerts;
+ alpha /= ds->numVerts;
+ centroid.color[ 0 ][ 0 ] = 0xFF;
+ centroid.color[ 0 ][ 1 ] = 0xFF;
+ centroid.color[ 0 ][ 2 ] = 0xFF;
centroid.color[ 0 ][ 2 ] = ( alpha > 255.0f ? 0xFF : alpha );
-
- /* head vert is centroid */
- tri[ 0 ] = ¢roid;
-
- /* walk fanned triangles */
+
+ /* head vert is centroid */
+ tri[ 0 ] = ¢roid;
+
+ /* walk fanned triangles */
for ( i = 0; i < ds->numVerts; i++ )
- {
- /* set triangle */
- tri[ 1 ] = &ds->verts[ i ];
+ {
+ /* set triangle */
+ tri[ 1 ] = &ds->verts[ i ];
tri[ 2 ] = &ds->verts[ ( i + 1 ) % ds->numVerts ];
-
- /* create models */
- n = AddSurfaceModelsToTriangle_r( ds, model, tri );
+
+ /* create models */
+ n = AddSurfaceModelsToTriangle_r( ds, model, tri );
if ( n < 0 ) {
- return n;
+ return n;
}
- localNumSurfaceModels += n;
- }
- break;
-
- /* handle patches */
- case SURFACE_PATCH:
- /* subdivide the surface */
- src.width = ds->patchWidth;
- src.height = ds->patchHeight;
- src.verts = ds->verts;
- //% subdivided = SubdivideMesh( src, 8.0f, 512 );
- iterations = IterationsForCurve( ds->longestCurve, patchSubdivisions );
- subdivided = SubdivideMesh2( src, iterations );
-
- /* fit it to the curve and remove colinear verts on rows/columns */
- PutMeshOnCurve( *subdivided );
- mesh = RemoveLinearMeshColumnsRows( subdivided );
- FreeMesh( subdivided );
-
- /* subdivide each quad to place the models */
+ localNumSurfaceModels += n;
+ }
+ break;
+
+ /* handle patches */
+ case SURFACE_PATCH:
+ /* subdivide the surface */
+ src.width = ds->patchWidth;
+ src.height = ds->patchHeight;
+ src.verts = ds->verts;
+ //% subdivided = SubdivideMesh( src, 8.0f, 512 );
+ iterations = IterationsForCurve( ds->longestCurve, patchSubdivisions );
+ subdivided = SubdivideMesh2( src, iterations );
+
+ /* fit it to the curve and remove colinear verts on rows/columns */
+ PutMeshOnCurve( *subdivided );
+ mesh = RemoveLinearMeshColumnsRows( subdivided );
+ FreeMesh( subdivided );
+
+ /* subdivide each quad to place the models */
for ( y = 0; y < ( mesh->height - 1 ); y++ )
- {
+ {
for ( x = 0; x < ( mesh->width - 1 ); x++ )
- {
- /* set indexes */
+ {
+ /* set indexes */
pw[ 0 ] = x + ( y * mesh->width );
pw[ 1 ] = x + ( ( y + 1 ) * mesh->width );
pw[ 2 ] = x + 1 + ( ( y + 1 ) * mesh->width );
pw[ 3 ] = x + 1 + ( y * mesh->width );
pw[ 4 ] = x + ( y * mesh->width ); /* same as pw[ 0 ] */
-
- /* set radix */
+
+ /* set radix */
r = ( x + y ) & 1;
-
- /* triangle 1 */
- tri[ 0 ] = &mesh->verts[ pw[ r + 0 ] ];
- tri[ 1 ] = &mesh->verts[ pw[ r + 1 ] ];
- tri[ 2 ] = &mesh->verts[ pw[ r + 2 ] ];
- n = AddSurfaceModelsToTriangle_r( ds, model, tri );
+
+ /* triangle 1 */
+ tri[ 0 ] = &mesh->verts[ pw[ r + 0 ] ];
+ tri[ 1 ] = &mesh->verts[ pw[ r + 1 ] ];
+ tri[ 2 ] = &mesh->verts[ pw[ r + 2 ] ];
+ n = AddSurfaceModelsToTriangle_r( ds, model, tri );
if ( n < 0 ) {
- return n;
+ return n;
}
- localNumSurfaceModels += n;
-
- /* triangle 2 */
- tri[ 0 ] = &mesh->verts[ pw[ r + 0 ] ];
- tri[ 1 ] = &mesh->verts[ pw[ r + 2 ] ];
- tri[ 2 ] = &mesh->verts[ pw[ r + 3 ] ];
- n = AddSurfaceModelsToTriangle_r( ds, model, tri );
+ localNumSurfaceModels += n;
+
+ /* triangle 2 */
+ tri[ 0 ] = &mesh->verts[ pw[ r + 0 ] ];
+ tri[ 1 ] = &mesh->verts[ pw[ r + 2 ] ];
+ tri[ 2 ] = &mesh->verts[ pw[ r + 3 ] ];
+ n = AddSurfaceModelsToTriangle_r( ds, model, tri );
if ( n < 0 ) {
- return n;
- }
- localNumSurfaceModels += n;
+ return n;
}
+ localNumSurfaceModels += n;
}
-
- /* free the subdivided mesh */
- FreeMesh( mesh );
- break;
-
- /* handle triangle surfaces */
- case SURFACE_TRIANGLES:
- case SURFACE_FORCED_META:
- case SURFACE_META:
- /* walk the triangle list */
+ }
+
+ /* free the subdivided mesh */
+ FreeMesh( mesh );
+ break;
+
+ /* handle triangle surfaces */
+ case SURFACE_TRIANGLES:
+ case SURFACE_FORCED_META:
+ case SURFACE_META:
+ /* walk the triangle list */
for ( i = 0; i < ds->numIndexes; i += 3 )
- {
- tri[ 0 ] = &ds->verts[ ds->indexes[ i ] ];
- tri[ 1 ] = &ds->verts[ ds->indexes[ i + 1 ] ];
- tri[ 2 ] = &ds->verts[ ds->indexes[ i + 2 ] ];
- n = AddSurfaceModelsToTriangle_r( ds, model, tri );
+ {
+ tri[ 0 ] = &ds->verts[ ds->indexes[ i ] ];
+ tri[ 1 ] = &ds->verts[ ds->indexes[ i + 1 ] ];
+ tri[ 2 ] = &ds->verts[ ds->indexes[ i + 2 ] ];
+ n = AddSurfaceModelsToTriangle_r( ds, model, tri );
if ( n < 0 ) {
- return n;
+ return n;
}
- localNumSurfaceModels += n;
- }
- break;
-
- /* no support for flares, foghull, etc */
- default:
- break;
+ localNumSurfaceModels += n;
+ }
+ break;
+
+ /* no support for flares, foghull, etc */
+ default:
+ break;
}
}
-
+
/* return count */
return localNumSurfaceModels;
}
*/
void AddEntitySurfaceModels( entity_t *e ){
- int i;
-
-
+ int i;
+
+
/* note it */
Sys_FPrintf( SYS_VRB, "--- AddEntitySurfaceModels ---\n" );
-
+
/* walk the surface list */
for ( i = e->firstDrawSurf; i < numMapDrawSurfs; i++ )
numSurfaceModels += AddSurfaceModels( &mapDrawSurfs[ i ] );
*/
static void VolumeColorMods( entity_t *e, mapDrawSurface_t *ds ){
- int i, j;
- float d;
- brush_t *b;
- plane_t *plane;
-
-
+ int i, j;
+ float d;
+ brush_t *b;
+ plane_t *plane;
+
+
/* early out */
if ( e->colorModBrushes == NULL ) {
return;
}
-
+
/* iterate brushes */
for ( b = e->colorModBrushes; b != NULL; b = b->nextColorModBrush )
{
if ( b->entityNum != 0 && b->entityNum != ds->entityNum ) {
continue;
}
-
+
/* test bbox */
if ( b->mins[ 0 ] > ds->maxs[ 0 ] || b->maxs[ 0 ] < ds->mins[ 0 ] ||
- b->mins[ 1 ] > ds->maxs[ 1 ] || b->maxs[ 1 ] < ds->mins[ 1 ] ||
+ b->mins[ 1 ] > ds->maxs[ 1 ] || b->maxs[ 1 ] < ds->mins[ 1 ] ||
b->mins[ 2 ] > ds->maxs[ 2 ] || b->maxs[ 2 ] < ds->mins[ 2 ] ) {
continue;
}
-
+
/* iterate verts */
for ( i = 0; i < ds->numVerts; i++ )
{
d = DotProduct( ds->verts[ i ].xyz, plane->normal ) - plane->dist;
if ( d > 1.0f ) {
break;
+ }
}
- }
-
+
/* apply colormods */
if ( j == b->numsides ) {
ColorMod( b->contentShader->colorMod, 1, &ds->verts[ i ] );
+ }
}
}
- }
}
*/
void FilterDrawsurfsIntoTree( entity_t *e, tree_t *tree ){
- int i, j;
- mapDrawSurface_t *ds;
- shaderInfo_t *si;
- vec3_t origin, mins, maxs;
- int refs;
- int numSurfs, numRefs, numSkyboxSurfaces;
- qboolean sb;
-
-
+ int i, j;
+ mapDrawSurface_t *ds;
+ shaderInfo_t *si;
+ vec3_t origin, mins, maxs;
+ int refs;
+ int numSurfs, numRefs, numSkyboxSurfaces;
+ qboolean sb;
+
+
/* note it */
Sys_FPrintf( SYS_VRB, "--- FilterDrawsurfsIntoTree ---\n" );
-
+
/* filter surfaces into the tree */
numSurfs = 0;
numRefs = 0;
if ( ds->numVerts == 0 && ds->type != SURFACE_FLARE && ds->type != SURFACE_SHADER ) {
continue;
}
-
+
/* get shader */
si = ds->shaderInfo;
/* refs initially zero */
refs = 0;
-
+
/* apply texture coordinate mods */
for ( j = 0; j < ds->numVerts; j++ )
TCMod( si->mod, ds->verts[ j ].st );
-
+
/* ydnar: apply shader colormod */
ColorMod( ds->shaderInfo->colorMod, ds->numVerts, ds->verts );
-
+
/* ydnar: apply brush colormod */
VolumeColorMods( e, ds );
-
+
/* ydnar: make fur surfaces */
if ( si->furNumLayers > 0 ) {
Fur( ds );
}
-
+
/* ydnar/sd: make foliage surfaces */
if ( si->foliage != NULL ) {
Foliage( ds );
}
-
+
/* create a flare surface if necessary */
if ( si->flareShader != NULL && si->flareShader[ 0 ] ) {
AddSurfaceFlare( ds, e->origin );
}
-
+
/* ydnar: don't emit nodraw surfaces (like nodraw fog) */
if ( ( si->compileFlags & C_NODRAW ) && ds->type != SURFACE_PATCH ) {
continue;
}
-
+
/* ydnar: bias the surface textures */
BiasSurfaceTextures( ds );
-
+
/* ydnar: globalizing of fog volume handling (eek a hack) */
if ( e != entities && si->noFog == qfalse ) {
/* find surface origin and offset by entity origin */
VectorAdd( ds->mins, ds->maxs, origin );
VectorScale( origin, 0.5f, origin );
VectorAdd( origin, e->origin, origin );
-
+
VectorAdd( ds->mins, e->origin, mins );
VectorAdd( ds->maxs, e->origin, maxs );
-
+
/* set the fog number for this surface */
- ds->fogNum = FogForBounds( mins, maxs, 1.0f ); //% FogForPoint( origin, 0.0f );
+ ds->fogNum = FogForBounds( mins, maxs, 1.0f ); //% FogForPoint( origin, 0.0f );
}
}
-
+
/* ydnar: remap shader */
if ( ds->shaderInfo->remapShader && ds->shaderInfo->remapShader[ 0 ] ) {
ds->shaderInfo = ShaderInfoForShader( ds->shaderInfo->remapShader );
}
-
+
/* ydnar: gs mods: handle the various types of surfaces */
switch ( ds->type )
{
- /* handle brush faces */
- case SURFACE_FACE:
- case SURFACE_DECAL:
+ /* handle brush faces */
+ case SURFACE_FACE:
+ case SURFACE_DECAL:
if ( refs == 0 ) {
- refs = FilterFaceIntoTree( ds, tree );
+ refs = FilterFaceIntoTree( ds, tree );
}
if ( refs > 0 ) {
- EmitFaceSurface( ds );
+ EmitFaceSurface( ds );
}
- break;
-
- /* handle patches */
- case SURFACE_PATCH:
+ break;
+
+ /* handle patches */
+ case SURFACE_PATCH:
if ( refs == 0 ) {
- refs = FilterPatchIntoTree( ds, tree );
+ refs = FilterPatchIntoTree( ds, tree );
}
if ( refs > 0 ) {
- EmitPatchSurface( e, ds );
+ EmitPatchSurface( e, ds );
}
- break;
-
- /* handle triangle surfaces */
- case SURFACE_TRIANGLES:
- case SURFACE_FORCED_META:
- case SURFACE_META:
- //% Sys_FPrintf( SYS_VRB, "Surface %4d: [%1d] %4d verts %s\n", numSurfs, ds->planar, ds->numVerts, si->shader );
+ break;
+
+ /* handle triangle surfaces */
+ case SURFACE_TRIANGLES:
+ case SURFACE_FORCED_META:
+ case SURFACE_META:
+ //% Sys_FPrintf( SYS_VRB, "Surface %4d: [%1d] %4d verts %s\n", numSurfs, ds->planar, ds->numVerts, si->shader );
if ( refs == 0 ) {
- refs = FilterTrianglesIntoTree( ds, tree );
+ refs = FilterTrianglesIntoTree( ds, tree );
}
if ( refs > 0 ) {
- EmitTriangleSurface( ds );
+ EmitTriangleSurface( ds );
}
- break;
-
- /* handle foliage surfaces (splash damage/wolf et) */
- case SURFACE_FOLIAGE:
- //% Sys_FPrintf( SYS_VRB, "Surface %4d: [%d] %4d verts %s\n", numSurfs, ds->numFoliageInstances, ds->numVerts, si->shader );
+ break;
+
+ /* handle foliage surfaces (splash damage/wolf et) */
+ case SURFACE_FOLIAGE:
+ //% Sys_FPrintf( SYS_VRB, "Surface %4d: [%d] %4d verts %s\n", numSurfs, ds->numFoliageInstances, ds->numVerts, si->shader );
if ( refs == 0 ) {
- refs = FilterFoliageIntoTree( ds, tree );
+ refs = FilterFoliageIntoTree( ds, tree );
}
if ( refs > 0 ) {
- EmitTriangleSurface( ds );
+ EmitTriangleSurface( ds );
}
- break;
-
- /* handle foghull surfaces */
- case SURFACE_FOGHULL:
+ break;
+
+ /* handle foghull surfaces */
+ case SURFACE_FOGHULL:
if ( refs == 0 ) {
- refs = AddReferenceToTree_r( ds, tree->headnode, qfalse );
+ refs = AddReferenceToTree_r( ds, tree->headnode, qfalse );
}
if ( refs > 0 ) {
- EmitTriangleSurface( ds );
+ EmitTriangleSurface( ds );
}
- break;
-
- /* handle flares */
- case SURFACE_FLARE:
+ break;
+
+ /* handle flares */
+ case SURFACE_FLARE:
if ( refs == 0 ) {
- refs = FilterFlareSurfIntoTree( ds, tree );
+ refs = FilterFlareSurfIntoTree( ds, tree );
}
if ( refs > 0 ) {
- EmitFlareSurface( ds );
- }
- break;
-
- /* handle shader-only surfaces */
- case SURFACE_SHADER:
- refs = 1;
EmitFlareSurface( ds );
- break;
-
- /* no references */
- default:
- refs = 0;
- break;
+ }
+ break;
+
+ /* handle shader-only surfaces */
+ case SURFACE_SHADER:
+ refs = 1;
+ EmitFlareSurface( ds );
+ break;
+
+ /* no references */
+ default:
+ refs = 0;
+ break;
}
/* maybe surface got marked as skybox again */
if ( sb ) {
ds->skybox = qfalse;
}
-
+
/* tot up the references */
if ( refs > 0 ) {
/* tot up counts */
numSurfs++;
numRefs += refs;
-
+
/* emit extra surface data */
SetSurfaceExtra( ds, numBSPDrawSurfaces - 1 );
//% Sys_FPrintf( SYS_VRB, "%d verts %d indexes\n", ds->numVerts, ds->numIndexes );
-
+
/* one last sanity check */
{
- bspDrawSurface_t *out;
+ bspDrawSurface_t *out;
out = &bspDrawSurfaces[ numBSPDrawSurfaces - 1 ];
if ( out->numVerts == 3 && out->numIndexes > 3 ) {
Sys_Printf( "\nWARNING: Potentially bad %s surface (%d: %d, %d)\n %s\n",
- surfaceTypes[ ds->type ],
- numBSPDrawSurfaces - 1, out->numVerts, out->numIndexes, si->shader );
+ surfaceTypes[ ds->type ],
+ numBSPDrawSurfaces - 1, out->numVerts, out->numIndexes, si->shader );
}
}
-
+
/* ydnar: handle skybox surfaces */
if ( ds->skybox ) {
MakeSkyboxSurface( ds );
}
}
}
-
+
/* emit some statistics */
Sys_FPrintf( SYS_VRB, "%9d references\n", numRefs );
Sys_FPrintf( SYS_VRB, "%9d (%d) emitted drawsurfs\n", numSurfs, numBSPDrawSurfaces );
Sys_FPrintf( SYS_VRB, "%9d skybox surfaces generated\n", numSkyboxSurfaces );
for ( i = 0; i < NUM_SURFACE_TYPES; i++ )
Sys_FPrintf( SYS_VRB, "%9d %s surfaces\n", numSurfacesByType[ i ], surfaceTypes[ i ] );
-
+
Sys_FPrintf( SYS_VRB, "%9d redundant indexes supressed, saving %d Kbytes\n", numRedundantIndexes, ( numRedundantIndexes * 4 / 1024 ) );
}
-#define MAX_FOLIAGE_INSTANCES 8192
+#define MAX_FOLIAGE_INSTANCES 8192
-static int numFoliageInstances;
-static foliageInstance_t foliageInstances[ MAX_FOLIAGE_INSTANCES ];
+static int numFoliageInstances;
+static foliageInstance_t foliageInstances[ MAX_FOLIAGE_INSTANCES ];
*/
static void SubdivideFoliageTriangle_r( mapDrawSurface_t *ds, foliage_t *foliage, bspDrawVert_t **tri ){
- bspDrawVert_t mid, *tri2[ 3 ];
- int max;
-
-
+ bspDrawVert_t mid, *tri2[ 3 ];
+ int max;
+
+
/* limit test */
if ( numFoliageInstances >= MAX_FOLIAGE_INSTANCES ) {
return;
}
-
+
/* plane test */
{
- vec4_t plane;
-
-
+ vec4_t plane;
+
+
/* make a plane */
if ( !PlaneFromPoints( plane, tri[ 0 ]->xyz, tri[ 1 ]->xyz, tri[ 2 ]->xyz ) ) {
return;
}
-
+
/* if normal is too far off vertical, then don't place an instance */
if ( plane[ 2 ] < 0.5f ) {
return;
+ }
}
- }
-
+
/* subdivide calc */
{
- int i;
- float *a, *b, dx, dy, dz, dist, maxDist;
- foliageInstance_t *fi;
-
-
+ int i;
+ float *a, *b, dx, dy, dz, dist, maxDist;
+ foliageInstance_t *fi;
+
+
/* get instance */
fi = &foliageInstances[ numFoliageInstances ];
-
+
/* find the longest edge and split it */
max = -1;
maxDist = 0.0f;
/* get verts */
a = tri[ i ]->xyz;
b = tri[ ( i + 1 ) % 3 ]->xyz;
-
+
/* get dists */
dx = a[ 0 ] - b[ 0 ];
dy = a[ 1 ] - b[ 1 ];
dz = a[ 2 ] - b[ 2 ];
dist = ( dx * dx ) + ( dy * dy ) + ( dz * dz );
-
+
/* longer? */
if ( dist > maxDist ) {
maxDist = dist;
max = i;
}
-
+
/* add to centroid */
VectorAdd( fi->xyz, tri[ i ]->xyz, fi->xyz );
VectorAdd( fi->normal, tri[ i ]->normal, fi->normal );
}
-
+
/* is the triangle small enough? */
if ( maxDist <= ( foliage->density * foliage->density ) ) {
- float alpha, odds, r;
-
-
+ float alpha, odds, r;
+
+
/* get average alpha */
if ( foliage->inverseAlpha == 2 ) {
alpha = 1.0f;
}
if ( alpha < 0.75f ) {
return;
+ }
}
- }
-
+
/* roll the dice */
odds = foliage->odds * alpha;
r = Random();
if ( r > odds ) {
return;
}
-
+
/* scale centroid */
VectorScale( fi->xyz, 0.33333333f, fi->xyz );
if ( VectorNormalize( fi->normal, fi->normal ) == 0.0f ) {
return;
}
-
+
/* add to count and return */
numFoliageInstances++;
return;
}
}
-
+
/* split the longest edge and map it */
LerpDrawVert( tri[ max ], tri[ ( max + 1 ) % 3 ], &mid );
-
+
/* recurse to first triangle */
VectorCopy( tri, tri2 );
tri2[ max ] = ∣
SubdivideFoliageTriangle_r( ds, foliage, tri2 );
-
+
/* recurse to second triangle */
VectorCopy( tri, tri2 );
tri2[ ( max + 1 ) % 3 ] = ∣
*/
void Foliage( mapDrawSurface_t *src ){
- int i, j, k, x, y, pw[ 5 ], r, oldNumMapDrawSurfs;
- mapDrawSurface_t *ds;
- shaderInfo_t *si;
- foliage_t *foliage;
- mesh_t srcMesh, *subdivided, *mesh;
- bspDrawVert_t *verts, *dv[ 3 ], *fi;
- vec3_t scale;
- m4x4_t transform;
-
-
+ int i, j, k, x, y, pw[ 5 ], r, oldNumMapDrawSurfs;
+ mapDrawSurface_t *ds;
+ shaderInfo_t *si;
+ foliage_t *foliage;
+ mesh_t srcMesh, *subdivided, *mesh;
+ bspDrawVert_t *verts, *dv[ 3 ], *fi;
+ vec3_t scale;
+ m4x4_t transform;
+
+
/* get shader */
si = src->shaderInfo;
if ( si == NULL || si->foliage == NULL ) {
return;
}
-
+
/* do every foliage */
for ( foliage = si->foliage; foliage != NULL; foliage = foliage->next )
{
/* zero out */
numFoliageInstances = 0;
-
+
/* map the surface onto the lightmap origin/cluster/normal buffers */
switch ( src->type )
{
- case SURFACE_META:
- case SURFACE_FORCED_META:
- case SURFACE_TRIANGLES:
- /* get verts */
- verts = src->verts;
-
- /* map the triangles */
+ case SURFACE_META:
+ case SURFACE_FORCED_META:
+ case SURFACE_TRIANGLES:
+ /* get verts */
+ verts = src->verts;
+
+ /* map the triangles */
for ( i = 0; i < src->numIndexes; i += 3 )
- {
- dv[ 0 ] = &verts[ src->indexes[ i ] ];
- dv[ 1 ] = &verts[ src->indexes[ i + 1 ] ];
- dv[ 2 ] = &verts[ src->indexes[ i + 2 ] ];
- SubdivideFoliageTriangle_r( src, foliage, dv );
- }
- break;
-
- case SURFACE_PATCH:
- /* make a mesh from the drawsurf */
- srcMesh.width = src->patchWidth;
- srcMesh.height = src->patchHeight;
- srcMesh.verts = src->verts;
- subdivided = SubdivideMesh( srcMesh, 8, 512 );
-
- /* fit it to the curve and remove colinear verts on rows/columns */
- PutMeshOnCurve( *subdivided );
- mesh = RemoveLinearMeshColumnsRows( subdivided );
- FreeMesh( subdivided );
-
- /* get verts */
- verts = mesh->verts;
-
- /* map the mesh quads */
+ {
+ dv[ 0 ] = &verts[ src->indexes[ i ] ];
+ dv[ 1 ] = &verts[ src->indexes[ i + 1 ] ];
+ dv[ 2 ] = &verts[ src->indexes[ i + 2 ] ];
+ SubdivideFoliageTriangle_r( src, foliage, dv );
+ }
+ break;
+
+ case SURFACE_PATCH:
+ /* make a mesh from the drawsurf */
+ srcMesh.width = src->patchWidth;
+ srcMesh.height = src->patchHeight;
+ srcMesh.verts = src->verts;
+ subdivided = SubdivideMesh( srcMesh, 8, 512 );
+
+ /* fit it to the curve and remove colinear verts on rows/columns */
+ PutMeshOnCurve( *subdivided );
+ mesh = RemoveLinearMeshColumnsRows( subdivided );
+ FreeMesh( subdivided );
+
+ /* get verts */
+ verts = mesh->verts;
+
+ /* map the mesh quads */
for ( y = 0; y < ( mesh->height - 1 ); y++ )
- {
+ {
for ( x = 0; x < ( mesh->width - 1 ); x++ )
- {
- /* set indexes */
+ {
+ /* set indexes */
pw[ 0 ] = x + ( y * mesh->width );
pw[ 1 ] = x + ( ( y + 1 ) * mesh->width );
pw[ 2 ] = x + 1 + ( ( y + 1 ) * mesh->width );
pw[ 3 ] = x + 1 + ( y * mesh->width );
pw[ 4 ] = x + ( y * mesh->width ); /* same as pw[ 0 ] */
-
- /* set radix */
+
+ /* set radix */
r = ( x + y ) & 1;
-
- /* get drawverts and map first triangle */
- dv[ 0 ] = &verts[ pw[ r + 0 ] ];
- dv[ 1 ] = &verts[ pw[ r + 1 ] ];
- dv[ 2 ] = &verts[ pw[ r + 2 ] ];
- SubdivideFoliageTriangle_r( src, foliage, dv );
-
- /* get drawverts and map second triangle */
- dv[ 0 ] = &verts[ pw[ r + 0 ] ];
- dv[ 1 ] = &verts[ pw[ r + 2 ] ];
- dv[ 2 ] = &verts[ pw[ r + 3 ] ];
- SubdivideFoliageTriangle_r( src, foliage, dv );
- }
+
+ /* get drawverts and map first triangle */
+ dv[ 0 ] = &verts[ pw[ r + 0 ] ];
+ dv[ 1 ] = &verts[ pw[ r + 1 ] ];
+ dv[ 2 ] = &verts[ pw[ r + 2 ] ];
+ SubdivideFoliageTriangle_r( src, foliage, dv );
+
+ /* get drawverts and map second triangle */
+ dv[ 0 ] = &verts[ pw[ r + 0 ] ];
+ dv[ 1 ] = &verts[ pw[ r + 2 ] ];
+ dv[ 2 ] = &verts[ pw[ r + 3 ] ];
+ SubdivideFoliageTriangle_r( src, foliage, dv );
}
-
- /* free the mesh */
- FreeMesh( mesh );
- break;
-
- default:
- break;
+ }
+
+ /* free the mesh */
+ FreeMesh( mesh );
+ break;
+
+ default:
+ break;
}
-
+
/* any origins? */
if ( numFoliageInstances < 1 ) {
continue;
}
-
+
/* remember surface count */
oldNumMapDrawSurfs = numMapDrawSurfs;
-
+
/* set transform matrix */
VectorSet( scale, foliage->scale, foliage->scale, foliage->scale );
m4x4_scale_for_vec3( transform, scale );
-
+
/* add the model to the bsp */
InsertModel( foliage->model, 0, 0, transform, NULL, NULL, src->entityNum, src->castShadows, src->recvShadows, 0, src->lightmapScale, 0, 0, src->colormod );
-
+
/* walk each new surface */
for ( i = oldNumMapDrawSurfs; i < numMapDrawSurfs; i++ )
{
/* get surface */
ds = &mapDrawSurfs[ i ];
-
+
/* set up */
ds->type = SURFACE_FOLIAGE;
ds->numFoliageInstances = numFoliageInstances;
-
+
/* a wee hack */
ds->patchWidth = ds->numFoliageInstances;
ds->patchHeight = ds->numVerts;
-
+
/* set fog to be same as source surface */
ds->fogNum = src->fogNum;
-
+
/* add a drawvert for every instance */
verts = safe_malloc( ( ds->numVerts + ds->numFoliageInstances ) * sizeof( *verts ) );
memset( verts, 0, ( ds->numVerts + ds->numFoliageInstances ) * sizeof( *verts ) );
memcpy( verts, ds->verts, ds->numVerts * sizeof( *verts ) );
free( ds->verts );
ds->verts = verts;
-
+
/* copy the verts */
for ( j = 0; j < ds->numFoliageInstances; j++ )
{
fi->color[ k ][ 3 ] = 255;
}
}
-
+
/* increment */
ds->numVerts += ds->numFoliageInstances;
}
projects / xonotic / netradiant.git / commitdiff