quick/netradiant-custom
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

minor tweaks

Browse Source
This commit is contained in:
Garux 2021-10-26 17:26:35 +03:00
parent d812cbd4d4
commit 977781a621
16 changed files with 430 additions and 758 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
tools/quake3/common/inout.cpp
View File

@ -194,7 +194,6 @@ void xml_Winding( const char *msg, const Vector3 p[], int numpoints, bool die ){
char buf[WINDING_BUFSIZE];
char smlbuf[128];
char level[2];
int i;
node = xmlNewNode( NULL, (const xmlChar*)"windingmsg" );
xmlNodeAddContent( node, (const xmlChar*)msg );
@ -203,11 +202,11 @@ void xml_Winding( const char *msg, const Vector3 p[], int numpoints, bool die ){
xmlSetProp( node, (const xmlChar*)"level", (const xmlChar *)level );
// a 'winding' node
sprintf( buf, "%i ", numpoints );
for ( i = 0; i < numpoints; i++ )
for ( int i = 0; i < numpoints; ++i )
{
sprintf( smlbuf, "(%g %g %g)", p[i][0], p[i][1], p[i][2] );
// don't overflow
if ( strlen( buf ) + strlen( smlbuf ) > WINDING_BUFSIZE ) {
if ( strlen( buf ) + strlen( smlbuf ) >= WINDING_BUFSIZE ) {
break;
}
strcat( buf, smlbuf );

24
tools/quake3/common/scriplib.cpp
View File

@ -315,11 +315,9 @@ void MatchToken( const char *match ) {
template<typename T>
void Parse1DMatrix( int x, T *m ) {
int i;
MatchToken( "(" );
for ( i = 0 ; i < x ; i++ ) {
for ( int i = 0; i < x; ++i ) {
GetToken( false );
m[i] = atof( token );
}
@ -330,11 +328,9 @@ template void Parse1DMatrix<float>( int x, float *m );
template void Parse1DMatrix<double>( int x, double *m );
void Parse2DMatrix( int y, int x, float *m ) {
int i;
MatchToken( "(" );
for ( i = 0 ; i < y ; i++ ) {
for ( int i = 0; i < y; ++i ) {
Parse1DMatrix( x, m + i * x );
}
@ -342,11 +338,9 @@ void Parse2DMatrix( int y, int x, float *m ) {
}
void Parse3DMatrix( int z, int y, int x, float *m ) {
int i;
MatchToken( "(" );
for ( i = 0 ; i < z ; i++ ) {
for ( int i = 0; i < z; ++i ) {
Parse2DMatrix( y, x, m + i * x * y );
}
@ -355,10 +349,8 @@ void Parse3DMatrix( int z, int y, int x, float *m ) {
void Write1DMatrix( FILE *f, int x, float *m ) {
int i;
fprintf( f, "( " );
for ( i = 0 ; i < x ; i++ ) {
for ( int i = 0; i < x; ++i ) {
if ( m[i] == (int)m[i] ) {
fprintf( f, "%i ", (int)m[i] );
}
@ -370,10 +362,8 @@ void Write1DMatrix( FILE *f, int x, float *m ) {
}
void Write2DMatrix( FILE *f, int y, int x, float *m ) {
int i;
fprintf( f, "( " );
for ( i = 0 ; i < y ; i++ ) {
for ( int i = 0; i < y; ++i ) {
Write1DMatrix( f, x, m + i * x );
fprintf( f, " " );
}
@ -382,10 +372,8 @@ void Write2DMatrix( FILE *f, int y, int x, float *m ) {
void Write3DMatrix( FILE *f, int z, int y, int x, float *m ) {
int i;
fprintf( f, "(\n" );
for ( i = 0 ; i < z ; i++ ) {
for ( int i = 0; i < z; ++i ) {
Write2DMatrix( f, y, x, m + i * ( x * y ) );
}
fprintf( f, ")\n" );

4
tools/quake3/common/stringfixedsize.h
View File

@ -42,8 +42,8 @@ public:
}
std::size_t write( const char* buffer, std::size_t length ) override {
if( m_length + length < SIZE ){
for( auto i = length; i != 0; --i )
m_string[m_length++] = *buffer++;
std::copy_n( buffer, length, m_string + m_length );
m_length += length;
strClear( &m_string[m_length] );
}
else{

27
tools/quake3/q3map2/map.cpp
View File

@ -300,10 +300,10 @@ void SnapPlaneImproved( Plane3f& plane, int numPoints, const Vector3 *points ){
if ( SnapNormal( plane.normal() ) ) {
if ( numPoints > 0 ) {
// Adjust the dist so that the provided points don't drift away.
Vector3 center( 0 );
for ( int i = 0; i < numPoints; i++ )
DoubleVector3 center( 0 );
for ( const Vector3& point : Span( points, numPoints ) )
{
center += points[i];
center += point;
}
center /= numPoints;
plane.dist() = vector3_dot( plane.normal(), center );
@ -1281,8 +1281,8 @@ void AdjustBrushesForOrigin( entity_t *ent ){
/* walk patch list */
for ( parseMesh_t *p = ent->patches; p != NULL; p = p->next )
{
for ( int i = 0; i < ( p->mesh.width * p->mesh.height ); i++ )
p->mesh.verts[ i ].xyz -= ent->originbrush_origin;
for ( bspDrawVert_t& vert : Span( p->mesh.verts, p->mesh.width * p->mesh.height ) )
vert.xyz -= ent->originbrush_origin;
}
}
@ -1330,11 +1330,9 @@ void SetEntityBounds( entity_t *e ){
*/
void LoadEntityIndexMap( entity_t *e ){
int i, size, numLayers, w, h;
int numLayers, w, h;
const char *indexMapFilename, *shader;
byte *pixels;
unsigned int *pixels32;
indexMap_t *im;
/* this only works with bmodel ents */
@ -1371,12 +1369,13 @@ void LoadEntityIndexMap( entity_t *e ){
/* handle tga image */
if ( path_extension_is( indexMapFilename, "tga" ) ) {
/* load it */
unsigned int *pixels32;
Load32BitImage( indexMapFilename, &pixels32, &w, &h );
/* convert to bytes */
size = w * h;
const int size = w * h;
pixels = safe_malloc( size );
for ( i = 0; i < size; i++ )
for ( int i = 0; i < size; i++ )
{
pixels[ i ] = ( ( pixels32[ i ] & 0xFF ) * numLayers ) / 256;
if ( pixels[ i ] >= numLayers ) {
@ -1396,8 +1395,8 @@ void LoadEntityIndexMap( entity_t *e ){
//% Sys_Printf( "-------------------------------" );
/* fix up out-of-range values */
size = w * h;
for ( i = 0; i < size; i++ )
const int size = w * h;
for ( int i = 0; i < size; i++ )
{
if ( pixels[ i ] >= numLayers ) {
pixels[ i ] = numLayers - 1;
@ -1422,7 +1421,7 @@ void LoadEntityIndexMap( entity_t *e ){
}
/* create a new index map */
im = safe_malloc( sizeof( *im ) );
indexMap_t *im = safe_malloc( sizeof( *im ) );
new ( im ) indexMap_t{}; // placement new
/* set it up */
@ -1437,7 +1436,7 @@ void LoadEntityIndexMap( entity_t *e ){
if( mapEnt->read_keyvalue( offset, "_offsets", "offsets" ) ){
/* value is a space-separated set of numbers */
/* get each value */
for ( i = 0; i < 256 && !strEmpty( offset ); i++ )
for ( int i = 0; i < 256 && !strEmpty( offset ); ++i )
{
const char *space = strchr( offset, ' ' );
if ( space == NULL ) {

53
tools/quake3/q3map2/mesh.cpp
View File

@ -94,10 +94,8 @@ void FreeMesh( mesh_t *m ) {
}
void PrintMesh( mesh_t *m ) {
int i, j;
for ( i = 0 ; i < m->height ; i++ ) {
for ( j = 0 ; j < m->width ; j++ ) {
for ( int i = 0; i < m->height; ++i ) {
for ( int j = 0; j < m->width; ++j ) {
Sys_Printf( "(%5.2f %5.2f %5.2f) "
, m->verts[i * m->width + j].xyz[0]
, m->verts[i * m->width + j].xyz[1]
@ -109,14 +107,11 @@ void PrintMesh( mesh_t *m ) {
mesh_t *CopyMesh( mesh_t *mesh ) {
mesh_t *out;
int size;
out = safe_malloc( sizeof( *out ) );
mesh_t *out = safe_malloc( sizeof( *out ) );
out->width = mesh->width;
out->height = mesh->height;
size = out->width * out->height * sizeof( *out->verts );
const int size = out->width * out->height * sizeof( *out->verts );
out->verts = safe_malloc( size );
memcpy( out->verts, mesh->verts, size );
@ -130,16 +125,13 @@ mesh_t *CopyMesh( mesh_t *mesh ) {
*/
mesh_t *TransposeMesh( mesh_t *in ) {
int w, h;
mesh_t *out;
out = safe_malloc( sizeof( *out ) );
mesh_t *out = safe_malloc( sizeof( *out ) );
out->width = in->height;
out->height = in->width;
out->verts = safe_malloc( out->width * out->height * sizeof( bspDrawVert_t ) );
for ( h = 0 ; h < in->height ; h++ ) {
for ( w = 0 ; w < in->width ; w++ ) {
for ( int h = 0; h < in->height; ++h ) {
for ( int w = 0; w < in->width; ++w ) {
out->verts[ w * in->height + h ] = in->verts[ h * in->width + w ];
}
}
@ -150,14 +142,12 @@ mesh_t *TransposeMesh( mesh_t *in ) {
}
void InvertMesh( mesh_t *in ) {
int w, h;
bspDrawVert_t temp;
for ( h = 0 ; h < in->height ; h++ ) {
for ( w = 0 ; w < in->width / 2 ; w++ ) {
temp = in->verts[ h * in->width + w ];
in->verts[ h * in->width + w ] = in->verts[ h * in->width + in->width - 1 - w ];
in->verts[ h * in->width + in->width - 1 - w ] = temp;
for ( int h = 0; h < in->height; ++h ) {
for ( int w = 0; w < in->width / 2; ++w ) {
std::swap(
in->verts[ h * in->width + w ],
in->verts[ h * in->width + in->width - 1 - w ]
);
}
}
}
@ -275,12 +265,9 @@ void MakeMeshNormals( mesh_t in ){
*/
void PutMeshOnCurve( mesh_t in ) {
int i, j, m;
// put all the aproximating points on the curve
for ( i = 0 ; i < in.width ; i++ ) {
for ( j = 1 ; j < in.height ; j += 2 ) {
for ( int i = 0; i < in.width; ++i ) {
for ( int j = 1; j < in.height; j += 2 ) {
const int idx = j * in.width + i;
const int idprev = ( j + 1 ) * in.width + i;
const int idnext = ( j - 1 ) * in.width + i;
@ -289,7 +276,7 @@ void PutMeshOnCurve( mesh_t in ) {
/* ydnar: interpolating st coords */
in.verts[idx].st = vector2_mid( vector2_mid( in.verts[idx].st, in.verts[idprev].st ),
vector2_mid( in.verts[idx].st, in.verts[idnext].st ) );
for ( m = 0; m < MAX_LIGHTMAPS; m++ )
for ( int m = 0; m < MAX_LIGHTMAPS; ++m )
{
in.verts[idx].lightmap[ m ] = vector2_mid( vector2_mid( in.verts[idx].lightmap[ m ], in.verts[idprev].lightmap[ m ] ),
vector2_mid( in.verts[idx].lightmap[ m ], in.verts[idnext].lightmap[ m ] ) );
@ -297,15 +284,15 @@ void PutMeshOnCurve( mesh_t in ) {
}
}
for ( j = 0 ; j < in.height ; j++ ) {
for ( i = 1 ; i < in.width ; i += 2 ) {
for ( int j = 0; j < in.height; ++j ) {
for ( int i = 1; i < in.width; i += 2 ) {
const int idx = j * in.width + i;
in.verts[idx].xyz = vector3_mid( vector3_mid( in.verts[idx].xyz, in.verts[idx + 1].xyz ),
vector3_mid( in.verts[idx].xyz, in.verts[idx - 1].xyz ) );
/* ydnar: interpolating st coords */
in.verts[idx].st = vector2_mid( vector2_mid( in.verts[idx].st, in.verts[idx + 1].st ),
vector2_mid( in.verts[idx].st, in.verts[idx - 1].st ) );
for ( m = 0; m < MAX_LIGHTMAPS; m++ )
for ( int m = 0; m < MAX_LIGHTMAPS; ++m )
{
in.verts[idx].lightmap[ m ] = vector2_mid( vector2_mid( in.verts[idx].lightmap[ m ], in.verts[idx + 1].lightmap[ m ] ),
vector2_mid( in.verts[idx].lightmap[ m ], in.verts[idx - 1].lightmap[ m ] ) );
@ -538,7 +525,7 @@ mesh_t *SubdivideMesh2( mesh_t in, int iterations ){
LerpDrawVert( &expand[ j + 1 ][ i ], &expand[ j + 2 ][ i ], &next );
LerpDrawVert( &prev, &next, &mid );
for ( k = out.height - 1; k > j + 3; k-- )
for ( k = out.height - 1; k > j + 3; k-- )
expand[ k ][ i ] = expand[ k - 2 ][ i ];
expand[ j + 1 ][ i ] = prev;
expand[ j + 2 ][ i ] = mid;

6
tools/quake3/q3map2/minimap.cpp
View File

@ -51,13 +51,11 @@ struct minimap_t
static minimap_t minimap;
bool BrushIntersectionWithLine( const bspBrush_t& brush, const Vector3& start, const Vector3& dir, float *t_in, float *t_out ){
int i;
bool in = false, out = false;
bspBrushSide_t *sides = &bspBrushSides[brush.firstSide];
for ( i = 0; i < brush.numSides; ++i )
for ( const bspBrushSide_t& side : Span( &bspBrushSides[brush.firstSide], brush.numSides ) )
{
const bspPlane_t& p = bspPlanes[sides[i].planeNum];
const bspPlane_t& p = bspPlanes[side.planeNum];
float sn = vector3_dot( start, p.normal() );
float dn = vector3_dot( dir, p.normal() );
if ( dn == 0 ) {

6
tools/quake3/q3map2/model.cpp
View File

@ -238,8 +238,7 @@ struct AssModel
}
void forEachFace( std::function<void( const Vector3 ( &xyz )[3], const Vector2 ( &st )[3])> visitor ) const override {
for ( size_t t = 0; t < m_mesh->mNumFaces; ++t ){
const aiFace& face = m_mesh->mFaces[t];
for ( const aiFace& face : Span( m_mesh->mFaces, m_mesh->mNumFaces ) ){
// if( face.mNumIndices == 3 )
Vector3 xyz[3];
Vector2 st[3];
@ -1236,8 +1235,7 @@ void InsertModel( const char *name, int skin, int frame, const Matrix4& transfor
/* copy indexes */
{
size_t idCopied = 0;
for ( size_t t = 0; t < mesh->mNumFaces; ++t ){
const aiFace& face = mesh->mFaces[t];
for ( const aiFace& face : Span( mesh->mFaces, mesh->mNumFaces ) ){
// if( face.mNumIndices == 3 )
for ( size_t i = 0; i < 3; i++ ){
ds->indexes[idCopied++] = face.mIndices[i];

32
tools/quake3/q3map2/patch.cpp
View File

@ -196,8 +196,6 @@ static void ExpandMaxIterations( int *maxIterations, int maxError, const Vector3
void ParsePatch( bool onlyLights ){
float info[ 5 ];
int i, j, k;
parseMesh_t *pm;
mesh_t m;
bspDrawVert_t *verts;
bool degenerate;
@ -213,24 +211,25 @@ void ParsePatch( bool onlyLights ){
Parse1DMatrix( 5, info );
m.width = info[0];
m.height = info[1];
m.verts = verts = safe_malloc( m.width * m.height * sizeof( m.verts[0] ) );
const int size = ( m.width * m.height );
m.verts = verts = safe_malloc( size * sizeof( m.verts[0] ) );
if ( m.width < 0 || m.width > MAX_PATCH_SIZE || m.height < 0 || m.height > MAX_PATCH_SIZE ) {
Error( "ParsePatch: bad size" );
}
MatchToken( "(" );
for ( j = 0; j < m.width ; j++ )
for ( int j = 0; j < m.width; ++j )
{
MatchToken( "(" );
for ( i = 0; i < m.height ; i++ )
for ( int i = 0; i < m.height; ++i )
{
Parse1DMatrix( 5, verts[ i * m.width + j ].xyz.data() );
/* ydnar: fix colors */
for ( k = 0; k < MAX_LIGHTMAPS; k++ )
for ( auto& color : verts[ i * m.width + j ].color )
{
verts[ i * m.width + j ].color[ k ].set( 255 );
color.set( 255 );
}
}
MatchToken( ")" );
@ -257,12 +256,11 @@ void ParsePatch( bool onlyLights ){
/* ydnar: delete and warn about degenerate patches */
j = ( m.width * m.height );
Vector4 delta( 0, 0, 0, 0 );
degenerate = true;
/* find first valid vector */
for ( i = 1; i < j && delta[ 3 ] == 0; i++ )
for ( int i = 1; i < size && delta[ 3 ] == 0; ++i )
{
delta.vec3() = m.verts[ 0 ].xyz - m.verts[ i ].xyz;
delta[ 3 ] = VectorNormalize( delta.vec3() );
@ -275,7 +273,7 @@ void ParsePatch( bool onlyLights ){
else
{
/* if all vectors match this or are zero, then this is a degenerate patch */
for ( i = 1; i < j && degenerate; i++ )
for ( int i = 1; i < size && degenerate; ++i )
{
Vector4 delta2( m.verts[ 0 ].xyz - m.verts[ i ].xyz, 0 );
delta2[ 3 ] = VectorNormalize( delta2.vec3() );
@ -302,9 +300,9 @@ void ParsePatch( bool onlyLights ){
/* find longest curve on the mesh */
longestCurve = 0.0f;
maxIterations = 0;
for ( j = 0; j + 2 < m.width; j += 2 )
for ( int j = 0; j + 2 < m.width; j += 2 )
{
for ( i = 0; i + 2 < m.height; i += 2 )
for ( int i = 0; i + 2 < m.height; i += 2 )
{
ExpandLongestCurve( &longestCurve, verts[ i * m.width + j ].xyz, verts[ i * m.width + ( j + 1 ) ].xyz, verts[ i * m.width + ( j + 2 ) ].xyz ); /* row */
ExpandLongestCurve( &longestCurve, verts[ i * m.width + j ].xyz, verts[ ( i + 1 ) * m.width + j ].xyz, verts[ ( i + 2 ) * m.width + j ].xyz ); /* col */
@ -314,7 +312,7 @@ void ParsePatch( bool onlyLights ){
}
/* allocate patch mesh */
pm = safe_calloc( sizeof( *pm ) );
parseMesh_t *pm = safe_calloc( sizeof( *pm ) );
/* ydnar: add entity/brush numbering */
pm->entityNum = mapEnt->mapEntityNum;
@ -343,10 +341,6 @@ void ParsePatch( bool onlyLights ){
*/
static void GrowGroup_r( parseMesh_t *pm, int patchNum, int patchCount, parseMesh_t **meshes, byte *bordering, byte *group ){
int i;
const byte *row;
/* early out check */
if ( group[ patchNum ] ) {
return;
@ -355,14 +349,14 @@ static void GrowGroup_r( parseMesh_t *pm, int patchNum, int patchCount, parseMes
/* set it */
group[ patchNum ] = 1;
row = bordering + patchNum * patchCount;
const byte *row = bordering + patchNum * patchCount;
/* check maximums */
value_maximize( pm->longestCurve, meshes[ patchNum ]->longestCurve );
value_maximize( pm->maxIterations, meshes[ patchNum ]->maxIterations );
/* walk other patches */
for ( i = 0; i < patchCount; i++ )
for ( int i = 0; i < patchCount; ++i )
{
if ( row[ i ] ) {
GrowGroup_r( pm, i, patchCount, meshes, bordering, group );

1
tools/quake3/q3map2/q3map2.h
View File

@ -1741,7 +1741,6 @@ void MakeEntityDecals( entity_t *e );
std::array<Vector3, 2> TextureAxisFromPlane( const plane_t& plane );
/* vis.c */
fixedWinding_t *NewFixedWinding( int points );
int VisMain( Args& args );
/* visflow.c */

102
tools/quake3/q3map2/shaders.cpp
View File

@ -40,13 +40,6 @@
*/
void ColorMod( colorMod_t *cm, int numVerts, bspDrawVert_t *drawVerts ){
int i, j;
float c;
Color4f mult, add;
bspDrawVert_t *dv;
colorMod_t *cm2;
/* dummy check */
if ( cm == NULL || numVerts < 1 || drawVerts == NULL ) {
return;
@ -54,83 +47,81 @@ void ColorMod( colorMod_t *cm, int numVerts, bspDrawVert_t *drawVerts ){
/* walk vertex list */
for ( i = 0; i < numVerts; i++ )
for ( bspDrawVert_t& dv : Span( drawVerts, numVerts ) )
{
/* get vertex */
dv = &drawVerts[ i ];
/* walk colorMod list */
for ( cm2 = cm; cm2 != NULL; cm2 = cm2->next )
for ( ; cm != NULL; cm = cm->next )
{
float c;
/* default */
mult.set( 1 );
add.set( 0 );
Color4f mult( 1, 1, 1, 1 );
Color4f add( 0, 0, 0, 0 );
const Vector3 cm2_vec3 = vector3_from_array( cm2->data );
const Vector3 cm_vec3 = vector3_from_array( cm->data );
/* switch on type */
switch ( cm2->type )
switch ( cm->type )
{
case EColorMod::ColorSet:
mult.rgb().set( 0 );
add.rgb() = cm2_vec3 * 255.0f;
add.rgb() = cm_vec3 * 255.0f;
break;
case EColorMod::AlphaSet:
mult.alpha() = 0.0f;
add.alpha() = cm2->data[ 0 ] * 255.0f;
add.alpha() = cm->data[ 0 ] * 255.0f;
break;
case EColorMod::ColorScale:
mult.rgb() = cm2_vec3;
mult.rgb() = cm_vec3;
break;
case EColorMod::AlphaScale:
mult.alpha() = cm2->data[ 0 ];
mult.alpha() = cm->data[ 0 ];
break;
case EColorMod::ColorDotProduct:
c = vector3_dot( dv->normal, cm2_vec3 );
c = vector3_dot( dv.normal, cm_vec3 );
mult.rgb().set( c );
break;
case EColorMod::ColorDotProductScale:
c = vector3_dot( dv->normal, cm2_vec3 );
c = ( c - cm2->data[3] ) / ( cm2->data[4] - cm2->data[3] );
c = vector3_dot( dv.normal, cm_vec3 );
c = ( c - cm->data[3] ) / ( cm->data[4] - cm->data[3] );
mult.rgb().set( c );
break;
case EColorMod::AlphaDotProduct:
mult.alpha() = vector3_dot( dv->normal, cm2_vec3 );
mult.alpha() = vector3_dot( dv.normal, cm_vec3 );
break;
case EColorMod::AlphaDotProductScale:
c = vector3_dot( dv->normal, cm2_vec3 );
c = ( c - cm2->data[3] ) / ( cm2->data[4] - cm2->data[3] );
c = vector3_dot( dv.normal, cm_vec3 );
c = ( c - cm->data[3] ) / ( cm->data[4] - cm->data[3] );
mult.alpha() = c;
break;
case EColorMod::ColorDotProduct2:
c = vector3_dot( dv->normal, cm2_vec3 );
c = vector3_dot( dv.normal, cm_vec3 );
c *= c;
mult.rgb().set( c );
break;
case EColorMod::ColorDotProduct2Scale:
c = vector3_dot( dv->normal, cm2_vec3 );
c = vector3_dot( dv.normal, cm_vec3 );
c *= c;
c = ( c - cm2->data[3] ) / ( cm2->data[4] - cm2->data[3] );
c = ( c - cm->data[3] ) / ( cm->data[4] - cm->data[3] );
mult.rgb().set( c );
break;
case EColorMod::AlphaDotProduct2:
mult.alpha() = vector3_dot( dv->normal, cm2_vec3 );
mult.alpha() = vector3_dot( dv.normal, cm_vec3 );
mult.alpha() *= mult.alpha();
break;
case EColorMod::AlphaDotProduct2Scale:
c = vector3_dot( dv->normal, cm2_vec3 );
c = vector3_dot( dv.normal, cm_vec3 );
c *= c;
c = ( c - cm2->data[3] ) / ( cm2->data[4] - cm2->data[3] );
c = ( c - cm->data[3] ) / ( cm->data[4] - cm->data[3] );
mult.alpha() = c;
break;
@ -139,9 +130,9 @@ void ColorMod( colorMod_t *cm, int numVerts, bspDrawVert_t *drawVerts ){
}
/* apply mod */
for ( j = 0; j < MAX_LIGHTMAPS; j++ )
for ( auto& color : dv.color )
{
dv->color[ j ] = color_to_byte( mult * static_cast<BasicVector4<byte>>( dv->color[ j ] ) + add );
color = color_to_byte( mult * static_cast<BasicVector4<byte>>( color ) + add );
}
}
}
@ -253,11 +244,8 @@ bool ApplySurfaceParm( const char *name, int *contentFlags, int *surfaceFlags, i
}
/* check custom info parms */
for ( int i = 0; i < numCustSurfaceParms; i++ )
for ( const surfaceParm_t& sp : Span( custSurfaceParms, numCustSurfaceParms ) )
{
/* get surfaceparm */
const surfaceParm_t& sp = custSurfaceParms[ i ];
/* match? */
if ( striEqual( name, sp.name ) ) {
/* clear and set flags */
@ -314,33 +302,21 @@ void BeginMapShaderFile( const char *mapFile ){
*/
void WriteMapShaderFile( void ){
FILE *file;
shaderInfo_t *si;
int i, num;
/* dummy check */
if ( mapShaderFile.empty() ) {
return;
}
/* are there any custom shaders? */
for ( i = 0, num = 0; i < numShaderInfo; i++ )
{
if ( shaderInfo[ i ].custom ) {
break;
}
}
if ( i == numShaderInfo ) {
if( std::none_of( shaderInfo, shaderInfo + numShaderInfo, []( const shaderInfo_t& si ){ return si.custom; } ) )
return;
}
/* note it */
Sys_FPrintf( SYS_VRB, "--- WriteMapShaderFile ---\n" );
Sys_FPrintf( SYS_VRB, "Writing %s", mapShaderFile.c_str() );
/* open shader file */
file = fopen( mapShaderFile.c_str(), "wt" );
FILE *file = fopen( mapShaderFile.c_str(), "wt" );
if ( file == NULL ) {
Sys_Warning( "Unable to open map shader file %s for writing\n", mapShaderFile.c_str() );
return;
@ -354,20 +330,18 @@ void WriteMapShaderFile( void ){
mapName.c_str() );
/* walk the shader list */
for ( i = 0, num = 0; i < numShaderInfo; i++ )
int num = 0;
for ( const shaderInfo_t& si : Span( shaderInfo, numShaderInfo ) )
{
/* get the shader and print it */
si = &shaderInfo[ i ];
if ( !si->custom || strEmptyOrNull( si->shaderText ) ) {
continue;
if ( si.custom && !strEmptyOrNull( si.shaderText ) ) {
num++;
/* print it to the file */
fprintf( file, "%s%s\n", si.shader.c_str(), si.shaderText );
//Sys_Printf( "%s%s\n", si.shader.c_str(), si.shaderText ); /* FIXME: remove debugging code */
Sys_FPrintf( SYS_VRB, "." );
}
num++;
/* print it to the file */
fprintf( file, "%s%s\n", si->shader.c_str(), si->shaderText );
//Sys_Printf( "%s%s\n", si->shader, si->shaderText ); /* FIXME: remove debugging code */
Sys_FPrintf( SYS_VRB, "." );
}
/* close the shader */

224
tools/quake3/q3map2/surface.cpp
View File

@ -150,9 +150,6 @@ mapDrawSurface_t *CloneSurface( mapDrawSurface_t *src, shaderInfo_t *si ){
*/
mapDrawSurface_t *MakeCelSurface( mapDrawSurface_t *src, shaderInfo_t *si ){
mapDrawSurface_t *ds;
/* dummy check */
if ( src == NULL || si == NULL ) {
return NULL;
@ -165,7 +162,7 @@ mapDrawSurface_t *MakeCelSurface( mapDrawSurface_t *src, shaderInfo_t *si ){
}
/* make a copy */
ds = CloneSurface( src, si );
mapDrawSurface_t *ds = CloneSurface( src, si );
if ( ds == NULL ) {
return NULL;
}
@ -187,17 +184,13 @@ mapDrawSurface_t *MakeCelSurface( mapDrawSurface_t *src, shaderInfo_t *si ){
*/
mapDrawSurface_t *MakeSkyboxSurface( mapDrawSurface_t *src ){
int i;
mapDrawSurface_t *ds;
/* dummy check */
if ( src == NULL ) {
return NULL;
}
/* make a copy */
ds = CloneSurface( src, src->shaderInfo );
mapDrawSurface_t *ds = CloneSurface( src, src->shaderInfo );
if ( ds == NULL ) {
return NULL;
}
@ -206,9 +199,9 @@ mapDrawSurface_t *MakeSkyboxSurface( mapDrawSurface_t *src ){
ds->parent = src;
/* scale the surface vertexes */
for ( i = 0; i < ds->numVerts; i++ )
for ( bspDrawVert_t& vert : Span( ds->verts, ds->numVerts ) )
{
matrix4_transform_point( skyboxTransform, ds->verts[ i ].xyz );
matrix4_transform_point( skyboxTransform, vert.xyz );
/* debug code */
//% bspDrawVerts[ bspDrawSurfaces[ ds->outputNum ].firstVert + i ].color[ 0 ][ 1 ] = 0;
@ -318,12 +311,12 @@ void TidyEntitySurfaces( entity_t *e ){
static Vector2 CalcSurfaceTextureBias( const mapDrawSurface_t *ds ){
/* walk the verts and determine min/max st values */
Vector2 mins( 999999, 999999 ), maxs( -999999, -999999 ), bias;
for ( int i = 0; i < ds->numVerts; i++ )
for ( const bspDrawVert_t& vert : Span( ds->verts, ds->numVerts ) )
{
for ( int j = 0; j < 2; j++ )
{
value_minimize( mins[ j ], ds->verts[ i ].st[ j ] );
value_maximize( maxs[ j ], ds->verts[ i ].st[ j ] );
value_minimize( mins[ j ], vert.st[ j ] );
value_maximize( maxs[ j ], vert.st[ j ] );
}
}
@ -390,10 +383,9 @@ Vector3 CalcLightmapAxis( const Vector3& normal ){
#define PLANAR_EPSILON 0.5f //% 0.126f 0.25f
void ClassifySurfaces( int numSurfs, mapDrawSurface_t *ds ){
int i, bestAxis;
Plane3f plane;
shaderInfo_t *si;
static Vector3 axii[ 6 ] =
static const Vector3 axii[ 6 ] =
{
{ 0, 0, -1 },
{ 0, 0, 1 },
@ -431,8 +423,8 @@ void ClassifySurfaces( int numSurfs, mapDrawSurface_t *ds ){
/* set surface bounding box */
ds->minmax.clear();
for ( i = 0; i < ds->numVerts; i++ )
ds->minmax.extend( ds->verts[ i ].xyz );
for ( const bspDrawVert_t& vert : Span( ds->verts, ds->numVerts ) )
ds->minmax.extend( vert.xyz );
/* try to get an existing plane */
if ( ds->planeNum >= 0 ) {
@ -443,11 +435,11 @@ void ClassifySurfaces( int numSurfs, mapDrawSurface_t *ds ){
else
{
plane = { 0, 0, 0, 0 };
for ( i = 0; i < ds->numVerts; i++ )
for ( const bspDrawVert_t& vert : Span( ds->verts, ds->numVerts ) )
{
if ( ds->verts[ i ].normal != g_vector3_identity ) {
plane.normal() = ds->verts[ i ].normal;
plane.dist() = vector3_dot( ds->verts[ i ].xyz, plane.normal() );
if ( vert.normal != g_vector3_identity ) {
plane.normal() = vert.normal;
plane.dist() = vector3_dot( vert.xyz, plane.normal() );
break;
}
}
@ -464,10 +456,10 @@ void ClassifySurfaces( int numSurfs, mapDrawSurface_t *ds ){
ds->planar = true;
/* test each vert */
for ( i = 0; i < ds->numVerts; i++ )
for ( const bspDrawVert_t& vert : Span( ds->verts, ds->numVerts ) )
{
/* point-plane test */
if ( fabs( plane3_distance_to_point( plane, ds->verts[ i ].xyz ) ) > PLANAR_EPSILON ) {
if ( fabs( plane3_distance_to_point( plane, vert.xyz ) ) > PLANAR_EPSILON ) {
//% if( ds->planeNum >= 0 )
//% {
//% Sys_Warning( "Planar surface marked unplanar (%f > %f)\n", fabs( dist ), PLANAR_EPSILON );
@ -519,8 +511,10 @@ void ClassifySurfaces( int numSurfs, mapDrawSurface_t *ds ){
else
{
/* find best lightmap axis */
int bestAxis;
for ( bestAxis = 0; bestAxis < 6; bestAxis++ )
{
int i;
for ( i = 0; i < ds->numVerts; i++ )
{
//% Sys_Printf( "Comparing %1.3f %1.3f %1.3f to %1.3f %1.3f %1.3f\n",
@ -573,14 +567,11 @@ void ClassifySurfaces( int numSurfs, mapDrawSurface_t *ds ){
*/
void ClassifyEntitySurfaces( entity_t *e ){
int i;
/* note it */
Sys_FPrintf( SYS_VRB, "--- ClassifyEntitySurfaces ---\n" );
/* walk the surface list */
for ( i = e->firstDrawSurf; i < numMapDrawSurfs; i++ )
for ( int i = e->firstDrawSurf; i < numMapDrawSurfs; ++i )
{
FinishSurface( &mapDrawSurfs[ i ] );
ClassifySurfaces( 1, &mapDrawSurfs[ i ] );
@ -655,21 +646,21 @@ shaderInfo_t *GetIndexedShader( const shaderInfo_t *parent, const indexMap_t *im
/* determine min/max index */
byte minShaderIndex = 255;
byte maxShaderIndex = 0;
for ( int i = 0; i < numPoints; i++ )
for ( const byte index : Span( shaderIndexes, numPoints ) )
{
value_minimize( minShaderIndex, shaderIndexes[ i ] );
value_maximize( maxShaderIndex, shaderIndexes[ i ] );
value_minimize( minShaderIndex, index );
value_maximize( maxShaderIndex, index );
}
/* set alpha inline */
for ( int i = 0; i < numPoints; i++ )
for ( byte& index : Span( shaderIndexes, numPoints ) )
{
/* straight rip from terrain.c */
if ( shaderIndexes[ i ] < maxShaderIndex ) {
shaderIndexes[ i ] = 0;
if ( index < maxShaderIndex ) {
index = 0;
}
else{
shaderIndexes[ i ] = 255;
index = 255;
}
}
@ -843,13 +834,13 @@ mapDrawSurface_t *DrawSurfaceForSide( const entity_t *e, const brush_t& b, const
dv->normal = mapplanes[ s.planenum ].normal();
/* ydnar: set color */
for ( int k = 0; k < MAX_LIGHTMAPS; k++ )
for ( auto& color : dv->color )
{
dv->color[ k ].set( 255 );
color.set( 255 );
/* ydnar: gs mods: handle indexed shader blending */
if( indexed )
dv->color[ k ].alpha() = shaderIndexes[ j ];
color.alpha() = shaderIndexes[ j ];
}
}
@ -873,7 +864,7 @@ mapDrawSurface_t *DrawSurfaceForSide( const entity_t *e, const brush_t& b, const
*/
mapDrawSurface_t *DrawSurfaceForMesh( entity_t *e, parseMesh_t *p, mesh_t *mesh ){
int i, k, numVerts;
int i, numVerts;
Plane3f plane;
bool planar;
mapDrawSurface_t *ds;
@ -999,8 +990,8 @@ mapDrawSurface_t *DrawSurfaceForMesh( entity_t *e, parseMesh_t *p, mesh_t *mesh
ds->lightmapVecs[ 2 ] = plane.normal();
/* push this normal to all verts (ydnar 2003-02-14: bad idea, small patches get screwed up) */
for ( i = 0; i < ds->numVerts; i++ )
ds->verts[ i ].normal = plane.normal();
for ( bspDrawVert_t& vert : Span( ds->verts, ds->numVerts ) )
vert.normal = plane.normal();
}
/* walk the verts to do special stuff */
@ -1023,13 +1014,13 @@ mapDrawSurface_t *DrawSurfaceForMesh( entity_t *e, parseMesh_t *p, mesh_t *mesh
}
/* ydnar: set color */
for ( k = 0; k < MAX_LIGHTMAPS; k++ )
for ( auto& color : dv->color )
{
dv->color[ k ].set( 255 );
color.set( 255 );
/* ydnar: gs mods: handle indexed shader blending */
if( indexed )
dv->color[ k ].alpha() = shaderIndexes[ i ];
color.alpha() = shaderIndexes[ i ];
}
/* ydnar: offset */
@ -1096,30 +1087,22 @@ mapDrawSurface_t *DrawSurfaceForFlare( int entNum, const Vector3& origin, const
*/
mapDrawSurface_t *DrawSurfaceForShader( const char *shader ){
int i;
shaderInfo_t *si;
mapDrawSurface_t *ds;
/* get shader */
si = ShaderInfoForShader( shader );
shaderInfo_t *si = ShaderInfoForShader( shader );
/* find existing surface */
for ( i = 0; i < numMapDrawSurfs; i++ )
for ( mapDrawSurface_t& ds : Span( mapDrawSurfs, numMapDrawSurfs ) )
{
/* get surface */
ds = &mapDrawSurfs[ i ];
/* check it */
if ( ds->shaderInfo == si ) {
return ds;
if ( ds.shaderInfo == si ) {
return &ds;
}
}
/* create a new surface */
ds = AllocDrawSurface( ESurfaceType::Shader );
mapDrawSurface_t *ds = AllocDrawSurface( ESurfaceType::Shader );
ds->entityNum = 0;
ds->shaderInfo = ShaderInfoForShader( shader );
ds->shaderInfo = si;
/* return to sender */
return ds;
@ -1135,8 +1118,8 @@ mapDrawSurface_t *DrawSurfaceForShader( const char *shader ){
static void AddSurfaceFlare( mapDrawSurface_t *ds, const Vector3& entityOrigin ){
Vector3 origin( 0 );
/* find centroid */
for ( int i = 0; i < ds->numVerts; i++ )
origin += ds->verts[ i ].xyz;
for ( const bspDrawVert_t& vert : Span( ds->verts, ds->numVerts ) )
origin += vert.xyz;
origin /= ds->numVerts;
origin += entityOrigin;
@ -1227,21 +1210,17 @@ void SubdivideFaceSurfaces( entity_t *e ){
/* note it */
Sys_FPrintf( SYS_VRB, "--- SubdivideFaceSurfaces ---\n" );
/* walk the list of surfaces */
const int numBaseDrawSurfs = numMapDrawSurfs;
for ( int i = e->firstDrawSurf; i < numBaseDrawSurfs; i++ )
/* walk the list of original surfaces, numMapDrawSurfs may increase in the process */
for ( mapDrawSurface_t& ds : Span( mapDrawSurfs + e->firstDrawSurf, numMapDrawSurfs ) )
{
/* get surface */
mapDrawSurface_t *ds = &mapDrawSurfs[ i ];
/* only subdivide brush sides */
if ( ds->type != ESurfaceType::Face || ds->mapBrush == NULL || ds->sideRef == NULL || ds->sideRef->side == NULL ) {
if ( ds.type != ESurfaceType::Face || ds.mapBrush == NULL || ds.sideRef == NULL || ds.sideRef->side == NULL ) {
continue;
}
/* get bits */
const brush_t *brush = ds->mapBrush;
const side_t& side = *ds->sideRef->side;
const brush_t *brush = ds.mapBrush;
const side_t& side = *ds.sideRef->side;
/* check subdivision for shader */
const shaderInfo_t *si = side.shaderInfo;
@ -1261,11 +1240,11 @@ void SubdivideFaceSurfaces( entity_t *e ){
}
/* preserve fog num */
const int fogNum = ds->fogNum;
const int fogNum = ds.fogNum;
/* make a winding and free the surface */
winding_t w = WindingFromDrawSurf( ds );
ClearSurface( ds );
winding_t w = WindingFromDrawSurf( &ds );
ClearSurface( &ds );
/* subdivide it */
SubdivideFace_r( e, *brush, side, w, fogNum, subdivisions );
@ -1675,7 +1654,7 @@ int AddReferenceToLeaf( mapDrawSurface_t *ds, node_t *node ){
*/
int AddReferenceToTree_r( mapDrawSurface_t *ds, node_t *node, bool skybox ){
int i, refs = 0;
int refs = 0;
/* dummy check */
@ -1699,8 +1678,8 @@ int AddReferenceToTree_r( mapDrawSurface_t *ds, node_t *node, bool skybox ){
}
/* increase the leaf bounds */
for ( i = 0; i < ds->numVerts; i++ )
node->minmax.extend( ds->verts[ i ].xyz );
for ( const bspDrawVert_t& vert : Span( ds->verts, ds->numVerts ) )
node->minmax.extend( vert.xyz );
}
/* add a reference */
@ -1914,10 +1893,10 @@ int FilterFaceIntoTree( mapDrawSurface_t *ds, tree_t& tree ){
#define FILTER_SUBDIVISION 8
static int FilterPatchIntoTree( mapDrawSurface_t *ds, tree_t& tree ){
int x, y, refs = 0;
int refs = 0;
for ( y = 0; y + 2 < ds->patchHeight; y += 2 )
for ( x = 0; x + 2 < ds->patchWidth; x += 2 )
for ( int y = 0; y + 2 < ds->patchHeight; y += 2 )
for ( int x = 0; x + 2 < ds->patchWidth; x += 2 )
{
Vector3 *points[9];
points[0] = &ds->verts[( y + 0 ) * ds->patchWidth + ( x + 0 )].xyz;
@ -1943,15 +1922,13 @@ static int FilterPatchIntoTree( mapDrawSurface_t *ds, tree_t& tree ){
*/
static int FilterTrianglesIntoTree( mapDrawSurface_t *ds, tree_t& tree ){
int i, refs;
int refs = 0;
/* ydnar: gs mods: this was creating bogus triangles before */
refs = 0;
for ( i = 0; i < ds->numIndexes; i += 3 )
for ( int i = 0; i < ds->numIndexes; i += 3 )
{
/* error check */
if ( ds->indexes[ i ] >= ds->numVerts ||
if ( ds->indexes[ i + 0 ] >= 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 );
@ -1959,15 +1936,15 @@ static int FilterTrianglesIntoTree( mapDrawSurface_t *ds, tree_t& tree ){
/* make a triangle winding and filter it into the tree */
winding_t w{
ds->verts[ ds->indexes[ i ] ].xyz,
ds->verts[ ds->indexes[ i + 0 ] ].xyz,
ds->verts[ ds->indexes[ i + 1 ] ].xyz,
ds->verts[ ds->indexes[ i + 2 ] ].xyz };
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 );
for ( const bspDrawVert_t& vert : Span( ds->verts, ds->numVerts ) )
refs += FilterPointIntoTree_r( vert.xyz, ds, tree.headnode );
return refs;
}
@ -1995,7 +1972,7 @@ static int FilterFoliageIntoTree( mapDrawSurface_t *ds, tree_t& tree ){
for ( i = 0; i < ds->numIndexes; i += 3 )
{
/* error check */
if ( ds->indexes[ i ] >= ds->numVerts ||
if ( ds->indexes[ i + 0 ] >= 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 );
@ -2003,7 +1980,7 @@ static int FilterFoliageIntoTree( mapDrawSurface_t *ds, tree_t& tree ){
/* make a triangle winding and filter it into the tree */
winding_t w{
instance->xyz + ds->verts[ ds->indexes[ i ] ].xyz,
instance->xyz + ds->verts[ ds->indexes[ i + 0 ] ].xyz,
instance->xyz + ds->verts[ ds->indexes[ i + 1 ] ].xyz,
instance->xyz + ds->verts[ ds->indexes[ i + 2 ] ].xyz };
refs += FilterWindingIntoTree_r( w, ds, tree.headnode );
@ -2043,10 +2020,10 @@ void EmitDrawVerts( const mapDrawSurface_t *ds, bspDrawSurface_t& out ){
/* copy the verts */
out.firstVert = bspDrawVerts.size();
out.numVerts = ds->numVerts;
for ( int i = 0; i < ds->numVerts; i++ )
for ( const bspDrawVert_t& vert : Span( ds->verts, ds->numVerts ) )
{
/* allocate a new vert */ /* copy it */
bspDrawVert_t& dv = bspDrawVerts.emplace_back( ds->verts[ i ] );
bspDrawVert_t& dv = bspDrawVerts.emplace_back( vert );
/* offset? */
if ( offset != 0.0f ) {
@ -2062,8 +2039,8 @@ void EmitDrawVerts( const mapDrawSurface_t *ds, bspDrawSurface_t& out ){
/* debug color? */
if ( debugSurfaces ) {
for ( int k = 0; k < MAX_LIGHTMAPS; k++ )
dv.color[ k ].rgb() = debugColors[ ( ds - mapDrawSurfs ) % 12 ];
for ( auto& color : dv.color )
color.rgb() = debugColors[ ( ds - mapDrawSurfs ) % 12 ];
}
}
}
@ -2219,7 +2196,6 @@ void EmitFlareSurface( mapDrawSurface_t *ds ){
*/
void EmitPatchSurface( entity_t *e, mapDrawSurface_t *ds ){
int i, j;
int surfaceFlags, contentFlags;
/* vortex: _patchMeta support */
@ -2228,13 +2204,13 @@ void EmitPatchSurface( entity_t *e, mapDrawSurface_t *ds ){
/* invert the surface if necessary */
if ( ds->backSide || ds->shaderInfo->invert ) {
/* walk the verts, flip the normal */
for ( i = 0; i < ds->numVerts; i++ )
vector3_negate( ds->verts[ i ].normal );
for ( bspDrawVert_t& vert : Span( ds->verts, ds->numVerts ) )
vector3_negate( vert.normal );
/* walk the verts again, but this time reverse their order */
for ( j = 0; j < ds->patchHeight; j++ )
for ( int j = 0; j < ds->patchHeight; j++ )
{
for ( i = 0; i < ( ds->patchWidth / 2 ); i++ )
for ( int i = 0; i < ( ds->patchWidth / 2 ); i++ )
{
std::swap( ds->verts[ j * ds->patchWidth + i ],
ds->verts[ j * ds->patchWidth + ( ds->patchWidth - i - 1 ) ] );
@ -2277,7 +2253,7 @@ void EmitPatchSurface( entity_t *e, mapDrawSurface_t *ds ){
out.fogNum = ds->fogNum;
/* RBSP */
for ( i = 0; i < MAX_LIGHTMAPS; i++ )
for ( int i = 0; i < MAX_LIGHTMAPS; i++ )
{
out.lightmapNum[ i ] = -3;
out.lightmapStyles[ i ] = LS_NONE;
@ -2443,8 +2419,8 @@ void EmitTriangleSurface( mapDrawSurface_t *ds ){
}
/* walk the verts, flip the normal */
for ( i = 0; i < ds->numVerts; i++ )
vector3_negate( ds->verts[ i ].normal );
for ( bspDrawVert_t& vert : Span( ds->verts, ds->numVerts ) )
vector3_negate( vert.normal );
/* invert facing */
vector3_negate( ds->lightmapVecs[ 2 ] );
@ -2564,7 +2540,7 @@ static void EmitFaceSurface( mapDrawSurface_t *ds ){
*/
static void MakeDebugPortalSurfs_r( const node_t *node, shaderInfo_t *si ){
int i, k, c, s;
int i, c, s;
const portal_t *p;
mapDrawSurface_t *ds;
bspDrawVert_t *dv;
@ -2621,10 +2597,10 @@ static void MakeDebugPortalSurfs_r( const node_t *node, shaderInfo_t *si ){
dv->xyz = w[ i ];
dv->normal = p->plane.normal();
dv->st = { 0, 0 };
for ( k = 0; k < MAX_LIGHTMAPS; k++ )
for ( auto& color : dv->color )
{
dv->color[ k ].rgb() = debugColors[ c % 12 ];
dv->color[ k ].alpha() = 32;
color.rgb() = debugColors[ c % 12 ];
color.alpha() = 32;
}
}
}
@ -2729,9 +2705,9 @@ void BiasSurfaceTextures( mapDrawSurface_t *ds ){
const Vector2 bias = CalcSurfaceTextureBias( ds );
/* bias the texture coordinates */
for ( int i = 0; i < ds->numVerts; i++ )
for ( bspDrawVert_t& vert : Span( ds->verts, ds->numVerts ) )
{
ds->verts[ i ].st -= bias;
vert.st -= bias;
}
}
@ -2752,13 +2728,10 @@ int AddSurfaceModelsToTriangle_r( mapDrawSurface_t *ds, const surfaceModel_t& mo
/* subdivide calc */
{
int i;
/* find the longest edge and split it */
max = -1;
float maxDist = 0.0f;
for ( i = 0; i < 3; i++ )
for ( int i = 0; i < 3; ++i )
{
/* get dist */
const float dist = vector3_length_squared( tri[ i ]->xyz - tri[ ( i + 1 ) % 3 ]->xyz );
@ -2905,12 +2878,12 @@ int AddSurfaceModels( mapDrawSurface_t *ds ){
alpha = 0.0f;
/* walk verts */
for ( i = 0; i < ds->numVerts; i++ )
for ( const bspDrawVert_t& vert : Span( ds->verts, ds->numVerts ) )
{
centroid.xyz += ds->verts[ i ].xyz;
centroid.normal += ds->verts[ i ].normal;
centroid.st += ds->verts[ i ].st;
alpha += ds->verts[ i ].color[ 0 ].alpha();
centroid.xyz += vert.xyz;
centroid.normal += vert.normal;
centroid.st += vert.st;
alpha += vert.color[ 0 ].alpha();
}
/* average */
@ -3065,21 +3038,21 @@ static void VolumeColorMods( entity_t *e, mapDrawSurface_t *ds ){
}
/* iterate verts */
for ( int i = 0; i < ds->numVerts; i++ )
for ( bspDrawVert_t& vert : Span( ds->verts, ds->numVerts ) )
{
/* iterate planes */
size_t j;
for ( j = 0; j < b->sides.size(); j++ )
for ( j = 0; j < b->sides.size(); ++j )
{
/* point-plane test */
if ( plane3_distance_to_point( mapplanes[ b->sides[ j ].planenum ].plane, ds->verts[ i ].xyz ) > 1.0f ) {
if ( plane3_distance_to_point( mapplanes[ b->sides[ j ].planenum ].plane, vert.xyz ) > 1.0f ) {
break;
}
}
/* apply colormods */
if ( j == b->sides.size() ) {
ColorMod( b->contentShader->colorMod, 1, &ds->verts[ i ] );
ColorMod( b->contentShader->colorMod, 1, &vert );
}
}
}
@ -3095,9 +3068,6 @@ static void VolumeColorMods( entity_t *e, mapDrawSurface_t *ds ){
*/
void FilterDrawsurfsIntoTree( entity_t *e, tree_t& tree ){
int i, j;
mapDrawSurface_t *ds;
shaderInfo_t *si;
int refs;
int numSurfs, numRefs, numSkyboxSurfaces;
bool sb;
@ -3110,16 +3080,16 @@ void FilterDrawsurfsIntoTree( entity_t *e, tree_t& tree ){
numSurfs = 0;
numRefs = 0;
numSkyboxSurfaces = 0;
for ( i = e->firstDrawSurf; i < numMapDrawSurfs; i++ )
for ( int i = e->firstDrawSurf; i < numMapDrawSurfs; ++i )
{
/* get surface and try to early out */
ds = &mapDrawSurfs[ i ];
mapDrawSurface_t *ds = &mapDrawSurfs[ i ];
if ( ds->numVerts == 0 && ds->type != ESurfaceType::Flare && ds->type != ESurfaceType::Shader ) {
continue;
}
/* get shader */
si = ds->shaderInfo;
shaderInfo_t *si = ds->shaderInfo;
/* ydnar: skybox surfaces are special */
if ( ds->skybox ) {
@ -3135,8 +3105,8 @@ void FilterDrawsurfsIntoTree( entity_t *e, tree_t& tree ){
refs = 0;
/* apply texture coordinate mods */
for ( j = 0; j < ds->numVerts; j++ )
TCMod( si->mod, ds->verts[ j ].st );
for ( bspDrawVert_t& vert : Span( ds->verts, ds->numVerts ) )
TCMod( si->mod, vert.st );
/* ydnar: apply shader colormod */
ColorMod( ds->shaderInfo->colorMod, ds->numVerts, ds->verts );

41
tools/quake3/q3map2/surface_fur.cpp
View File

@ -46,44 +46,35 @@
*/
void Fur( mapDrawSurface_t *ds ){
int i, j, k, numLayers;
float offset, fade, a;
mapDrawSurface_t *fur;
bspDrawVert_t *dv;
/* dummy check */
if ( ds == NULL || ds->fur || ds->shaderInfo->furNumLayers < 1 ) {
return;
}
/* get basic info */
numLayers = ds->shaderInfo->furNumLayers;
offset = ds->shaderInfo->furOffset;
fade = ds->shaderInfo->furFade * 255.0f;
const int numLayers = ds->shaderInfo->furNumLayers;
const float offset = ds->shaderInfo->furOffset;
const float fade = ds->shaderInfo->furFade * 255.0f;
/* debug code */
//% Sys_FPrintf( SYS_VRB, "Fur(): layers: %d offset: %f fade: %f %s\n",
//% numLayers, offset, fade, ds->shaderInfo->shader );
/* initial offset */
for ( j = 0; j < ds->numVerts; j++ )
for ( bspDrawVert_t& dv : Span( ds->verts, ds->numVerts ) )
{
/* get surface vert */
dv = &ds->verts[ j ];
/* offset is scaled by original vertex alpha */
a = (float) dv->color[ 0 ].alpha() / 255.0;
const float a = dv.color[ 0 ].alpha() / 255.0;
/* offset it */
dv->xyz += dv->normal * ( offset * a );
dv.xyz += dv.normal * ( offset * a );
}
/* wash, rinse, repeat */
for ( i = 1; i < numLayers; i++ )
for ( int i = 1; i < numLayers; ++i )
{
/* clone the surface */
fur = CloneSurface( ds, ds->shaderInfo );
mapDrawSurface_t *fur = CloneSurface( ds, ds->shaderInfo );
if ( fur == NULL ) {
return;
}
@ -92,25 +83,21 @@ void Fur( mapDrawSurface_t *ds ){
fur->fur = true;
/* walk the verts */
for ( j = 0; j < fur->numVerts; j++ )
for ( int j = 0; j < fur->numVerts; ++j )
{
/* get surface vert */
dv = &ds->verts[ j ];
/* offset is scaled by original vertex alpha */
a = (float) dv->color[ 0 ].alpha() / 255.0;
const float a = ds->verts[ j ].color[ 0 ].alpha() / 255.0;
/* get fur vert */
dv = &fur->verts[ j ];
bspDrawVert_t& dv = fur->verts[ j ];
/* offset it */
dv->xyz += dv->normal * ( offset * a * i );
dv.xyz += dv.normal * ( offset * a * i );
/* fade alpha */
for ( k = 0; k < MAX_LIGHTMAPS; k++ )
for ( auto& color : dv.color )
{
a = (float) dv->color[ k ].alpha() - fade;
dv->color[ k ].alpha() = color_to_byte( a );
color.alpha() = color_to_byte( color.alpha() - fade );
}
}
}

19
tools/quake3/q3map2/surface_meta.cpp
View File

@ -648,8 +648,8 @@ void MaxAreaFaceSurface( mapDrawSurface_t *ds ){
void FanFaceSurface( mapDrawSurface_t *ds ){
int i, k, a, b, c;
Color4f color[ MAX_LIGHTMAPS ];
for ( k = 0; k < MAX_LIGHTMAPS; k++ )
color[k].set( 0 );
for ( auto& co : color )
co.set( 0 );
bspDrawVert_t *verts, *centroid, *dv;
double iv;
@ -855,29 +855,24 @@ void EmitMetaStats(){
*/
void MakeEntityMetaTriangles( entity_t *e ){
int i, f, fOld, start;
mapDrawSurface_t *ds;
/* note it */
Sys_FPrintf( SYS_VRB, "--- MakeEntityMetaTriangles ---\n" );
/* init pacifier */
fOld = -1;
start = I_FloatTime();
int fOld = -1;
const int start = I_FloatTime();
/* walk the list of surfaces in the entity */
for ( i = e->firstDrawSurf; i < numMapDrawSurfs; i++ )
for ( int i = e->firstDrawSurf; i < numMapDrawSurfs; ++i )
{
/* print pacifier */
f = 10 * ( i - e->firstDrawSurf ) / ( numMapDrawSurfs - e->firstDrawSurf );
if ( f != fOld ) {
if ( const int f = 10 * ( i - e->firstDrawSurf ) / ( numMapDrawSurfs - e->firstDrawSurf ); f != fOld ) {
fOld = f;
Sys_FPrintf( SYS_VRB, "%d...", f );
}
/* get surface */
ds = &mapDrawSurfs[ i ];
mapDrawSurface_t *ds = &mapDrawSurfs[ i ];
if ( ds->numVerts <= 0 ) {
continue;
}

154
tools/quake3/q3map2/tjunction.cpp
View File

@ -201,12 +201,12 @@ int AddEdge( bspDrawVert_t& dv1, bspDrawVert_t& dv2, bool createNonAxial ) {
adds a surface's edges
*/
void AddSurfaceEdges( mapDrawSurface_t *ds ){
for ( int i = 0; i < ds->numVerts; i++ )
void AddSurfaceEdges( mapDrawSurface_t& ds ){
for ( int i = 0; i < ds.numVerts; i++ )
{
/* save the edge number in the lightmap field so we don't need to look it up again */
ds->verts[i].lightmap[ 0 ][ 0 ] =
AddEdge( ds->verts[ i ], ds->verts[ ( i + 1 ) % ds->numVerts ], false );
ds.verts[i].lightmap[ 0 ][ 0 ] =
AddEdge( ds.verts[ i ], ds.verts[ ( i + 1 ) % ds.numVerts ], false );
}
}
@ -249,14 +249,12 @@ bool ColinearEdge( const Vector3& v1, const Vector3& v2, const Vector3& v3 ){
brush tjunctions
====================
*/
void AddPatchEdges( mapDrawSurface_t *ds ) {
int i;
for ( i = 0 ; i < ds->patchWidth - 2; i += 2 ) {
void AddPatchEdges( mapDrawSurface_t& ds ) {
for ( int i = 0; i < ds.patchWidth - 2; i += 2 ) {
{
bspDrawVert_t& v1 = ds->verts[ i ];
bspDrawVert_t& v2 = ds->verts[ i + 1 ];
bspDrawVert_t& v3 = ds->verts[ i + 2 ];
bspDrawVert_t& v1 = ds.verts[ i + 0 ];
bspDrawVert_t& v2 = ds.verts[ i + 1 ];
bspDrawVert_t& v3 = ds.verts[ i + 2 ];
// if v2 is the midpoint of v1 to v3, add an edge from v1 to v3
if ( ColinearEdge( v1.xyz, v2.xyz, v3.xyz ) ) {
@ -264,9 +262,9 @@ void AddPatchEdges( mapDrawSurface_t *ds ) {
}
}
{
bspDrawVert_t& v1 = ds->verts[ ( ds->patchHeight - 1 ) * ds->patchWidth + i ];
bspDrawVert_t& v2 = ds->verts[ ( ds->patchHeight - 1 ) * ds->patchWidth + i + 1 ];
bspDrawVert_t& v3 = ds->verts[ ( ds->patchHeight - 1 ) * ds->patchWidth + i + 2 ];
bspDrawVert_t& v1 = ds.verts[ ( ds.patchHeight - 1 ) * ds.patchWidth + i + 0 ];
bspDrawVert_t& v2 = ds.verts[ ( ds.patchHeight - 1 ) * ds.patchWidth + i + 1 ];
bspDrawVert_t& v3 = ds.verts[ ( ds.patchHeight - 1 ) * ds.patchWidth + i + 2 ];
// if v2 is on the v1 to v3 line, add an edge from v1 to v3
if ( ColinearEdge( v1.xyz, v2.xyz, v3.xyz ) ) {
@ -275,11 +273,11 @@ void AddPatchEdges( mapDrawSurface_t *ds ) {
}
}
for ( i = 0 ; i < ds->patchHeight - 2 ; i += 2 ) {
for ( int i = 0; i < ds.patchHeight - 2; i += 2 ) {
{
bspDrawVert_t& v1 = ds->verts[ i * ds->patchWidth ];
bspDrawVert_t& v2 = ds->verts[ ( i + 1 ) * ds->patchWidth ];
bspDrawVert_t& v3 = ds->verts[ ( i + 2 ) * ds->patchWidth ];
bspDrawVert_t& v1 = ds.verts[ ( i + 0 ) * ds.patchWidth ];
bspDrawVert_t& v2 = ds.verts[ ( i + 1 ) * ds.patchWidth ];
bspDrawVert_t& v3 = ds.verts[ ( i + 2 ) * ds.patchWidth ];
// if v2 is the midpoint of v1 to v3, add an edge from v1 to v3
if ( ColinearEdge( v1.xyz, v2.xyz, v3.xyz ) ) {
@ -287,9 +285,9 @@ void AddPatchEdges( mapDrawSurface_t *ds ) {
}
}
{
bspDrawVert_t& v1 = ds->verts[ ( ds->patchWidth - 1 ) + i * ds->patchWidth ];
bspDrawVert_t& v2 = ds->verts[ ( ds->patchWidth - 1 ) + ( i + 1 ) * ds->patchWidth ];
bspDrawVert_t& v3 = ds->verts[ ( ds->patchWidth - 1 ) + ( i + 2 ) * ds->patchWidth ];
bspDrawVert_t& v1 = ds.verts[ ( ds.patchWidth - 1 ) + ( i + 0 ) * ds.patchWidth ];
bspDrawVert_t& v2 = ds.verts[ ( ds.patchWidth - 1 ) + ( i + 1 ) * ds.patchWidth ];
bspDrawVert_t& v3 = ds.verts[ ( ds.patchWidth - 1 ) + ( i + 2 ) * ds.patchWidth ];
// if v2 is the midpoint of v1 to v3, add an edge from v1 to v3
if ( ColinearEdge( v1.xyz, v2.xyz, v3.xyz ) ) {
@ -297,8 +295,6 @@ void AddPatchEdges( mapDrawSurface_t *ds ) {
}
}
}
}
@ -308,7 +304,7 @@ void AddPatchEdges( mapDrawSurface_t *ds ) {
====================
*/
#define MAX_SURFACE_VERTS 256
void FixSurfaceJunctions( mapDrawSurface_t *ds ) {
void FixSurfaceJunctions( mapDrawSurface_t& ds ) {
int i, j, k;
edgeLine_t *e;
edgePoint_t *p;
@ -320,7 +316,7 @@ void FixSurfaceJunctions( mapDrawSurface_t *ds ) {
numVerts = 0;
for ( i = 0 ; i < ds->numVerts ; i++ )
for ( i = 0; i < ds.numVerts; ++i )
{
counts[i] = 0;
@ -328,15 +324,15 @@ void FixSurfaceJunctions( mapDrawSurface_t *ds ) {
if ( numVerts == MAX_SURFACE_VERTS ) {
Error( "MAX_SURFACE_VERTS" );
}
verts[numVerts] = ds->verts[i];
verts[numVerts] = ds.verts[i];
originals[numVerts] = i;
numVerts++;
// check to see if there are any t junctions before the next vert
v1 = &ds->verts[i];
v2 = &ds->verts[ ( i + 1 ) % ds->numVerts ];
v1 = &ds.verts[i];
v2 = &ds.verts[ ( i + 1 ) % ds.numVerts ];
j = (int)ds->verts[i].lightmap[ 0 ][ 0 ];
j = (int)ds.verts[i].lightmap[ 0 ][ 0 ];
if ( j == -1 ) {
continue; // degenerate edge
}
@ -408,7 +404,7 @@ void FixSurfaceJunctions( mapDrawSurface_t *ds ) {
}
}
c_addedVerts += numVerts - ds->numVerts;
c_addedVerts += numVerts - ds.numVerts;
c_totalVerts += numVerts;
@ -433,9 +429,9 @@ void FixSurfaceJunctions( mapDrawSurface_t *ds ) {
// fine the way it is
c_natural++;
ds->numVerts = numVerts;
ds->verts = safe_malloc( numVerts * sizeof( *ds->verts ) );
memcpy( ds->verts, verts, numVerts * sizeof( *ds->verts ) );
ds.numVerts = numVerts;
ds.verts = safe_malloc( numVerts * sizeof( *ds.verts ) );
memcpy( ds.verts, verts, numVerts * sizeof( *ds.verts ) );
return;
}
@ -464,11 +460,11 @@ void FixSurfaceJunctions( mapDrawSurface_t *ds ) {
}
ds->numVerts = numVerts;
ds->verts = safe_malloc( numVerts * sizeof( *ds->verts ) );
ds.numVerts = numVerts;
ds.verts = safe_malloc( numVerts * sizeof( *ds.verts ) );
for ( j = 0 ; j < ds->numVerts ; j++ ) {
ds->verts[j] = verts[ ( j + i ) % ds->numVerts ];
for ( j = 0 ; j < ds.numVerts ; j++ ) {
ds.verts[j] = verts[ ( j + i ) % ds.numVerts ];
}
}
@ -486,69 +482,58 @@ void FixSurfaceJunctions( mapDrawSurface_t *ds ) {
int c_broken = 0;
bool FixBrokenSurface( mapDrawSurface_t *ds ){
bspDrawVert_t *dv1, *dv2, avg;
int i, j, k;
bool FixBrokenSurface( mapDrawSurface_t& ds ){
/* dummy check */
if ( ds == NULL ) {
return false;
}
if ( ds->type != ESurfaceType::Face ) {
if ( ds.type != ESurfaceType::Face ) {
return false;
}
/* check all verts */
for ( i = 0; i < ds->numVerts; i++ )
for ( int i = 0; i < ds.numVerts; ++i )
{
/* get verts */
dv1 = &ds->verts[ i ];
dv2 = &ds->verts[ ( i + 1 ) % ds->numVerts ];
bspDrawVert_t& dv1 = ds.verts[ i ];
bspDrawVert_t& dv2 = ds.verts[ ( i + 1 ) % ds.numVerts ];
bspDrawVert_t avg;
/* degenerate edge? */
avg.xyz = dv1->xyz - dv2->xyz;
avg.xyz = dv1.xyz - dv2.xyz;
if ( vector3_length( avg.xyz ) < DEGENERATE_EPSILON ) {
Sys_FPrintf( SYS_WRN | SYS_VRBflag, "WARNING: Degenerate T-junction edge found, fixing...\n" );
/* create an average drawvert */
/* ydnar 2002-01-26: added nearest-integer welding preference */
avg.xyz = SnapWeldVector( dv1->xyz, dv2->xyz );
avg.normal = VectorNormalized( dv1->normal + dv2->normal );
avg.st = vector2_mid( dv1->st, dv2->st );
avg.xyz = SnapWeldVector( dv1.xyz, dv2.xyz );
avg.normal = VectorNormalized( dv1.normal + dv2.normal );
avg.st = vector2_mid( dv1.st, dv2.st );
/* lightmap st/colors */
for ( k = 0; k < MAX_LIGHTMAPS; k++ )
for ( int k = 0; k < MAX_LIGHTMAPS; ++k )
{
avg.lightmap[ k ] = vector2_mid( dv1->lightmap[ k ], dv2->lightmap[ k ] );
for ( j = 0; j < 4; j++ )
avg.color[ k ][ j ] = (int) ( dv1->color[ k ][ j ] + dv2->color[ k ][ j ] ) >> 1;
avg.lightmap[ k ] = vector2_mid( dv1.lightmap[ k ], dv2.lightmap[ k ] );
for ( int j = 0; j < 4; ++j )
avg.color[ k ][ j ] = (int) ( dv1.color[ k ][ j ] + dv2.color[ k ][ j ] ) >> 1;
}
/* ydnar: der... */
memcpy( dv1, &avg, sizeof( avg ) );
dv1 = avg;
/* move the remaining verts */
for ( k = i + 2; k < ds->numVerts; k++ )
for ( int k = i + 2; k < ds.numVerts; ++k )
{
/* get verts */
dv1 = &ds->verts[ k ];
dv2 = &ds->verts[ k - 1 ];
/* copy */
memcpy( dv2, dv1, sizeof( bspDrawVert_t ) );
ds.verts[ k - 1 ] = ds.verts[ k ];
}
ds->numVerts--;
ds.numVerts--;
/* after welding, we have to consider the same vertex again, as it now has a new neighbor dv2 */
--i;
/* should ds->numVerts have become 0, then i is now -1. In the next iteration, the loop will abort. */
/* should ds.numVerts have become 0, then i is now -1. In the next iteration, the loop will abort. */
}
}
/* one last check and return */
return ds->numVerts >= 3;
return ds.numVerts >= 3;
}
@ -562,12 +547,7 @@ bool FixBrokenSurface( mapDrawSurface_t *ds ){
*/
void FixTJunctions( entity_t *ent ){
int i;
mapDrawSurface_t *ds;
shaderInfo_t *si;
int axialEdgeLines;
originalEdge_t *e;
bspDrawVert_t *dv;
/* meta mode has its own t-junction code (currently not as good as this code) */
//% if( meta )
@ -582,17 +562,17 @@ void FixTJunctions( entity_t *ent ){
// this actually creates axial edges, but it
// only creates originalEdge_t structures
// for non-axial edges
for ( i = ent->firstDrawSurf ; i < numMapDrawSurfs ; i++ )
for ( int i = ent->firstDrawSurf; i < numMapDrawSurfs; ++i )
{
/* get surface and early out if possible */
ds = &mapDrawSurfs[ i ];
si = ds->shaderInfo;
if ( ( si->compileFlags & C_NODRAW ) || si->autosprite || si->notjunc || ds->numVerts == 0 ) {
mapDrawSurface_t& ds = mapDrawSurfs[ i ];
const shaderInfo_t *si = ds.shaderInfo;
if ( ( si->compileFlags & C_NODRAW ) || si->autosprite || si->notjunc || ds.numVerts == 0 ) {
continue;
}
/* ydnar: gs mods: handle the various types of surfaces */
switch ( ds->type )
switch ( ds.type )
{
/* handle brush faces */
case ESurfaceType::Face:
@ -619,10 +599,8 @@ void FixTJunctions( entity_t *ent ){
// add the non-axial edges, longest first
// this gives the most accurate edge description
for ( i = 0 ; i < numOriginalEdges ; i++ ) {
e = &originalEdges[i];
dv = e->dv[0]; // e might change during AddEdge
dv->lightmap[ 0 ][ 0 ] = AddEdge( *e->dv[ 0 ], *e->dv[ 1 ], true );
for ( originalEdge_t& e : Span( originalEdges, numOriginalEdges ) ) { // originalEdges might not change during AddEdge( true )
e.dv[ 0 ]->lightmap[ 0 ][ 0 ] = AddEdge( *e.dv[ 0 ], *e.dv[ 1 ], true );
}
Sys_FPrintf( SYS_VRB, "%9d axial edge lines\n", axialEdgeLines );
@ -630,24 +608,24 @@ void FixTJunctions( entity_t *ent ){
Sys_FPrintf( SYS_VRB, "%9d degenerate edges\n", c_degenerateEdges );
// insert any needed vertexes
for ( i = ent->firstDrawSurf; i < numMapDrawSurfs ; i++ )
for ( int i = ent->firstDrawSurf; i < numMapDrawSurfs; ++i )
{
/* get surface and early out if possible */
ds = &mapDrawSurfs[ i ];
si = ds->shaderInfo;
if ( ( si->compileFlags & C_NODRAW ) || si->autosprite || si->notjunc || ds->numVerts == 0 || ds->type != ESurfaceType::Face ) {
mapDrawSurface_t& ds = mapDrawSurfs[ i ];
const shaderInfo_t *si = ds.shaderInfo;
if ( ( si->compileFlags & C_NODRAW ) || si->autosprite || si->notjunc || ds.numVerts == 0 || ds.type != ESurfaceType::Face ) {
continue;
}
/* ydnar: gs mods: handle the various types of surfaces */
switch ( ds->type )
switch ( ds.type )
{
/* handle brush faces */
case ESurfaceType::Face:
FixSurfaceJunctions( ds );
if ( !FixBrokenSurface( ds ) ) {
c_broken++;
ClearSurface( ds );
ClearSurface( &ds );
}
break;

410
tools/quake3/q3map2/vis.cpp
View File

@ -58,15 +58,10 @@ fixedWinding_t *NewFixedWinding( int numpoints ){
void prl( leaf_t *l ){
int i;
vportal_t *p;
visPlane_t pl;
for ( i = 0 ; i < l->numportals ; i++ )
for ( const vportal_t *p : Span( l->portals, l->numportals ) )
{
p = l->portals[i];
pl = p->plane;
Sys_Printf( "portal %4i to leaf %4i : %7.1f : (%4.1f, %4.1f, %4.1f)\n",(int)( p - portals ),p->leaf,pl.dist(), pl.normal()[0], pl.normal()[1], pl.normal()[2] );
const visPlane_t pl = p->plane;
Sys_Printf( "portal %4i to leaf %4i : %7.1f : (%4.1f, %4.1f, %4.1f)\n",(int)( p - portals ), p->leaf, pl.dist(), pl.normal()[0], pl.normal()[1], pl.normal()[2] );
}
}
@ -82,7 +77,7 @@ void prl( leaf_t *l ){
=============
*/
void SortPortals( void ){
for ( int i = 0 ; i < numportals * 2 ; i++ )
for ( int i = 0; i < numportals * 2; ++i )
sorted_portals[i] = &portals[i];
if ( !nosort ) {
@ -99,33 +94,25 @@ void SortPortals( void ){
==============
*/
int LeafVectorFromPortalVector( byte *portalbits, byte *leafbits ){
int i, j, leafnum;
vportal_t *p;
int c_leafs;
for ( i = 0 ; i < numportals * 2 ; i++ )
for ( int i = 0; i < numportals * 2; ++i )
{
if ( portalbits[i >> 3] & ( 1 << ( i & 7 ) ) ) {
p = portals + i;
leafbits[p->leaf >> 3] |= ( 1 << ( p->leaf & 7 ) );
const vportal_t& p = portals[i];
leafbits[p.leaf >> 3] |= ( 1 << ( p.leaf & 7 ) );
}
}
for ( j = 0; j < portalclusters; j++ )
for ( int i = 0; i < portalclusters; ++i )
{
leafnum = j;
int leafnum = i;
while ( leafs[leafnum].merged >= 0 )
leafnum = leafs[leafnum].merged;
//if the merged leaf is visible then the original leaf is visible
if ( leafbits[leafnum >> 3] & ( 1 << ( leafnum & 7 ) ) ) {
leafbits[j >> 3] |= ( 1 << ( j & 7 ) );
leafbits[i >> 3] |= ( 1 << ( i & 7 ) );
}
}
c_leafs = CountBits( leafbits, portalclusters );
return c_leafs;
return CountBits( leafbits, portalclusters ); //c_leafs
}
@ -138,13 +125,9 @@ int LeafVectorFromPortalVector( byte *portalbits, byte *leafbits ){
*/
static int clustersizehistogram[MAX_MAP_LEAFS] = {0};
void ClusterMerge( int leafnum ){
leaf_t *leaf;
byte portalvector[MAX_PORTALS / 8];
byte uncompressed[MAX_MAP_LEAFS / 8];
int i, j;
int numvis, mergedleafnum;
vportal_t *p;
int pnum;
// OR together all the portalvis bits
@ -153,10 +136,9 @@ void ClusterMerge( int leafnum ){
mergedleafnum = leafs[mergedleafnum].merged;
memset( portalvector, 0, portalbytes );
leaf = &leafs[mergedleafnum];
for ( i = 0; i < leaf->numportals; i++ )
for ( const vportal_t *p : Span( leafs[mergedleafnum].portals, leafs[mergedleafnum].numportals ) )
{
p = leaf->portals[i];
if ( p->removed ) {
continue;
}
@ -164,9 +146,9 @@ void ClusterMerge( int leafnum ){
if ( p->status != EVStatus::Done ) {
Error( "portal not done" );
}
for ( j = 0 ; j < portallongs ; j++ )
for ( int j = 0; j < portallongs; ++j )
( (long *)portalvector )[j] |= ( (long *)p->portalvis )[j];
pnum = p - portals;
const int pnum = p - portals;
portalvector[pnum >> 3] |= 1 << ( pnum & 7 );
}
@ -259,13 +241,11 @@ void CalcPassagePortalVis( void ){
==================
*/
void CalcFastVis( void ){
int i;
// fastvis just uses mightsee for a very loose bound
for ( i = 0 ; i < numportals * 2 ; i++ )
for ( vportal_t& p : Span( portals, numportals * 2 ) )
{
portals[i].portalvis = portals[i].portalflood;
portals[i].status = EVStatus::Done;
p.portalvis = p.portalflood;
p.status = EVStatus::Done;
}
}
@ -358,25 +338,23 @@ void CalcVis( void ){
SetPortalSphere
==================
*/
void SetPortalSphere( vportal_t *p ){
Vector3 total( 0 );
fixedWinding_t *w;
void SetPortalSphere( vportal_t& p ){
Vector3 origin( 0 );
w = p->winding;
for ( int i = 0; i < w->numpoints; i++ )
for ( const Vector3& point : Span( p.winding->points, p.winding->numpoints ) )
{
total += w->points[i];
origin += point;
}
total /= w->numpoints;
origin /= p.winding->numpoints;
double bestr = 0;
for ( int i = 0; i < w->numpoints; i++ )
for ( const Vector3& point : Span( p.winding->points, p.winding->numpoints ) )
{
value_maximize( bestr, vector3_length( w->points[i] - total ) );
value_maximize( bestr, vector3_length( point - origin ) );
}
p->origin = total;
p->radius = bestr;
p.origin = origin;
p.radius = bestr;
}
/*
@ -388,23 +366,21 @@ void SetPortalSphere( vportal_t *p ){
static bool Winding_PlanesConcave( const fixedWinding_t *w1, const fixedWinding_t *w2,
const Plane3f& plane1, const Plane3f& plane2 ){
int i;
if ( !w1 || !w2 ) {
return false;
}
// check if one of the points of winding 1 is at the front of the plane of winding 2
for ( i = 0; i < w1->numpoints; i++ )
for ( const Vector3& point : Span( w1->points, w1->numpoints ) )
{
if ( plane3_distance_to_point( plane2, w1->points[i] ) > WCONVEX_EPSILON ) {
if ( plane3_distance_to_point( plane2, point ) > WCONVEX_EPSILON ) {
return true;
}
}
// check if one of the points of winding 2 is at the front of the plane of winding 1
for ( i = 0; i < w2->numpoints; i++ )
for ( const Vector3& point : Span( w2->points, w2->numpoints ) )
{
if ( plane3_distance_to_point( plane1, w2->points[i] ) > WCONVEX_EPSILON ) {
if ( plane3_distance_to_point( plane1, point ) > WCONVEX_EPSILON ) {
return true;
}
}
@ -418,36 +394,19 @@ static bool Winding_PlanesConcave( const fixedWinding_t *w1, const fixedWinding_
============
*/
static bool TryMergeLeaves( int l1num, int l2num ){
int i, j, k, n, numportals;
leaf_t *l1, *l2;
vportal_t *p1, *p2;
vportal_t *portals[MAX_PORTALS_ON_LEAF];
for ( k = 0; k < 2; k++ )
for ( const leaf_t *l1 : { &faceleafs[l1num], &leafs[l1num] } )
{
if ( k ) {
l1 = &leafs[l1num];
}
else{
l1 = &faceleafs[l1num];
}
for ( i = 0; i < l1->numportals; i++ )
for ( const vportal_t *p1 : Span( l1->portals, l1->numportals ) )
{
p1 = l1->portals[i];
if ( p1->leaf == l2num ) {
continue;
}
for ( n = 0; n < 2; n++ )
for ( const leaf_t *l2 : { &faceleafs[l2num], &leafs[l2num] } )
{
if ( n ) {
l2 = &leafs[l2num];
}
else{
l2 = &faceleafs[l2num];
}
for ( j = 0; j < l2->numportals; j++ )
for ( const vportal_t *p2 : Span( l2->portals, l2->numportals ) )
{
p2 = l2->portals[j];
if ( p2->leaf == l1num ) {
continue;
}
@ -459,43 +418,31 @@ static bool TryMergeLeaves( int l1num, int l2num ){
}
}
}
for ( k = 0; k < 2; k++ )
for ( leaf_t *lfs : { faceleafs, leafs } )
{
if ( k ) {
l1 = &leafs[l1num];
l2 = &leafs[l2num];
}
else
{
l1 = &faceleafs[l1num];
l2 = &faceleafs[l2num];
}
numportals = 0;
leaf_t& l1 = lfs[l1num];
leaf_t& l2 = lfs[l2num];
int numportals = 0;
//the leaves can be merged now
for ( i = 0; i < l1->numportals; i++ )
for ( vportal_t *p1 : Span( l1.portals, l1.numportals ) )
{
p1 = l1->portals[i];
if ( p1->leaf == l2num ) {
p1->removed = true;
continue;
}
portals[numportals++] = p1;
}
for ( j = 0; j < l2->numportals; j++ )
for ( vportal_t *p2 : Span( l2.portals, l2.numportals ) )
{
p2 = l2->portals[j];
if ( p2->leaf == l1num ) {
p2->removed = true;
continue;
}
portals[numportals++] = p2;
}
for ( i = 0; i < numportals; i++ )
{
l2->portals[i] = portals[i];
}
l2->numportals = numportals;
l1->merged = l2num;
std::copy_n( portals, numportals, l2.portals );
l2.numportals = numportals;
l1.merged = l2num;
}
return true;
}
@ -506,18 +453,10 @@ static bool TryMergeLeaves( int l1num, int l2num ){
============
*/
void UpdatePortals( void ){
int i;
vportal_t *p;
for ( i = 0; i < numportals * 2; i++ )
{
p = &portals[i];
if ( p->removed ) {
continue;
}
while ( leafs[p->leaf].merged >= 0 )
p->leaf = leafs[p->leaf].merged;
}
for ( vportal_t& p : Span( portals, numportals * 2 ) )
if ( !p.removed )
while ( leafs[p.leaf].merged >= 0 )
p.leaf = leafs[p.leaf].merged;
}
/*
@ -528,40 +467,31 @@ void UpdatePortals( void ){
============
*/
void MergeLeaves( void ){
int i, j, nummerges, totalnummerges;
leaf_t *leaf;
vportal_t *p;
int nummerges, totalnummerges = 0;
totalnummerges = 0;
do
{
nummerges = 0;
for ( i = 0; i < portalclusters; i++ )
for ( int i = 0; i < portalclusters; ++i )
{
leaf = &leafs[i];
const leaf_t& leaf = leafs[i];
//if this leaf is merged already
/* ydnar: vmods: merge all non-hint portals */
if ( leaf->merged >= 0 && !hint ) {
if ( leaf.merged >= 0 && !hint ) {
continue;
}
for ( j = 0; j < leaf->numportals; j++ )
for ( const vportal_t *p : Span( leaf.portals, leaf.numportals ) )
{
p = leaf->portals[j];
//
if ( p->removed ) {
continue;
}
//never merge through hint portals
if ( p->hint ) {
continue;
}
if ( TryMergeLeaves( i, p->leaf ) ) {
UpdatePortals();
nummerges++;
break;
if ( !p->removed && !p->hint ) {
if ( TryMergeLeaves( i, p->leaf ) ) {
UpdatePortals();
nummerges++;
break;
}
}
}
}
@ -608,15 +538,15 @@ fixedWinding_t *TryMergeWinding( fixedWinding_t *f1, fixedWinding_t *f2, const V
if ( fabs( (*p2)[k] - (*p3)[k] ) > 0.1 ) { //EQUAL_EPSILON) //ME
break;
}
} //end for
}
if ( k == 3 ) {
break;
}
} //end for
}
if ( j < f2->numpoints ) {
break;
}
} //end for
}
if ( i == f1->numpoints ) {
return NULL; // no matching edges
@ -715,7 +645,7 @@ void MergeLeafPortals( void ){
hintsmerged++;
}
p1->hint |= p2->hint;
SetPortalSphere( p1 );
SetPortalSphere( *p1 );
p2->removed = true;
nummerges++;
i--;
@ -739,116 +669,30 @@ void MergeLeafPortals( void ){
============
*/
int CountActivePortals( void ){
int num, hints, j;
vportal_t *p;
int num = 0, hints = 0;
num = 0;
hints = 0;
for ( j = 0; j < numportals * 2; j++ )
for ( const vportal_t& p : Span( portals, numportals * 2 ) )
{
p = portals + j;
if ( p->removed ) {
continue;
if ( !p.removed ) {
num++;
if ( p.hint )
hints++;
}
if ( p->hint ) {
hints++;
}
num++;
}
Sys_Printf( "%6d active portals\n", num );
Sys_Printf( "%6d hint portals\n", hints );
return num;
}
/*
============
WritePortals
============
*/
void WriteFloat( FILE *f, float v );
void WritePortals( char *filename ){
int i, j, num;
vportal_t *p;
fixedWinding_t *w;
// write the file
FILE *pf = SafeOpenWrite( filename, "wt" );
num = 0;
for ( j = 0; j < numportals * 2; j++ )
{
p = portals + j;
if ( p->removed ) {
continue;
}
// if (!p->hint)
// continue;
num++;
}
fprintf( pf, "%s\n", PORTALFILE );
fprintf( pf, "%i\n", 0 );
fprintf( pf, "%i\n", num ); // + numfaces);
fprintf( pf, "%i\n", 0 );
for ( j = 0; j < numportals * 2; j++ )
{
p = portals + j;
if ( p->removed ) {
continue;
}
// if (!p->hint)
// continue;
w = p->winding;
fprintf( pf, "%i %i %i ",w->numpoints, 0, 0 );
fprintf( pf, "%d ", p->hint );
for ( i = 0 ; i < w->numpoints ; i++ )
{
fprintf( pf, "(" );
WriteFloat( pf, w->points[i][0] );
WriteFloat( pf, w->points[i][1] );
WriteFloat( pf, w->points[i][2] );
fprintf( pf, ") " );
}
fprintf( pf, "\n" );
}
/*
for (j = 0; j < numfaces; j++)
{
p = faces + j;
w = p->winding;
fprintf (pf,"%i %i %i ",w->numpoints, 0, 0);
fprintf (pf, "0 ");
for (i=0 ; i<w->numpoints ; i++)
{
fprintf (pf,"(");
WriteFloat (pf, w->points[i][0]);
WriteFloat (pf, w->points[i][1]);
WriteFloat (pf, w->points[i][2]);
fprintf (pf,") ");
}
fprintf (pf,"\n");
}*/
fclose( pf );
}
/*
============
LoadPortals
============
*/
void LoadPortals( char *name ){
int i, j, flags;
vportal_t *p;
leaf_t *l;
char magic[80];
FILE *f;
int numpoints;
fixedWinding_t *w;
int leafnums[2];
int numpoints, leafnums[2], flags;
if ( strEqual( name, "-" ) ) {
f = stdin;
@ -883,8 +727,8 @@ void LoadPortals( char *name ){
portals = safe_calloc( 2 * numportals * sizeof( vportal_t ) );
leafs = safe_calloc( portalclusters * sizeof( leaf_t ) );
for ( i = 0; i < portalclusters; i++ )
leafs[i].merged = -1;
for ( leaf_t& leaf : Span( leafs, portalclusters ) )
leaf.merged = -1;
bspVisBytes.resize( VIS_HEADER_SIZE + portalclusters * leafbytes );
@ -895,7 +739,7 @@ void LoadPortals( char *name ){
( (int *)bspVisBytes.data() )[0] = portalclusters;
( (int *)bspVisBytes.data() )[1] = leafbytes;
for ( i = 0, p = portals ; i < numportals ; i++ )
for ( int i = 0; i < numportals; ++i )
{
if ( fscanf( f, "%i %i %i ", &numpoints, &leafnums[0], &leafnums[1] ) != 3 ) {
Error( "LoadPortals: reading portal %i", i );
@ -911,13 +755,13 @@ void LoadPortals( char *name ){
Error( "LoadPortals: reading flags" );
}
w = p->winding = NewFixedWinding( numpoints );
fixedWinding_t *w = NewFixedWinding( numpoints );
w->numpoints = numpoints;
for ( j = 0 ; j < numpoints ; j++ )
for ( Vector3& point : Span( w->points, w->numpoints ) )
{
if ( fscanf( f, "(%f %f %f ) ",
&w->points[j][0], &w->points[j][1], &w->points[j][2] ) != 3 ) {
&point[0], &point[1], &point[2] ) != 3 ) {
Error( "LoadPortals: reading portal %i", i );
}
}
@ -929,62 +773,62 @@ void LoadPortals( char *name ){
const visPlane_t plane = PlaneFromWinding( w );
// create forward portal
l = &leafs[leafnums[0]];
if ( l->numportals == MAX_PORTALS_ON_LEAF ) {
Error( "Leaf with too many portals" );
}
l->portals[l->numportals] = p;
l->numportals++;
{
vportal_t& p = portals[i * 2];
p.num = i + 1;
p.hint = ((flags & 1) != 0);
p.sky = ((flags & 2) != 0);
p.winding = w;
p.plane = plane3_flipped( plane );
p.leaf = leafnums[1];
SetPortalSphere( p );
p->num = i + 1;
p->hint = ((flags & 1) != 0);
p->sky = ((flags & 2) != 0);
p->winding = w;
p->plane = plane3_flipped( plane );
p->leaf = leafnums[1];
SetPortalSphere( p );
p++;
leaf_t& l = leafs[leafnums[0]];
if ( l.numportals == MAX_PORTALS_ON_LEAF ) {
Error( "Leaf with too many portals" );
}
l.portals[l.numportals] = &p;
l.numportals++;
}
// create backwards portal
l = &leafs[leafnums[1]];
if ( l->numportals == MAX_PORTALS_ON_LEAF ) {
Error( "Leaf with too many portals" );
}
l->portals[l->numportals] = p;
l->numportals++;
p->num = i + 1;
p->hint = hint;
p->winding = NewFixedWinding( w->numpoints );
p->winding->numpoints = w->numpoints;
for ( j = 0 ; j < w->numpoints ; j++ )
{
p->winding->points[j] = w->points[w->numpoints - 1 - j];
vportal_t& p = portals[i * 2 + 1];
p.num = i + 1;
p.hint = hint;
p.winding = NewFixedWinding( w->numpoints );
p.winding->numpoints = w->numpoints;
std::reverse_copy( w->points, w->points + w->numpoints, p.winding->points );
p.plane = plane;
p.leaf = leafnums[0];
SetPortalSphere( p );
leaf_t& l = leafs[leafnums[1]];
if ( l.numportals == MAX_PORTALS_ON_LEAF ) {
Error( "Leaf with too many portals" );
}
l.portals[l.numportals] = &p;
l.numportals++;
}
p->plane = plane;
p->leaf = leafnums[0];
SetPortalSphere( p );
p++;
}
faces = safe_calloc( 2 * numfaces * sizeof( vportal_t ) );
faceleafs = safe_calloc( portalclusters * sizeof( leaf_t ) );
for ( i = 0, p = faces; i < numfaces; i++ )
for ( int i = 0; i < numfaces; ++i )
{
if ( fscanf( f, "%i %i ", &numpoints, &leafnums[0] ) != 2 ) {
Error( "LoadPortals: reading portal %i", i );
}
w = p->winding = NewFixedWinding( numpoints );
fixedWinding_t *w = NewFixedWinding( numpoints );
w->numpoints = numpoints;
for ( j = 0 ; j < numpoints ; j++ )
for ( Vector3& point : Span( w->points, w->numpoints ) )
{
if ( fscanf( f, "(%f %f %f ) ",
&w->points[j][0], &w->points[j][1], &w->points[j][2] ) != 3 ) {
&point[0], &point[1], &point[2] ) != 3 ) {
Error( "LoadPortals: reading portal %i", i );
}
}
@ -992,24 +836,21 @@ void LoadPortals( char *name ){
// silence gcc warning
}
// calc plane
const visPlane_t plane = PlaneFromWinding( w );
vportal_t& p = faces[i];
p.num = i + 1;
p.winding = w;
// normal pointing out of the leaf
p.plane = plane3_flipped( PlaneFromWinding( w ) );
p.leaf = -1;
SetPortalSphere( p );
l = &faceleafs[leafnums[0]];
l->merged = -1;
if ( l->numportals == MAX_PORTALS_ON_LEAF ) {
leaf_t& l = faceleafs[leafnums[0]];
l.merged = -1;
if ( l.numportals == MAX_PORTALS_ON_LEAF ) {
Error( "Leaf with too many faces" );
}
l->portals[l->numportals] = p;
l->numportals++;
p->num = i + 1;
p->winding = w;
// normal pointing out of the leaf
p->plane = plane3_flipped( plane );
p->leaf = -1;
SetPortalSphere( p );
p++;
l.portals[l.numportals] = &p;
l.numportals++;
}
fclose( f );
@ -1116,7 +957,6 @@ int VisMain( Args& args ){
}
CountActivePortals();
/* WritePortals( "maps/hints.prs" );*/
Sys_Printf( "visdatasize:%zu\n", bspVisBytes.size() );

80
tools/quake3/q3map2/visflow.cpp
View File

@ -54,11 +54,8 @@
*/
int CountBits( byte *bits, int numbits ){
int i;
int c;
c = 0;
for ( i = 0 ; i < numbits ; i++ )
int c = 0;
for ( int i = 0; i < numbits; ++i )
if ( bits[i >> 3] & ( 1 << ( i & 7 ) ) ) {
c++;
}
@ -68,15 +65,13 @@ int CountBits( byte *bits, int numbits ){
void CheckStack( leaf_t *leaf, threaddata_t *thread ){
pstack_t *p, *p2;
for ( p = thread->pstack_head.next ; p ; p = p->next )
for ( pstack_t *p = thread->pstack_head.next; p; p = p->next )
{
// Sys_Printf ("=");
if ( p->leaf == leaf ) {
Error( "CheckStack: leaf recursion" );
}
for ( p2 = thread->pstack_head.next ; p2 != p ; p2 = p2->next )
for ( pstack_t *p2 = thread->pstack_head.next; p2 != p; p2 = p2->next )
if ( p2->leaf == p->leaf ) {
Error( "CheckStack: late leaf recursion" );
}
@ -86,9 +81,7 @@ void CheckStack( leaf_t *leaf, threaddata_t *thread ){
fixedWinding_t *AllocStackWinding( pstack_t *stack ){
int i;
for ( i = 0 ; i < 3 ; i++ )
for ( int i = 0; i < 3; ++i )
{
if ( stack->freewindings[i] ) {
stack->freewindings[i] = 0;
@ -383,10 +376,9 @@ fixedWinding_t *ClipToSeperators( fixedWinding_t *source, fixedWinding_t *pass,
*/
void RecursiveLeafFlow( int leafnum, threaddata_t *thread, pstack_t *prevstack ){
pstack_t stack;
vportal_t *p;
visPlane_t backplane;
leaf_t *leaf;
int i, j, n;
int j, n;
long *test, *might, *prevmight, *vis, more;
int pnum;
@ -411,9 +403,8 @@ void RecursiveLeafFlow( int leafnum, threaddata_t *thread, pstack_t *prevstack )
vis = (long *)thread->base->portalvis;
// check all portals for flowing into other leafs
for ( i = 0; i < leaf->numportals; i++ )
for ( vportal_t *p : Span( leaf->portals, leaf->numportals ) )
{
p = leaf->portals[i];
if ( p->removed ) {
continue;
}
@ -1121,7 +1112,7 @@ fixedWinding_t *PassageChopWinding( fixedWinding_t *in, fixedWinding_t *out, con
AddSeperators
===============
*/
int AddSeperators( fixedWinding_t *source, fixedWinding_t *pass, bool flipclip, visPlane_t *seperators, int maxseperators ){
int AddSeperators( const fixedWinding_t *source, const fixedWinding_t *pass, bool flipclip, visPlane_t *seperators, int maxseperators ){
int i, j, k, l;
int counts[3], numseperators;
bool fliptest;
@ -1247,9 +1238,8 @@ int AddSeperators( fixedWinding_t *source, fixedWinding_t *pass, bool flipclip,
===============
*/
void CreatePassages( int portalnum ){
int i, j, k, n, numseperators, numsee;
vportal_t *portal, *p, *target;
leaf_t *leaf;
int j, k, n, numseperators, numsee;
vportal_t *portal, *p;
passage_t *passage, *lastpassage;
visPlane_t seperators[MAX_SEPERATORS * 2];
fixedWinding_t *w;
@ -1268,10 +1258,8 @@ void CreatePassages( int portalnum ){
}
lastpassage = NULL;
leaf = &leafs[portal->leaf];
for ( i = 0; i < leaf->numportals; i++ )
for ( const vportal_t *target : Span( leafs[portal->leaf].portals, leafs[portal->leaf].numportals ) )
{
target = leaf->portals[i];
if ( target->removed ) {
continue;
}
@ -1365,22 +1353,15 @@ void CreatePassages( int portalnum ){
}
void PassageMemory( void ){
int i, j, totalmem, totalportals;
vportal_t *portal, *target;
leaf_t *leaf;
int totalmem = 0, totalportals = 0;
totalmem = 0;
totalportals = 0;
for ( i = 0; i < numportals; i++ )
for ( const vportal_t *portal : Span( sorted_portals, numportals ) )
{
portal = sorted_portals[i];
if ( portal->removed ) {
continue;
}
leaf = &leafs[portal->leaf];
for ( j = 0; j < leaf->numportals; j++ )
for ( const vportal_t *target : Span( leafs[portal->leaf].portals, leafs[portal->leaf].numportals ) )
{
target = leaf->portals[j];
if ( target->removed ) {
continue;
}
@ -1443,20 +1424,12 @@ void PassageMemory( void ){
==================
*/
void SimpleFlood( vportal_t *srcportal, int leafnum ){
int i;
leaf_t *leaf;
vportal_t *p;
int pnum;
leaf = &leafs[leafnum];
for ( i = 0 ; i < leaf->numportals ; i++ )
for ( const vportal_t *p : Span( leafs[leafnum].portals, leafs[leafnum].numportals ) )
{
p = leaf->portals[i];
if ( p->removed ) {
continue;
}
pnum = p - portals;
const int pnum = p - portals;
if ( !( srcportal->portalfront[pnum >> 3] & ( 1 << ( pnum & 7 ) ) ) ) {
continue;
}
@ -1587,23 +1560,16 @@ void BasePortalVis( int portalnum ){
==================
*/
void RecursiveLeafBitFlow( int leafnum, byte *mightsee, byte *cansee ){
vportal_t *p;
leaf_t *leaf;
int i, j;
long more;
int pnum;
byte newmight[MAX_PORTALS / 8];
leaf = &leafs[leafnum];
// check all portals for flowing into other leafs
for ( i = 0 ; i < leaf->numportals ; i++ )
for ( const vportal_t *p : Span( leafs[leafnum].portals, leafs[leafnum].numportals ) )
{
p = leaf->portals[i];
if ( p->removed ) {
continue;
}
pnum = p - portals;
const int pnum = p - portals;
// if some previous portal can't see it, skip
if ( !( mightsee[pnum >> 3] & ( 1 << ( pnum & 7 ) ) ) ) {
@ -1611,12 +1577,12 @@ void RecursiveLeafBitFlow( int leafnum, byte *mightsee, byte *cansee ){
}
// if this portal can see some portals we mightsee, recurse
more = 0;
for ( j = 0 ; j < portallongs ; j++ )
long more = 0;
for ( int i = 0; i < portallongs; ++i )
{
( (long *)newmight )[j] = ( (long *)mightsee )[j]
& ( (long *)p->portalflood )[j];
more |= ( (long *)newmight )[j] & ~( (long *)cansee )[j];
( (long *)newmight )[i] = ( (long *)mightsee )[i]
& ( (long *)p->portalflood )[i];
more |= ( (long *)newmight )[i] & ~( (long *)cansee )[i];
}
if ( !more ) {