From 46427535647ad4c732cf3a86c4ac126706bd37ac Mon Sep 17 00:00:00 2001 From: Garux Date: Mon, 27 Sep 2021 06:14:12 +0300 Subject: [PATCH] std::vector bspDrawSurfaces --- tools/quake3/q3map2/autopk3.cpp | 14 +- tools/quake3/q3map2/bsp.cpp | 1 - tools/quake3/q3map2/bspfile_abstract.cpp | 67 ++-------- tools/quake3/q3map2/bspfile_ibsp.cpp | 152 ++++++--------------- tools/quake3/q3map2/bspfile_rbsp.cpp | 6 +- tools/quake3/q3map2/convert_ase.cpp | 57 ++++---- tools/quake3/q3map2/convert_bsp.cpp | 16 +-- tools/quake3/q3map2/convert_json.cpp | 7 +- tools/quake3/q3map2/convert_map.cpp | 21 ++- tools/quake3/q3map2/convert_obj.cpp | 35 ++--- tools/quake3/q3map2/light.cpp | 28 ++-- tools/quake3/q3map2/light_bounce.cpp | 14 +- tools/quake3/q3map2/light_trace.cpp | 6 +- tools/quake3/q3map2/light_ydnar.cpp | 44 +++--- tools/quake3/q3map2/lightmaps_ydnar.cpp | 6 +- tools/quake3/q3map2/main.cpp | 1 - tools/quake3/q3map2/q3map2.h | 26 ++-- tools/quake3/q3map2/shaders.cpp | 2 +- tools/quake3/q3map2/surface.cpp | 163 ++++++++++------------- tools/quake3/q3map2/surface_extra.cpp | 38 +++--- tools/quake3/q3map2/writebsp.cpp | 4 +- 21 files changed, 263 insertions(+), 445 deletions(-) diff --git a/tools/quake3/q3map2/autopk3.cpp b/tools/quake3/q3map2/autopk3.cpp index 18bc0fb9..520fd309 100644 --- a/tools/quake3/q3map2/autopk3.cpp +++ b/tools/quake3/q3map2/autopk3.cpp @@ -239,9 +239,9 @@ int pk3BSPMain( Args& args ){ std::vector drawsurfSHs( bspShaders.size(), false ); - for ( i = 0; i < numBSPDrawSurfaces; ++i ){ - drawsurfSHs[ bspDrawSurfaces[i].shaderNum ] = true; - //Sys_Printf( "%s\n", bspShaders[bspDrawSurfaces[i].shaderNum].shader ); + for ( const bspDrawSurface_t& surf : bspDrawSurfaces ){ + drawsurfSHs[ surf.shaderNum ] = true; + //Sys_Printf( "%s\n", bspShaders[surf.shaderNum].shader ); } StrList* pk3Shaders = StrList_allocate( 1024 ); @@ -911,8 +911,8 @@ int repackBSPMain( Args& args ){ std::vector drawsurfSHs( bspShaders.size(), false ); - for ( i = 0; i < numBSPDrawSurfaces; ++i ){ - drawsurfSHs[ bspDrawSurfaces[i].shaderNum ] = true; + for ( const bspDrawSurface_t& surf : bspDrawSurfaces ){ + drawsurfSHs[ surf.shaderNum ] = true; } for ( size_t i = 0; i < bspShaders.size(); ++i ){ @@ -977,9 +977,7 @@ int repackBSPMain( Args& args ){ Sys_Printf( "%s\n", pk3Sounds->s[i] ); } /* free partially loaded bsp data */ - free( bspDrawSurfaces ); - bspDrawSurfaces = NULL; - numBSPDrawSurfaces = 0; + bspDrawSurfaces.clear(); entities.clear(); numBSPEntities = 0; diff --git a/tools/quake3/q3map2/bsp.cpp b/tools/quake3/q3map2/bsp.cpp index 03a62b3a..b51a9000 100644 --- a/tools/quake3/q3map2/bsp.cpp +++ b/tools/quake3/q3map2/bsp.cpp @@ -648,7 +648,6 @@ int BSPMain( Args& args ){ Sys_Printf( "--- BSP ---\n" ); doingBSP = true; - SetDrawSurfacesBuffer(); mapDrawSurfs = safe_calloc( sizeof( mapDrawSurface_t ) * MAX_MAP_DRAW_SURFS ); numMapDrawSurfs = 0; diff --git a/tools/quake3/q3map2/bspfile_abstract.cpp b/tools/quake3/q3map2/bspfile_abstract.cpp index 1512570c..6344f006 100644 --- a/tools/quake3/q3map2/bspfile_abstract.cpp +++ b/tools/quake3/q3map2/bspfile_abstract.cpp @@ -51,38 +51,6 @@ -/* FIXME: remove the functions below that handle memory management of bsp file chunks */ - -int numBSPDrawSurfacesBuffer = 0; -void SetDrawSurfacesBuffer(){ - free( bspDrawSurfaces ); - - numBSPDrawSurfacesBuffer = MAX_MAP_DRAW_SURFS; - - bspDrawSurfaces = safe_calloc_info( sizeof( bspDrawSurface_t ) * numBSPDrawSurfacesBuffer, "IncDrawSurfaces" ); -} - -void SetDrawSurfaces( int n ){ - free( bspDrawSurfaces ); - - numBSPDrawSurfaces = - numBSPDrawSurfacesBuffer = n; - - bspDrawSurfaces = safe_calloc_info( sizeof( bspDrawSurface_t ) * numBSPDrawSurfacesBuffer, "IncDrawSurfaces" ); -} - -void BSPFilesCleanup(){ - bspDrawVerts.clear(); - free( bspDrawSurfaces ); - bspLightBytes.clear(); - bspGridPoints.clear(); -} - - - - - - /* SwapBlock() if all values are 32 bits, this can be used to swap everything @@ -193,7 +161,7 @@ void SwapBSPFile( void ){ /* drawsurfs */ /* note: rbsp files (and hence q3map2 abstract bsp) have byte lightstyles index arrays, this follows sof2map convention */ - SwapBlock( (int*) bspDrawSurfaces, numBSPDrawSurfaces * sizeof( bspDrawSurfaces[ 0 ] ) ); + SwapBlock( bspDrawSurfaces ); /* fogs */ for ( i = 0; i < numBSPFogs; i++ ) @@ -348,26 +316,7 @@ void PartialLoadBSPFile( const char *filename ){ /* load it, then byte swap the in-memory version */ //g_game->load( filename ); PartialLoadIBSPFile( filename ); - - /* PartialSwapBSPFile() */ - - /* shaders (don't swap the name) */ - for ( bspShader_t& shader : bspShaders ) - { - shader.contentFlags = LittleLong( shader.contentFlags ); - shader.surfaceFlags = LittleLong( shader.surfaceFlags ); - } - - /* drawsurfs */ - /* note: rbsp files (and hence q3map2 abstract bsp) have byte lightstyles index arrays, this follows sof2map convention */ - SwapBlock( (int*) bspDrawSurfaces, numBSPDrawSurfaces * sizeof( bspDrawSurfaces[ 0 ] ) ); - - /* fogs */ - for ( int i = 0; i < numBSPFogs; i++ ) - { - bspFogs[ i ].brushNum = LittleLong( bspFogs[ i ].brushNum ); - bspFogs[ i ].visibleSide = LittleLong( bspFogs[ i ].visibleSide ); - } + SwapBSPFile(); } /* @@ -412,12 +361,12 @@ void PrintBSPFileSizes( void ){ ParseEntities(); } int patchCount = 0, planarCount = 0, trisoupCount = 0; - for ( const bspDrawSurface_t *s = bspDrawSurfaces; s != bspDrawSurfaces + numBSPDrawSurfaces; ++s ){ - if ( s->surfaceType == MST_PATCH ) + for ( const bspDrawSurface_t& s : bspDrawSurfaces ){ + if ( s.surfaceType == MST_PATCH ) ++patchCount; - else if ( s->surfaceType == MST_PLANAR ) + else if ( s.surfaceType == MST_PLANAR ) ++planarCount; - else if ( s->surfaceType == MST_TRIANGLE_SOUP ) + else if ( s.surfaceType == MST_TRIANGLE_SOUP ) ++trisoupCount; } /* note that this is abstracted */ @@ -450,8 +399,8 @@ void PrintBSPFileSizes( void ){ bspLeafBrushes.size(), bspLeafBrushes.size() * sizeof( bspLeafBrushes[0] ) ); Sys_Printf( "\n" ); - Sys_Printf( "%9d drawsurfaces %9d *\n", - numBSPDrawSurfaces, (int) ( numBSPDrawSurfaces * sizeof( *bspDrawSurfaces ) ) ); + Sys_Printf( "%9zu drawsurfaces %9zu *\n", + bspDrawSurfaces.size(), bspDrawSurfaces.size() * sizeof( bspDrawSurfaces[0] ) ); Sys_Printf( "%9d patch surfaces\n", patchCount ); Sys_Printf( "%9d planar surfaces\n", diff --git a/tools/quake3/q3map2/bspfile_ibsp.cpp b/tools/quake3/q3map2/bspfile_ibsp.cpp index c3842013..c9dbf25e 100644 --- a/tools/quake3/q3map2/bspfile_ibsp.cpp +++ b/tools/quake3/q3map2/bspfile_ibsp.cpp @@ -112,113 +112,49 @@ struct ibspDrawSurface_t int patchWidth; int patchHeight; + ibspDrawSurface_t( const bspDrawSurface_t& other ) : + shaderNum( other.shaderNum ), + fogNum( other.fogNum ), + surfaceType( other.surfaceType ), + firstVert( other.firstVert ), + numVerts( other.numVerts ), + firstIndex( other.firstIndex ), + numIndexes( other.numIndexes ), + lightmapNum( other.lightmapNum[0] ), + lightmapX( other.lightmapX[0] ), + lightmapY( other.lightmapY[0] ), + lightmapWidth( other.lightmapWidth ), + lightmapHeight( other.lightmapHeight ), + lightmapOrigin( other.lightmapOrigin ), + lightmapVecs{ other.lightmapVecs[0], other.lightmapVecs[1], other.lightmapVecs[2] }, + patchWidth( other.patchWidth ), + patchHeight( other.patchHeight ) {} + operator bspDrawSurface_t() const { + static_assert( MAX_LIGHTMAPS == 4 ); + return{ + shaderNum, + fogNum, + surfaceType, + firstVert, + numVerts, + firstIndex, + numIndexes, + { LS_NORMAL, LS_NONE, LS_NONE, LS_NONE }, + { LS_NORMAL, LS_NONE, LS_NONE, LS_NONE }, + { lightmapNum, -3, -3, -3 }, + { lightmapX, 0, 0, 0 }, + { lightmapY, 0, 0, 0 }, + lightmapWidth, + lightmapHeight, + lightmapOrigin, + { lightmapVecs[0], lightmapVecs[1], lightmapVecs[2] }, + patchWidth, + patchHeight + }; + } }; -static void CopyDrawSurfacesLump( ibspHeader_t *header ){ - int i, j; - ibspDrawSurface_t *in; - bspDrawSurface_t *out; - - - /* get count */ - numBSPDrawSurfaces = GetLumpElements( (bspHeader_t*) header, LUMP_SURFACES, sizeof( *in ) ); - SetDrawSurfaces( numBSPDrawSurfaces ); - - /* copy */ - in = GetLump( (bspHeader_t*) header, LUMP_SURFACES ); - out = bspDrawSurfaces; - for ( i = 0; i < numBSPDrawSurfaces; i++ ) - { - out->shaderNum = in->shaderNum; - out->fogNum = in->fogNum; - out->surfaceType = in->surfaceType; - out->firstVert = in->firstVert; - out->numVerts = in->numVerts; - out->firstIndex = in->firstIndex; - out->numIndexes = in->numIndexes; - - out->lightmapStyles[ 0 ] = LS_NORMAL; - out->vertexStyles[ 0 ] = LS_NORMAL; - out->lightmapNum[ 0 ] = in->lightmapNum; - out->lightmapX[ 0 ] = in->lightmapX; - out->lightmapY[ 0 ] = in->lightmapY; - - for ( j = 1; j < MAX_LIGHTMAPS; j++ ) - { - out->lightmapStyles[ j ] = LS_NONE; - out->vertexStyles[ j ] = LS_NONE; - out->lightmapNum[ j ] = -3; - out->lightmapX[ j ] = 0; - out->lightmapY[ j ] = 0; - } - - out->lightmapWidth = in->lightmapWidth; - out->lightmapHeight = in->lightmapHeight; - - out->lightmapOrigin = in->lightmapOrigin; - out->lightmapVecs[ 0 ] = in->lightmapVecs[ 0 ]; - out->lightmapVecs[ 1 ] = in->lightmapVecs[ 1 ]; - out->lightmapVecs[ 2 ] = in->lightmapVecs[ 2 ]; - - out->patchWidth = in->patchWidth; - out->patchHeight = in->patchHeight; - - in++; - out++; - } -} - - -static void AddDrawSurfacesLump( FILE *file, ibspHeader_t *header ){ - int i, size; - bspDrawSurface_t *in; - ibspDrawSurface_t *buffer, *out; - - - /* allocate output buffer */ - size = numBSPDrawSurfaces * sizeof( *buffer ); - buffer = safe_calloc( size ); - - /* convert */ - in = bspDrawSurfaces; - out = buffer; - for ( i = 0; i < numBSPDrawSurfaces; i++ ) - { - out->shaderNum = in->shaderNum; - out->fogNum = in->fogNum; - out->surfaceType = in->surfaceType; - out->firstVert = in->firstVert; - out->numVerts = in->numVerts; - out->firstIndex = in->firstIndex; - out->numIndexes = in->numIndexes; - - out->lightmapNum = in->lightmapNum[ 0 ]; - out->lightmapX = in->lightmapX[ 0 ]; - out->lightmapY = in->lightmapY[ 0 ]; - out->lightmapWidth = in->lightmapWidth; - out->lightmapHeight = in->lightmapHeight; - - out->lightmapOrigin = in->lightmapOrigin; - out->lightmapVecs[ 0 ] = in->lightmapVecs[ 0 ]; - out->lightmapVecs[ 1 ] = in->lightmapVecs[ 1 ]; - out->lightmapVecs[ 2 ] = in->lightmapVecs[ 2 ]; - - out->patchWidth = in->patchWidth; - out->patchHeight = in->patchHeight; - - in++; - out++; - } - - /* write lump */ - AddLump( file, (bspHeader_t*) header, LUMP_SURFACES, buffer, size ); - - /* free buffer */ - free( buffer ); -} - - /* drawverts */ struct ibspDrawVert_t @@ -234,7 +170,7 @@ struct ibspDrawVert_t lightmap( other.lightmap[0] ), normal( other.normal ), color( other.color[0] ) {} - operator bspDrawVert_t() { + operator bspDrawVert_t() const { static_assert( MAX_LIGHTMAPS == 4 ); return { xyz, @@ -315,7 +251,7 @@ void LoadIBSPFile( const char *filename ){ CopyLump( (bspHeader_t*) header, LUMP_DRAWVERTS, bspDrawVerts ); - CopyDrawSurfacesLump( header ); + CopyLump( (bspHeader_t*) header, LUMP_SURFACES, bspDrawSurfaces ); numBSPFogs = CopyLump( (bspHeader_t*) header, LUMP_FOGS, bspFogs, sizeof( bspFog_t ) ); // TODO fix overflow @@ -367,7 +303,7 @@ void PartialLoadIBSPFile( const char *filename ){ /* load/convert lumps */ CopyLump( (bspHeader_t*) header, LUMP_SHADERS, bspShaders ); - CopyDrawSurfacesLump( header ); + CopyLump( (bspHeader_t*) header, LUMP_SURFACES, bspDrawSurfaces ); numBSPFogs = CopyLump( (bspHeader_t*) header, LUMP_FOGS, bspFogs, sizeof( bspFog_t ) ); // TODO fix overflow @@ -421,7 +357,7 @@ void WriteIBSPFile( const char *filename ){ AddLump( file, header->lumps[LUMP_LEAFBRUSHES], bspLeafBrushes ); AddLump( file, header->lumps[LUMP_MODELS], bspModels ); AddLump( file, header->lumps[LUMP_DRAWVERTS], std::vector( bspDrawVerts.begin(), bspDrawVerts.end() ) ); - AddDrawSurfacesLump( file, header ); + AddLump( file, header->lumps[LUMP_SURFACES], std::vector( bspDrawSurfaces.begin(), bspDrawSurfaces.end() ) ); AddLump( file, header->lumps[LUMP_VISIBILITY], bspVisBytes ); AddLump( file, header->lumps[LUMP_LIGHTMAPS], bspLightBytes ); AddLump( file, header->lumps[LUMP_LIGHTGRID], std::vector( bspGridPoints.begin(), bspGridPoints.end() ) ); diff --git a/tools/quake3/q3map2/bspfile_rbsp.cpp b/tools/quake3/q3map2/bspfile_rbsp.cpp index 8e6e6da3..9eb77735 100644 --- a/tools/quake3/q3map2/bspfile_rbsp.cpp +++ b/tools/quake3/q3map2/bspfile_rbsp.cpp @@ -217,9 +217,7 @@ void LoadRBSPFile( const char *filename ){ CopyLump( (bspHeader_t*) header, LUMP_DRAWVERTS, bspDrawVerts ); - numBSPDrawSurfaces = GetLumpElements( (bspHeader_t*) header, LUMP_SURFACES, sizeof( bspDrawSurfaces[ 0 ] ) ); - SetDrawSurfaces( numBSPDrawSurfaces ); - CopyLump( (bspHeader_t*) header, LUMP_SURFACES, bspDrawSurfaces, sizeof( bspDrawSurfaces[ 0 ] ) ); + CopyLump( (bspHeader_t*) header, LUMP_SURFACES, bspDrawSurfaces ); numBSPFogs = CopyLump( (bspHeader_t*) header, LUMP_FOGS, bspFogs, sizeof( bspFogs[ 0 ] ) ); @@ -283,7 +281,7 @@ void WriteRBSPFile( const char *filename ){ AddLump( file, header->lumps[LUMP_LEAFBRUSHES], bspLeafBrushes ); AddLump( file, header->lumps[LUMP_MODELS], bspModels ); AddLump( file, header->lumps[LUMP_DRAWVERTS], bspDrawVerts ); - AddLump( file, (bspHeader_t*) header, LUMP_SURFACES, bspDrawSurfaces, numBSPDrawSurfaces * sizeof( bspDrawSurfaces[ 0 ] ) ); + AddLump( file, header->lumps[LUMP_SURFACES], bspDrawSurfaces ); AddLump( file, header->lumps[LUMP_VISIBILITY], bspVisBytes ); AddLump( file, header->lumps[LUMP_LIGHTMAPS], bspLightBytes ); AddLightGridLumps( file, header ); diff --git a/tools/quake3/q3map2/convert_ase.cpp b/tools/quake3/q3map2/convert_ase.cpp index ae2dac69..320c2c65 100644 --- a/tools/quake3/q3map2/convert_ase.cpp +++ b/tools/quake3/q3map2/convert_ase.cpp @@ -41,17 +41,17 @@ int numLightmapsASE = 0; -static void ConvertSurface( FILE *f, int modelNum, bspDrawSurface_t *ds, int surfaceNum, const Vector3& origin, const std::vector& lmIndices ){ +static void ConvertSurface( FILE *f, int modelNum, int surfaceNum, const Vector3& origin, const std::vector& lmIndices ){ char name[ 1024 ]; - + const bspDrawSurface_t& ds = bspDrawSurfaces[ surfaceNum ]; /* ignore patches for now */ - if ( ds->surfaceType != MST_PLANAR && ds->surfaceType != MST_TRIANGLE_SOUP ) { + if ( ds.surfaceType != MST_PLANAR && ds.surfaceType != MST_TRIANGLE_SOUP ) { return; } /* print object header for each dsurf */ - sprintf( name, "mat%dmodel%dsurf%d", ds->shaderNum, modelNum, surfaceNum ); + sprintf( name, "mat%dmodel%dsurf%d", ds.shaderNum, modelNum, surfaceNum ); fprintf( f, "*GEOMOBJECT\t{\r\n" ); fprintf( f, "\t*NODE_NAME\t\"%s\"\r\n", name ); fprintf( f, "\t*NODE_TM\t{\r\n" ); @@ -69,9 +69,9 @@ static void ConvertSurface( FILE *f, int modelNum, bspDrawSurface_t *ds, int sur /* print mesh header */ fprintf( f, "\t*MESH\t{\r\n" ); fprintf( f, "\t\t*TIMEVALUE\t0\r\n" ); - fprintf( f, "\t\t*MESH_NUMVERTEX\t%d\r\n", ds->numVerts ); - fprintf( f, "\t\t*MESH_NUMFACES\t%d\r\n", ds->numIndexes / 3 ); - switch ( ds->surfaceType ) + fprintf( f, "\t\t*MESH_NUMVERTEX\t%d\r\n", ds.numVerts ); + fprintf( f, "\t\t*MESH_NUMFACES\t%d\r\n", ds.numIndexes / 3 ); + switch ( ds.surfaceType ) { case MST_PLANAR: fprintf( f, "\t\t*COMMENT\t\"SURFACETYPE\tMST_PLANAR\"\r\n" ); @@ -83,32 +83,32 @@ static void ConvertSurface( FILE *f, int modelNum, bspDrawSurface_t *ds, int sur /* export vertex xyz */ fprintf( f, "\t\t*MESH_VERTEX_LIST\t{\r\n" ); - for ( int i = 0; i < ds->numVerts; i++ ) + for ( int i = 0; i < ds.numVerts; i++ ) { - const bspDrawVert_t& dv = bspDrawVerts[ ds->firstVert + i ]; + const bspDrawVert_t& dv = bspDrawVerts[ ds.firstVert + i ]; fprintf( f, "\t\t\t*MESH_VERTEX\t%d\t%f\t%f\t%f\r\n", i, dv.xyz[ 0 ], dv.xyz[ 1 ], dv.xyz[ 2 ] ); } fprintf( f, "\t\t}\r\n" ); /* export faces */ fprintf( f, "\t\t*MESH_FACE_LIST\t{\r\n" ); - for ( int i = 0; i < ds->numIndexes; i += 3 ) + for ( int i = 0; i < ds.numIndexes; i += 3 ) { const int face = ( i / 3 ); - const int a = bspDrawIndexes[ i + ds->firstIndex ]; - const int c = bspDrawIndexes[ i + ds->firstIndex + 1 ]; - const int b = bspDrawIndexes[ i + ds->firstIndex + 2 ]; + const int a = bspDrawIndexes[ i + ds.firstIndex ]; + const int c = bspDrawIndexes[ i + ds.firstIndex + 1 ]; + const int b = bspDrawIndexes[ i + ds.firstIndex + 2 ]; fprintf( f, "\t\t\t*MESH_FACE\t%d\tA:\t%d\tB:\t%d\tC:\t%d\tAB:\t1\tBC:\t1\tCA:\t1\t*MESH_SMOOTHING\t0\t*MESH_MTLID\t0\r\n", face, a, b, c ); } fprintf( f, "\t\t}\r\n" ); /* export vertex st */ - fprintf( f, "\t\t*MESH_NUMTVERTEX\t%d\r\n", ds->numVerts ); + fprintf( f, "\t\t*MESH_NUMTVERTEX\t%d\r\n", ds.numVerts ); fprintf( f, "\t\t*MESH_TVERTLIST\t{\r\n" ); - for ( int i = 0; i < ds->numVerts; i++ ) + for ( int i = 0; i < ds.numVerts; i++ ) { - const bspDrawVert_t& dv = bspDrawVerts[ ds->firstVert + i ]; + const bspDrawVert_t& dv = bspDrawVerts[ ds.firstVert + i ]; if ( lightmapsAsTexcoord ) { fprintf( f, "\t\t\t*MESH_TVERT\t%d\t%f\t%f\t%f\r\n", i, dv.lightmap[0][0], ( 1.0 - dv.lightmap[0][1] ), 1.0f ); // dv.lightmap[0][1] internal, ( 1.0 - dv.lightmap[0][1] ) external } @@ -119,26 +119,26 @@ static void ConvertSurface( FILE *f, int modelNum, bspDrawSurface_t *ds, int sur fprintf( f, "\t\t}\r\n" ); /* export texture faces */ - fprintf( f, "\t\t*MESH_NUMTVFACES\t%d\r\n", ds->numIndexes / 3 ); + fprintf( f, "\t\t*MESH_NUMTVFACES\t%d\r\n", ds.numIndexes / 3 ); fprintf( f, "\t\t*MESH_TFACELIST\t{\r\n" ); - for ( int i = 0; i < ds->numIndexes; i += 3 ) + for ( int i = 0; i < ds.numIndexes; i += 3 ) { const int face = ( i / 3 ); - const int a = bspDrawIndexes[ i + ds->firstIndex ]; - const int c = bspDrawIndexes[ i + ds->firstIndex + 1 ]; - const int b = bspDrawIndexes[ i + ds->firstIndex + 2 ]; + const int a = bspDrawIndexes[ i + ds.firstIndex ]; + const int c = bspDrawIndexes[ i + ds.firstIndex + 1 ]; + const int b = bspDrawIndexes[ i + ds.firstIndex + 2 ]; fprintf( f, "\t\t\t*MESH_TFACE\t%d\t%d\t%d\t%d\r\n", face, a, b, c ); } fprintf( f, "\t\t}\r\n" ); /* export vertex normals */ fprintf( f, "\t\t*MESH_NORMALS\t{\r\n" ); - for ( int i = 0; i < ds->numIndexes; i += 3 ) + for ( int i = 0; i < ds.numIndexes; i += 3 ) { const int face = ( i / 3 ); - const int a = bspDrawIndexes[ i + ds->firstIndex ]; - const int b = bspDrawIndexes[ i + ds->firstIndex + 1 ]; - const int c = bspDrawIndexes[ i + ds->firstIndex + 2 ]; + const int a = bspDrawIndexes[ i + ds.firstIndex ]; + const int b = bspDrawIndexes[ i + ds.firstIndex + 1 ]; + const int c = bspDrawIndexes[ i + ds.firstIndex + 2 ]; const Vector3 normal = VectorNormalized( bspDrawVerts[ a ].normal + bspDrawVerts[ b ].normal + bspDrawVerts[ c ].normal ); fprintf( f, "\t\t\t*MESH_FACENORMAL\t%d\t%f\t%f\t%f\r\n", face, normal[ 0 ], normal[ 1 ], normal[ 2 ] ); for( const auto idx : { a, b, c } ){ @@ -156,7 +156,7 @@ static void ConvertSurface( FILE *f, int modelNum, bspDrawSurface_t *ds, int sur fprintf( f, "\t*PROP_CASTSHADOW\t1\r\n" ); fprintf( f, "\t*PROP_RECVSHADOW\t1\r\n" ); if ( lightmapsAsTexcoord ) { - const int lmNum = ds->lightmapNum[0] >= 0? ds->lightmapNum[0]: lmIndices[ds->shaderNum] >= 0? lmIndices[ds->shaderNum] : ds->lightmapNum[0]; + const int lmNum = ds.lightmapNum[0] >= 0? ds.lightmapNum[0]: lmIndices[ds.shaderNum] >= 0? lmIndices[ds.shaderNum] : ds.lightmapNum[0]; if ( lmNum >= 0 && lmNum + (int)deluxemap < numLightmapsASE ) { fprintf( f, "\t*MATERIAL_REF\t%d\r\n", lmNum + deluxemap ); } @@ -165,7 +165,7 @@ static void ConvertSurface( FILE *f, int modelNum, bspDrawSurface_t *ds, int sur } } else{ - fprintf( f, "\t*MATERIAL_REF\t%d\r\n", ds->shaderNum ); + fprintf( f, "\t*MATERIAL_REF\t%d\r\n", ds.shaderNum ); } fprintf( f, "}\r\n" ); } @@ -183,8 +183,7 @@ static void ConvertModel( FILE *f, int modelNum, const Vector3& origin, const st /* go through each drawsurf in the model */ for ( int i = 0; i < model.numBSPSurfaces; i++ ) { - const int s = model.firstBSPSurface + i; - ConvertSurface( f, modelNum, &bspDrawSurfaces[ s ], s, origin, lmIndices ); + ConvertSurface( f, modelNum, model.firstBSPSurface + i, origin, lmIndices ); } } diff --git a/tools/quake3/q3map2/convert_bsp.cpp b/tools/quake3/q3map2/convert_bsp.cpp index 97a045cb..f779ef7e 100644 --- a/tools/quake3/q3map2/convert_bsp.cpp +++ b/tools/quake3/q3map2/convert_bsp.cpp @@ -374,7 +374,6 @@ static void ExtrapolateTexcoords( const float *axyz, const float *ast, */ int ScaleBSPMain( Args& args ){ - int i, j; float f, a; Vector3 scale; Vector3 vec; @@ -520,19 +519,19 @@ int ScaleBSPMain( Args& args ){ } if ( texscale ) { - for ( i = 0; i < numBSPDrawSurfaces; i++ ) + for ( const bspDrawSurface_t& surf : bspDrawSurfaces ) { - switch ( bspDrawSurfaces[i].surfaceType ) + switch ( surf.surfaceType ) { case MST_PLANAR: - if ( bspDrawSurfaces[i].numIndexes % 3 ) { + if ( surf.numIndexes % 3 ) { Error( "Not a triangulation!" ); } - for ( j = bspDrawSurfaces[i].firstIndex; j < bspDrawSurfaces[i].firstIndex + bspDrawSurfaces[i].numIndexes; j += 3 ) + for ( int j = surf.firstIndex; j < surf.firstIndex + surf.numIndexes; j += 3 ) { - const int ia = bspDrawIndexes[j] + bspDrawSurfaces[i].firstVert, - ib = bspDrawIndexes[j + 1] + bspDrawSurfaces[i].firstVert, - ic = bspDrawIndexes[j + 2] + bspDrawSurfaces[i].firstVert; + const int ia = bspDrawIndexes[j + 0] + surf.firstVert, + ib = bspDrawIndexes[j + 1] + surf.firstVert, + ic = bspDrawIndexes[j + 2] + surf.firstVert; bspDrawVert_t &a = bspDrawVerts[ia], &b = bspDrawVerts[ib], &c = bspDrawVerts[ic]; const float *oa = &old_xyzst[ia * 5], *ob = &old_xyzst[ib * 5], *oc = &old_xyzst[ic * 5]; // extrapolate: @@ -707,7 +706,6 @@ void PseudoCompileBSP( bool need_tree ){ facelist_t faces; tree_t tree{}; - SetDrawSurfacesBuffer(); mapDrawSurfs = safe_calloc( sizeof( mapDrawSurface_t ) * MAX_MAP_DRAW_SURFS ); numMapDrawSurfs = 0; diff --git a/tools/quake3/q3map2/convert_json.cpp b/tools/quake3/q3map2/convert_json.cpp index dd7c0883..3214c1fd 100644 --- a/tools/quake3/q3map2/convert_json.cpp +++ b/tools/quake3/q3map2/convert_json.cpp @@ -274,7 +274,7 @@ static void write_json( const char *directory ){ } { doc.RemoveAllMembers(); - for_indexed( auto&& surf : Span( bspDrawSurfaces, numBSPDrawSurfaces ) ){ + for_indexed( const auto& surf : bspDrawSurfaces ){ rapidjson::Value value( rapidjson::kObjectType ); value.AddMember( "shaderNum", surf.shaderNum, all ); value.AddMember( "fogNum", surf.fogNum, all ); @@ -477,9 +477,8 @@ static void read_json( const char *directory ){ } { const auto doc = load_json( StringOutputStream( 256 )( directory, "DrawSurfaces.json" ) ); - static std::vector items; for( auto&& obj : doc.GetObj() ){ - auto&& item = items.emplace_back(); + auto&& item = bspDrawSurfaces.emplace_back(); item.shaderNum = obj.value["shaderNum"].GetInt(); item.fogNum = obj.value["fogNum"].GetInt(); item.surfaceType = obj.value["surfaceType"].GetInt(); @@ -499,8 +498,6 @@ static void read_json( const char *directory ){ item.patchWidth = obj.value["patchWidth"].GetInt(); item.patchHeight = obj.value["patchHeight"].GetInt(); } - bspDrawSurfaces = items.data(); - numBSPDrawSurfaces = items.size(); } { const auto doc = load_json( StringOutputStream( 256 )( directory, "fogs.json" ) ); diff --git a/tools/quake3/q3map2/convert_map.cpp b/tools/quake3/q3map2/convert_map.cpp index 09fa7138..3b35dce5 100644 --- a/tools/quake3/q3map2/convert_map.cpp +++ b/tools/quake3/q3map2/convert_map.cpp @@ -48,9 +48,6 @@ static float Det3x3( float a00, float a01, float a02, } void GetBestSurfaceTriangleMatchForBrushside( const side_t& buildSide, const bspDrawVert_t *bestVert[3] ){ - bspDrawSurface_t *s; - int i; - int t; float best = 0; float thisarea; const bspDrawVert_t *vert[3]; @@ -61,20 +58,20 @@ void GetBestSurfaceTriangleMatchForBrushside( const side_t& buildSide, const bsp bestVert[0] = bestVert[1] = bestVert[2] = NULL; // brute force through all surfaces - for ( s = bspDrawSurfaces; s != bspDrawSurfaces + numBSPDrawSurfaces; ++s ) + for ( const bspDrawSurface_t& s : bspDrawSurfaces ) { - if ( s->surfaceType != MST_PLANAR && s->surfaceType != MST_TRIANGLE_SOUP ) { + if ( s.surfaceType != MST_PLANAR && s.surfaceType != MST_TRIANGLE_SOUP ) { continue; } - if ( !strEqual( buildSide.shaderInfo->shader, bspShaders[s->shaderNum].shader ) ) { + if ( !strEqual( buildSide.shaderInfo->shader, bspShaders[s.shaderNum].shader ) ) { continue; } - for ( t = 0; t + 3 <= s->numIndexes; t += 3 ) + for ( int t = 0; t + 3 <= s.numIndexes; t += 3 ) { - vert[0] = &bspDrawVerts[s->firstVert + bspDrawIndexes[s->firstIndex + t + 0]]; - vert[1] = &bspDrawVerts[s->firstVert + bspDrawIndexes[s->firstIndex + t + 1]]; - vert[2] = &bspDrawVerts[s->firstVert + bspDrawIndexes[s->firstIndex + t + 2]]; - if ( s->surfaceType == MST_PLANAR && VectorCompare( vert[0]->normal, vert[1]->normal ) && VectorCompare( vert[1]->normal, vert[2]->normal ) ) { + vert[0] = &bspDrawVerts[s.firstVert + bspDrawIndexes[s.firstIndex + t + 0]]; + vert[1] = &bspDrawVerts[s.firstVert + bspDrawIndexes[s.firstIndex + t + 1]]; + vert[2] = &bspDrawVerts[s.firstVert + bspDrawIndexes[s.firstIndex + t + 2]]; + if ( s.surfaceType == MST_PLANAR && VectorCompare( vert[0]->normal, vert[1]->normal ) && VectorCompare( vert[1]->normal, vert[2]->normal ) ) { if ( vector3_length( vert[0]->normal - buildPlane.normal() ) >= normalEpsilon || vector3_length( vert[1]->normal - buildPlane.normal() ) >= normalEpsilon || vector3_length( vert[2]->normal - buildPlane.normal() ) >= normalEpsilon ) { @@ -99,7 +96,7 @@ void GetBestSurfaceTriangleMatchForBrushside( const side_t& buildSide, const bsp } // Okay. Correct surface type, correct shader, correct plane. Let's start with the business... winding_t polygon( buildSide.winding ); - for ( i = 0; i < 3; ++i ) + for ( int i = 0; i < 3; ++i ) { // 0: 1, 2 // 1: 2, 0 diff --git a/tools/quake3/q3map2/convert_obj.cpp b/tools/quake3/q3map2/convert_obj.cpp index 6ce64121..719c0b3d 100644 --- a/tools/quake3/q3map2/convert_obj.cpp +++ b/tools/quake3/q3map2/convert_obj.cpp @@ -44,14 +44,16 @@ int lastLightmap = -1; int objVertexCount = 0; int objLastShaderNum = -1; -static void ConvertSurfaceToOBJ( FILE *f, int modelNum, bspDrawSurface_t *ds, int surfaceNum, const Vector3& origin, const std::vector& lmIndices ){ +static void ConvertSurfaceToOBJ( FILE *f, int modelNum, int surfaceNum, const Vector3& origin, const std::vector& lmIndices ){ + const bspDrawSurface_t& ds = bspDrawSurfaces[ surfaceNum ]; + /* ignore patches for now */ - if ( ds->surfaceType != MST_PLANAR && ds->surfaceType != MST_TRIANGLE_SOUP ) { + if ( ds.surfaceType != MST_PLANAR && ds.surfaceType != MST_TRIANGLE_SOUP ) { return; } - fprintf( f, "g mat%dmodel%dsurf%d\r\n", ds->shaderNum, modelNum, surfaceNum ); - switch ( ds->surfaceType ) + fprintf( f, "g mat%dmodel%dsurf%d\r\n", ds.shaderNum, modelNum, surfaceNum ); + switch ( ds.surfaceType ) { case MST_PLANAR: fprintf( f, "# SURFACETYPE MST_PLANAR\r\n" ); @@ -63,7 +65,7 @@ static void ConvertSurfaceToOBJ( FILE *f, int modelNum, bspDrawSurface_t *ds, in /* export shader */ if ( lightmapsAsTexcoord ) { - const int lmNum = ds->lightmapNum[0] >= 0? ds->lightmapNum[0]: lmIndices[ds->shaderNum] >= 0? lmIndices[ds->shaderNum] : ds->lightmapNum[0]; + const int lmNum = ds.lightmapNum[0] >= 0? ds.lightmapNum[0]: lmIndices[ds.shaderNum] >= 0? lmIndices[ds.shaderNum] : ds.lightmapNum[0]; if ( objLastShaderNum != lmNum ) { fprintf( f, "usemtl lm_%04d\r\n", lmNum + deluxemap ); objLastShaderNum = lmNum + deluxemap; @@ -79,16 +81,16 @@ static void ConvertSurfaceToOBJ( FILE *f, int modelNum, bspDrawSurface_t *ds, in } else { - if ( objLastShaderNum != ds->shaderNum ) { - fprintf( f, "usemtl %s\r\n", bspShaders[ds->shaderNum].shader ); - objLastShaderNum = ds->shaderNum; + if ( objLastShaderNum != ds.shaderNum ) { + fprintf( f, "usemtl %s\r\n", bspShaders[ds.shaderNum].shader ); + objLastShaderNum = ds.shaderNum; } } /* export vertex */ - for ( int i = 0; i < ds->numVerts; i++ ) + for ( int i = 0; i < ds.numVerts; i++ ) { - const bspDrawVert_t& dv = bspDrawVerts[ ds->firstVert + i ]; + const bspDrawVert_t& dv = bspDrawVerts[ ds.firstVert + i ]; fprintf( f, "# vertex %d\r\n", i + objVertexCount + 1 ); fprintf( f, "v %f %f %f\r\n", dv.xyz[ 0 ], dv.xyz[ 2 ], -dv.xyz[ 1 ] ); fprintf( f, "vn %f %f %f\r\n", dv.normal[ 0 ], dv.normal[ 2 ], -dv.normal[ 1 ] ); @@ -101,11 +103,11 @@ static void ConvertSurfaceToOBJ( FILE *f, int modelNum, bspDrawSurface_t *ds, in } /* export faces */ - for ( int i = 0; i < ds->numIndexes; i += 3 ) + for ( int i = 0; i < ds.numIndexes; i += 3 ) { - const int a = bspDrawIndexes[ i + ds->firstIndex ]; - const int c = bspDrawIndexes[ i + ds->firstIndex + 1 ]; - const int b = bspDrawIndexes[ i + ds->firstIndex + 2 ]; + const int a = bspDrawIndexes[ i + ds.firstIndex ]; + const int c = bspDrawIndexes[ i + ds.firstIndex + 1 ]; + const int b = bspDrawIndexes[ i + ds.firstIndex + 2 ]; fprintf( f, "f %d/%d/%d %d/%d/%d %d/%d/%d\r\n", a + objVertexCount + 1, a + objVertexCount + 1, a + objVertexCount + 1, b + objVertexCount + 1, b + objVertexCount + 1, b + objVertexCount + 1, @@ -113,7 +115,7 @@ static void ConvertSurfaceToOBJ( FILE *f, int modelNum, bspDrawSurface_t *ds, in ); } - objVertexCount += ds->numVerts; + objVertexCount += ds.numVerts; } @@ -129,8 +131,7 @@ static void ConvertModelToOBJ( FILE *f, int modelNum, const Vector3& origin, con /* go through each drawsurf in the model */ for ( int i = 0; i < model.numBSPSurfaces; i++ ) { - const int s = model.firstBSPSurface + i; - ConvertSurfaceToOBJ( f, modelNum, &bspDrawSurfaces[ s ], s, origin, lmIndices ); + ConvertSurfaceToOBJ( f, modelNum, model.firstBSPSurface + i, origin, lmIndices ); } } diff --git a/tools/quake3/q3map2/light.cpp b/tools/quake3/q3map2/light.cpp index e8babcb3..c9421277 100644 --- a/tools/quake3/q3map2/light.cpp +++ b/tools/quake3/q3map2/light.cpp @@ -467,11 +467,6 @@ void CreateEntityLights( void ){ #define APPROX_BOUNCE 1.0f void CreateSurfaceLights( void ){ - int i; - bspDrawSurface_t *ds; - surfaceInfo_t *info; - shaderInfo_t *si; - float subdivide; clipWork_t cw; @@ -479,25 +474,25 @@ void CreateSurfaceLights( void ){ const bool nss = entities[ 0 ].boolForKey( "_noshadersun" ); /* walk the list of surfaces */ - for ( i = 0; i < numBSPDrawSurfaces; i++ ) + for ( size_t i = 0; i < bspDrawSurfaces.size(); i++ ) { /* get surface and other bits */ - ds = &bspDrawSurfaces[ i ]; - info = &surfaceInfos[ i ]; - si = info->si; + bspDrawSurface_t *ds = &bspDrawSurfaces[ i ]; + surfaceInfo_t *info = &surfaceInfos[ i ]; + const shaderInfo_t *si = info->si; /* sunlight? */ if ( si->sun != NULL && !nss ) { Sys_FPrintf( SYS_VRB, "Sun: %s\n", si->shader.c_str() ); CreateSunLight( si->sun ); - si->sun = NULL; /* FIXME: leak! */ + const_cast( si )->sun = NULL; /* FIXME: leak! */ } /* sky light? */ if ( si->skyLightValue > 0.0f ) { Sys_FPrintf( SYS_VRB, "Sky: %s\n", si->shader.c_str() ); CreateSkyLights( si->color, si->skyLightValue, si->skyLightIterations, si->lightFilterRadius, si->lightStyle ); - si->skyLightValue = 0.0f; /* FIXME: hack! */ + const_cast( si )->skyLightValue = 0.0f; /* FIXME: hack! */ } /* try to early out */ @@ -527,12 +522,7 @@ void CreateSurfaceLights( void ){ } /* get subdivision amount */ - if ( si->lightSubdivide > 0 ) { - subdivide = si->lightSubdivide; - } - else{ - subdivide = defaultLightSubdivide; - } + const float subdivide = si->lightSubdivide > 0? si->lightSubdivide : defaultLightSubdivide; /* switch on type */ switch ( ds->surfaceType ) @@ -1819,7 +1809,7 @@ void LightWorld( bool fastAllocate ){ StitchSurfaceLightmaps(); Sys_Printf( "--- IlluminateVertexes ---\n" ); - RunThreadsOnIndividual( numBSPDrawSurfaces, true, IlluminateVertexes ); + RunThreadsOnIndividual( bspDrawSurfaces.size(), true, IlluminateVertexes ); Sys_Printf( "%9d vertexes illuminated\n", numVertsIlluminated ); /* ydnar: emit statistics on light culling */ @@ -1886,7 +1876,7 @@ void LightWorld( bool fastAllocate ){ StitchSurfaceLightmaps(); Sys_Printf( "--- IlluminateVertexes ---\n" ); - RunThreadsOnIndividual( numBSPDrawSurfaces, true, IlluminateVertexes ); + RunThreadsOnIndividual( bspDrawSurfaces.size(), true, IlluminateVertexes ); Sys_Printf( "%9d vertexes illuminated\n", numVertsIlluminated ); /* ydnar: emit statistics on light culling */ diff --git a/tools/quake3/q3map2/light_bounce.cpp b/tools/quake3/q3map2/light_bounce.cpp index 67f64ae4..a6b287f2 100644 --- a/tools/quake3/q3map2/light_bounce.cpp +++ b/tools/quake3/q3map2/light_bounce.cpp @@ -165,7 +165,7 @@ float Modulo1IfNegative( float f ){ returns false if pixels are bad */ -bool RadSampleImage( byte *pixels, int width, int height, const Vector2& st, Color4f& color ){ +bool RadSampleImage( const byte *pixels, int width, int height, const Vector2& st, Color4f& color ){ int x, y; /* clear color first */ @@ -207,7 +207,7 @@ bool RadSampleImage( byte *pixels, int width, int height, const Vector2& st, Col #define MAX_SAMPLES 150 #define SAMPLE_GRANULARITY 6 -static void RadSample( int lightmapNum, bspDrawSurface_t *ds, rawLightmap_t *lm, shaderInfo_t *si, radWinding_t *rw, Vector3& average, Vector3& gradient, int *style ){ +static void RadSample( int lightmapNum, bspDrawSurface_t *ds, rawLightmap_t *lm, const shaderInfo_t *si, radWinding_t *rw, Vector3& average, Vector3& gradient, int *style ){ int i, j, k, l, v, samples; Vector3 color; MinMax minmax; @@ -359,7 +359,7 @@ static void RadSample( int lightmapNum, bspDrawSurface_t *ds, rawLightmap_t *lm, -static void RadSubdivideDiffuseLight( int lightmapNum, bspDrawSurface_t *ds, rawLightmap_t *lm, shaderInfo_t *si, +static void RadSubdivideDiffuseLight( int lightmapNum, bspDrawSurface_t *ds, rawLightmap_t *lm, const shaderInfo_t *si, float scale, float subdivide, radWinding_t *rw, clipWork_t *cw ){ int i, style = 0; float dist, area, value; @@ -602,7 +602,7 @@ static void RadSubdivideDiffuseLight( int lightmapNum, bspDrawSurface_t *ds, raw creates unbounced diffuse lights for triangle soup (misc_models, etc) */ -void RadLightForTriangles( int num, int lightmapNum, rawLightmap_t *lm, shaderInfo_t *si, float scale, float subdivide, clipWork_t *cw ){ +void RadLightForTriangles( int num, int lightmapNum, rawLightmap_t *lm, const shaderInfo_t *si, float scale, float subdivide, clipWork_t *cw ){ int i, j, k, v; bspDrawSurface_t *ds; radWinding_t rw; @@ -646,7 +646,7 @@ void RadLightForTriangles( int num, int lightmapNum, rawLightmap_t *lm, shaderIn #define PLANAR_EPSILON 0.1f -void RadLightForPatch( 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, const shaderInfo_t *si, float scale, float subdivide, clipWork_t *cw ){ int i, x, y, v, t, pw[ 5 ], r; bspDrawSurface_t *ds; surfaceInfo_t *info; @@ -791,7 +791,7 @@ void RadLight( int num ){ bspDrawSurface_t *ds; surfaceInfo_t *info; rawLightmap_t *lm; - shaderInfo_t *si; + const shaderInfo_t *si; clipWork_t cw; @@ -869,7 +869,7 @@ void RadCreateDiffuseLights( void ){ numPatchDiffuseLights = 0; /* hit every surface (threaded) */ - RunThreadsOnIndividual( numBSPDrawSurfaces, true, RadLight ); + RunThreadsOnIndividual( bspDrawSurfaces.size(), true, RadLight ); /* dump the lights generated to a file */ if ( dump ) { diff --git a/tools/quake3/q3map2/light_trace.cpp b/tools/quake3/q3map2/light_trace.cpp index 49426e8b..dd947cef 100644 --- a/tools/quake3/q3map2/light_trace.cpp +++ b/tools/quake3/q3map2/light_trace.cpp @@ -63,7 +63,7 @@ struct traceVert_t struct traceInfo_t { - shaderInfo_t *si; + const shaderInfo_t *si; int surfaceNum, castShadows; bool skipGrid; }; @@ -1261,8 +1261,8 @@ bool TraceTriangle( traceInfo_t *ti, traceTriangle_t *tt, trace_t *trace ){ float det, invDet, depth; float u, v, w, s, t; int is, it; - byte *pixel; - shaderInfo_t *si; + const byte *pixel; + const shaderInfo_t *si; /* don't double-trace against sky */ diff --git a/tools/quake3/q3map2/light_ydnar.cpp b/tools/quake3/q3map2/light_ydnar.cpp index d51a33df..300465dc 100644 --- a/tools/quake3/q3map2/light_ydnar.cpp +++ b/tools/quake3/q3map2/light_ydnar.cpp @@ -157,7 +157,7 @@ Vector3b ColorToBytes( const Vector3& color, float scale ){ #define EQUAL_NORMAL_EPSILON 0.01f void SmoothNormals( void ){ - int i, j, k, f, fOld, start; + int fOld, start; float shadeAngle, defaultShadeAngle, maxShadeAngle; int indexes[ MAX_SAMPLES ]; Vector3 votes[ MAX_SAMPLES ]; @@ -176,7 +176,7 @@ void SmoothNormals( void ){ /* run through every surface and flag verts belonging to non-lightmapped surfaces and set per-vertex smoothing angle */ - for ( i = 0; i < numBSPDrawSurfaces; i++ ) + for ( size_t i = 0; i < bspDrawSurfaces.size(); ++i ) { /* get drawsurf */ bspDrawSurface_t& ds = bspDrawSurfaces[ i ]; @@ -192,9 +192,9 @@ void SmoothNormals( void ){ value_maximize( maxShadeAngle, shadeAngle ); /* flag its verts */ - for ( j = 0; j < ds.numVerts; j++ ) + for ( int j = 0; j < ds.numVerts; j++ ) { - f = ds.firstVert + j; + const int f = ds.firstVert + j; shadeAngles[ f ] = shadeAngle; if ( ds.surfaceType == MST_TRIANGLE_SOUP ) { smoothed[ f ] = true; @@ -218,11 +218,10 @@ void SmoothNormals( void ){ start = I_FloatTime(); /* go through the list of vertexes */ - for ( i = 0; i < numBSPDrawVerts; i++ ) + for ( int i = 0; i < numBSPDrawVerts; i++ ) { /* print pacifier */ - f = 10 * i / numBSPDrawVerts; - if ( f != fOld ) { + if ( const int f = 10 * i / numBSPDrawVerts; f != fOld ) { fOld = f; Sys_Printf( "%i...", f ); } @@ -238,7 +237,7 @@ void SmoothNormals( void ){ int numVotes = 0; /* build a table of coincident vertexes */ - for ( j = i; j < numBSPDrawVerts && numVerts < MAX_SAMPLES; j++ ) + for ( int j = i; j < numBSPDrawVerts && numVerts < MAX_SAMPLES; j++ ) { /* already smoothed? */ if ( smoothed[ j ] ) { @@ -268,6 +267,7 @@ void SmoothNormals( void ){ smoothed[ j ] = true; /* see if this normal has already been voted */ + int k; for ( k = 0; k < numVotes; k++ ) { if ( vector3_equal_epsilon( bspDrawVerts[ j ].normal, votes[ k ], EQUAL_NORMAL_EPSILON ) ) { @@ -291,7 +291,7 @@ void SmoothNormals( void ){ /* average normal */ if ( VectorNormalize( average ) != 0 ) { /* smooth */ - for ( j = 0; j < numVerts; j++ ) + for ( int j = 0; j < numVerts; j++ ) yDrawVerts[ indexes[ j ] ].normal = average; } } @@ -375,7 +375,7 @@ static bool CalcTangentVectors( int numVerts, bspDrawVert_t **dv, Vector3 *stv, perterbs the normal by the shader's normalmap in tangent space */ -static void PerturbNormal( bspDrawVert_t *dv, shaderInfo_t *si, Vector3& pNormal, const Vector3 stv[ 3 ], const Vector3 ttv[ 3 ] ){ +static void PerturbNormal( bspDrawVert_t *dv, const shaderInfo_t *si, Vector3& pNormal, const Vector3 stv[ 3 ], const Vector3 ttv[ 3 ] ){ /* passthrough */ pNormal = dv->normal; @@ -408,7 +408,7 @@ static void PerturbNormal( bspDrawVert_t *dv, shaderInfo_t *si, Vector3& pNormal static int MapSingleLuxel( rawLightmap_t *lm, surfaceInfo_t *info, bspDrawVert_t *dv, const Plane3f* plane, float pass, const Vector3 stv[ 3 ], const Vector3 ttv[ 3 ], const Vector3 worldverts[ 3 ] ){ int i, numClusters, *clusters, pointCluster; float lightmapSampleOffset; - shaderInfo_t *si; + const shaderInfo_t *si; Vector3 pNormal; Vector3 vecs[ 3 ]; Vector3 nudged; @@ -3676,35 +3676,29 @@ void FreeTraceLights( trace_t *trace ){ */ void CreateTraceLightsForSurface( int num, trace_t *trace ){ - int i; - bspDrawVert_t *dv; - bspDrawSurface_t *ds; - surfaceInfo_t *info; - - /* dummy check */ if ( num < 0 ) { return; } /* get drawsurface and info */ - ds = &bspDrawSurfaces[ num ]; - info = &surfaceInfos[ num ]; + const bspDrawSurface_t& ds = bspDrawSurfaces[ num ]; + const surfaceInfo_t& info = surfaceInfos[ num ]; /* get the mins/maxs for the dsurf */ MinMax minmax; - Vector3 normal = bspDrawVerts[ ds->firstVert ].normal; - for ( i = 0; i < ds->numVerts; i++ ) + Vector3 normal = bspDrawVerts[ ds.firstVert ].normal; + for ( int i = 0; i < ds.numVerts; i++ ) { - dv = &yDrawVerts[ ds->firstVert + i ]; - minmax.extend( dv->xyz ); - if ( !VectorCompare( dv->normal, normal ) ) { + const bspDrawVert_t& dv = yDrawVerts[ ds.firstVert + i ]; + minmax.extend( dv.xyz ); + if ( !VectorCompare( dv.normal, normal ) ) { normal.set( 0 ); } } /* create the lights for the bounding box */ - CreateTraceLightsForBounds( minmax, &normal, info->numSurfaceClusters, &surfaceClusters[ info->firstSurfaceCluster ], LightFlags::Surfaces, trace ); + CreateTraceLightsForBounds( minmax, &normal, info.numSurfaceClusters, &surfaceClusters[ info.firstSurfaceCluster ], LightFlags::Surfaces, trace ); } ///////////////////////////////////////////////////////////// diff --git a/tools/quake3/q3map2/lightmaps_ydnar.cpp b/tools/quake3/q3map2/lightmaps_ydnar.cpp index 79aa4df1..5260a9c4 100644 --- a/tools/quake3/q3map2/lightmaps_ydnar.cpp +++ b/tools/quake3/q3map2/lightmaps_ydnar.cpp @@ -930,6 +930,7 @@ void SetupSurfaceLightmaps( void ){ surfaceInfo_t *info, *info2; rawLightmap_t *lm; bool added; + const int numBSPDrawSurfaces = bspDrawSurfaces.size(); /* note it */ @@ -1068,7 +1069,6 @@ void SetupSurfaceLightmaps( void ){ { /* get info and attempt early out */ num = sortSurfaces[ i ]; - ds = &bspDrawSurfaces[ num ]; info = &surfaceInfos[ num ]; if ( !info->hasLightmap || info->lm != NULL || info->parentSurfaceNum >= 0 ) { continue; @@ -2343,7 +2343,7 @@ void StoreSurfaceLightmaps( bool fastAllocate ){ outLightmap_t *olm; bspDrawVert_t *dv, *ydv, *dvParent; char dirname[ 1024 ], filename[ 1024 ]; - shaderInfo_t *csi; + const shaderInfo_t *csi; char lightmapName[ 128 ]; const char *rgbGenValues[ 256 ] = {0}; const char *alphaGenValues[ 256 ] = {0}; @@ -3064,7 +3064,7 @@ void StoreSurfaceLightmaps( bool fastAllocate ){ timer_start = I_FloatTime(); /* walk the list of surfaces */ - for ( i = 0; i < numBSPDrawSurfaces; i++ ) + for ( size_t i = 0; i < bspDrawSurfaces.size(); ++i ) { /* get the surface and info */ ds = &bspDrawSurfaces[ i ]; diff --git a/tools/quake3/q3map2/main.cpp b/tools/quake3/q3map2/main.cpp index cc79a1a1..b38ba50e 100644 --- a/tools/quake3/q3map2/main.cpp +++ b/tools/quake3/q3map2/main.cpp @@ -47,7 +47,6 @@ static void ExitQ3Map( void ){ /* flush xml send buffer, shut down connection */ Broadcast_Shutdown(); - BSPFilesCleanup(); free( mapDrawSurfs ); } diff --git a/tools/quake3/q3map2/q3map2.h b/tools/quake3/q3map2/q3map2.h index 00c15fcd..a732c0cb 100644 --- a/tools/quake3/q3map2/q3map2.h +++ b/tools/quake3/q3map2/q3map2.h @@ -1142,7 +1142,7 @@ struct light_t { ELightType type; LightFlags flags; /* ydnar: condensed all the booleans into one flags int */ - shaderInfo_t *si; + const shaderInfo_t *si; Vector3 origin{ 0 }; Vector3 normal{ 0 }; /* for surfaces, spotlights, and suns */ @@ -1247,7 +1247,7 @@ struct outLightmap_t int numLightmaps; int freeLuxels; int numShaders; - shaderInfo_t *shaders[ MAX_LIGHTMAP_SHADERS ]; + const shaderInfo_t *shaders[ MAX_LIGHTMAP_SHADERS ]; byte *lightBits; Vector3b *bspLightBytes; Vector3b *bspDirBytes; @@ -1391,7 +1391,7 @@ struct rawGridPoint_t struct surfaceInfo_t { int modelindex; - shaderInfo_t *si; + const shaderInfo_t *si; rawLightmap_t *lm; int parentSurfaceNum, childSurfaceNum; int entityNum, castShadows, recvShadows, sampleSize, patchIterations; @@ -1705,9 +1705,9 @@ void EmitMetaStats(); // vortex: print meta statistics ev /* surface_extra.c */ void SetDefaultSampleSize( int sampleSize ); -void SetSurfaceExtra( mapDrawSurface_t *ds, int num ); +void SetSurfaceExtra( const mapDrawSurface_t& ds ); -shaderInfo_t *GetSurfaceExtraShaderInfo( int num ); +const shaderInfo_t *GetSurfaceExtraShaderInfo( int num ); int GetSurfaceExtraParentSurfaceNum( int num ); int GetSurfaceExtraEntityNum( int num ); int GetSurfaceExtraCastShadows( int num ); @@ -1759,9 +1759,9 @@ float SetupTrace( trace_t *trace ); /* light_bounce.c */ -bool RadSampleImage( byte * pixels, int width, int height, const Vector2& st, Color4f& color ); -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 ); +bool RadSampleImage( const byte * pixels, int width, int height, const Vector2& st, Color4f& color ); +void RadLightForTriangles( int num, int lightmapNum, rawLightmap_t *lm, const shaderInfo_t *si, float scale, float subdivide, clipWork_t *cw ); +void RadLightForPatch( int num, int lightmapNum, rawLightmap_t *lm, const shaderInfo_t *si, float scale, float subdivide, clipWork_t *cw ); void RadCreateDiffuseLights( void ); @@ -1835,7 +1835,7 @@ bool ApplySurfaceParm( const char *name, int *contentFlag void BeginMapShaderFile( const char *mapFile ); void WriteMapShaderFile( void ); -shaderInfo_t *CustomShader( shaderInfo_t *si, const char *find, char *replace ); +const shaderInfo_t *CustomShader( const shaderInfo_t *si, const char *find, char *replace ); void EmitVertexRemapShader( char *from, char *to ); void LoadShaderInfo( void ); @@ -1844,11 +1844,6 @@ shaderInfo_t *ShaderInfoForShaderNull( const char *shader ); /* bspfile_abstract.c */ -void SetGridPoints( int n ); -void SetDrawSurfaces( int n ); -void SetDrawSurfacesBuffer(); -void BSPFilesCleanup(); - void SwapBlock( int *block, int size ); int GetLumpElements( bspHeader_t *header, int lump, int size ); @@ -2362,8 +2357,7 @@ Q_EXTERN std::vector bspDrawVerts; Q_EXTERN std::vector bspDrawIndexes; -Q_EXTERN int numBSPDrawSurfaces Q_ASSIGN( 0 ); -Q_EXTERN bspDrawSurface_t *bspDrawSurfaces Q_ASSIGN( NULL ); +Q_EXTERN std::vector bspDrawSurfaces; // MAX_MAP_DRAW_SURFS Q_EXTERN int numBSPFogs Q_ASSIGN( 0 ); Q_EXTERN bspFog_t bspFogs[ MAX_MAP_FOGS ]; diff --git a/tools/quake3/q3map2/shaders.cpp b/tools/quake3/q3map2/shaders.cpp index fb9bebca..4bd4d180 100644 --- a/tools/quake3/q3map2/shaders.cpp +++ b/tools/quake3/q3map2/shaders.cpp @@ -386,7 +386,7 @@ void WriteMapShaderFile( void ){ sets up a custom map shader */ -shaderInfo_t *CustomShader( shaderInfo_t *si, const char *find, char *replace ){ +const shaderInfo_t *CustomShader( const shaderInfo_t *si, const char *find, char *replace ){ shaderInfo_t *csi; char shader[ MAX_QPATH ]; char *s; diff --git a/tools/quake3/q3map2/surface.cpp b/tools/quake3/q3map2/surface.cpp index 6c8a02e1..dc52d516 100644 --- a/tools/quake3/q3map2/surface.cpp +++ b/tools/quake3/q3map2/surface.cpp @@ -1633,6 +1633,7 @@ void ClipSidesIntoTree( entity_t *e, const tree_t& tree ){ int AddReferenceToLeaf( mapDrawSurface_t *ds, node_t *node ){ drawSurfRef_t *dsr; + const int numBSPDrawSurfaces = bspDrawSurfaces.size(); /* dummy check */ @@ -2035,13 +2036,13 @@ static int FilterFlareSurfIntoTree( mapDrawSurface_t *ds, tree_t& tree ){ emits bsp drawverts from a map drawsurface */ -void EmitDrawVerts( const mapDrawSurface_t *ds, bspDrawSurface_t *out ){ +void EmitDrawVerts( const mapDrawSurface_t *ds, bspDrawSurface_t& out ){ /* get stuff */ const float offset = ds->shaderInfo->offset; /* copy the verts */ - out->firstVert = bspDrawVerts.size(); - out->numVerts = ds->numVerts; + out.firstVert = bspDrawVerts.size(); + out.numVerts = ds->numVerts; for ( int i = 0; i < ds->numVerts; i++ ) { /* allocate a new vert */ /* copy it */ @@ -2145,11 +2146,11 @@ int FindDrawIndexes( int numIndexes, const int *indexes ){ attempts to find an existing run of drawindexes before adding new ones */ -void EmitDrawIndexes( const mapDrawSurface_t *ds, bspDrawSurface_t *out ){ +void EmitDrawIndexes( const mapDrawSurface_t *ds, bspDrawSurface_t& out ){ /* attempt to use redundant indexing */ - out->firstIndex = FindDrawIndexes( ds->numIndexes, ds->indexes ); - out->numIndexes = ds->numIndexes; - if ( out->firstIndex == int( bspDrawIndexes.size() ) ) { + out.firstIndex = FindDrawIndexes( ds->numIndexes, ds->indexes ); + out.numIndexes = ds->numIndexes; + if ( out.firstIndex == int( bspDrawIndexes.size() ) ) { /* copy new unique indexes */ for ( int i = 0; i < ds->numIndexes; i++ ) { @@ -2158,8 +2159,8 @@ void EmitDrawIndexes( const mapDrawSurface_t *ds, bspDrawSurface_t *out ){ /* validate the index */ if ( ds->type != ESurfaceType::Patch ) { if ( index < 0 || index >= ds->numVerts ) { - Sys_Warning( "%d %s has invalid index %d (%d)\n", - numBSPDrawSurfaces, + Sys_Warning( "%zu %s has invalid index %d (%d)\n", + bspDrawSurfaces.size() - 1, ds->shaderInfo->shader.c_str(), index, i ); @@ -2179,45 +2180,34 @@ void EmitDrawIndexes( const mapDrawSurface_t *ds, bspDrawSurface_t *out ){ */ void EmitFlareSurface( mapDrawSurface_t *ds ){ - int i; - bspDrawSurface_t *out; - - /* ydnar: nuking useless flare drawsurfaces */ if ( !emitFlares && ds->type != ESurfaceType::Shader ) { return; } - /* limit check */ - if ( numBSPDrawSurfaces == MAX_MAP_DRAW_SURFS ) { - Error( "MAX_MAP_DRAW_SURFS" ); - } - /* allocate a new surface */ - out = &bspDrawSurfaces[ numBSPDrawSurfaces ]; - ds->outputNum = numBSPDrawSurfaces; - numBSPDrawSurfaces++; - memset( out, 0, sizeof( *out ) ); + bspDrawSurface_t& out = bspDrawSurfaces.emplace_back(); + ds->outputNum = bspDrawSurfaces.size() - 1; /* set it up */ - out->surfaceType = MST_FLARE; - out->shaderNum = EmitShader( ds->shaderInfo->shader, &ds->shaderInfo->contentFlags, &ds->shaderInfo->surfaceFlags ); - out->fogNum = ds->fogNum; + 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++ ) + for ( int i = 0; i < MAX_LIGHTMAPS; i++ ) { - out->lightmapNum[ i ] = -3; - out->lightmapStyles[ i ] = LS_NONE; - out->vertexStyles[ i ] = LS_NONE; + out.lightmapNum[ i ] = -3; + out.lightmapStyles[ i ] = LS_NONE; + out.vertexStyles[ i ] = LS_NONE; } - out->lightmapStyles[ 0 ] = ds->lightStyle; - out->vertexStyles[ 0 ] = ds->lightStyle; + out.lightmapStyles[ 0 ] = ds->lightStyle; + out.vertexStyles[ 0 ] = ds->lightStyle; - out->lightmapOrigin = ds->lightmapOrigin; /* origin */ - out->lightmapVecs[ 0 ] = ds->lightmapVecs[ 0 ]; /* color */ - out->lightmapVecs[ 1 ] = ds->lightmapVecs[ 1 ]; - out->lightmapVecs[ 2 ] = ds->lightmapVecs[ 2 ]; /* normal */ + out.lightmapOrigin = ds->lightmapOrigin; /* origin */ + out.lightmapVecs[ 0 ] = ds->lightmapVecs[ 0 ]; /* color */ + out.lightmapVecs[ 1 ] = ds->lightmapVecs[ 1 ]; + out.lightmapVecs[ 2 ] = ds->lightmapVecs[ 2 ]; /* normal */ /* add to count */ numSurfacesByType[ static_cast( ds->type ) ]++; @@ -2230,7 +2220,6 @@ void EmitFlareSurface( mapDrawSurface_t *ds ){ void EmitPatchSurface( entity_t *e, mapDrawSurface_t *ds ){ int i, j; - bspDrawSurface_t *out; int surfaceFlags, contentFlags; /* vortex: _patchMeta support */ @@ -2262,18 +2251,13 @@ void EmitPatchSurface( entity_t *e, mapDrawSurface_t *ds ){ } /* allocate a new surface */ - if ( numBSPDrawSurfaces == MAX_MAP_DRAW_SURFS ) { - Error( "MAX_MAP_DRAW_SURFS" ); - } - out = &bspDrawSurfaces[ numBSPDrawSurfaces ]; - ds->outputNum = numBSPDrawSurfaces; - numBSPDrawSurfaces++; - memset( out, 0, sizeof( *out ) ); + bspDrawSurface_t& out = bspDrawSurfaces.emplace_back(); + ds->outputNum = bspDrawSurfaces.size() - 1; /* set it up */ - out->surfaceType = MST_PATCH; + out.surfaceType = MST_PATCH; if ( debugSurfaces ) { - out->shaderNum = EmitShader( "debugsurfaces", NULL, NULL ); + out.shaderNum = EmitShader( "debugsurfaces", NULL, NULL ); } else if ( patchMeta || forcePatchMeta ) { /* patch meta requires that we have nodraw patches for collision */ @@ -2288,34 +2272,34 @@ void EmitPatchSurface( entity_t *e, mapDrawSurface_t *ds ){ ds->sampleSize = 0; /* emit the new fake shader */ - out->shaderNum = EmitShader( ds->shaderInfo->shader, &contentFlags, &surfaceFlags ); + out.shaderNum = EmitShader( ds->shaderInfo->shader, &contentFlags, &surfaceFlags ); } else{ - out->shaderNum = EmitShader( ds->shaderInfo->shader, &ds->shaderInfo->contentFlags, &ds->shaderInfo->surfaceFlags ); + out.shaderNum = EmitShader( ds->shaderInfo->shader, &ds->shaderInfo->contentFlags, &ds->shaderInfo->surfaceFlags ); } - out->patchWidth = ds->patchWidth; - out->patchHeight = ds->patchHeight; - out->fogNum = ds->fogNum; + out.patchWidth = ds->patchWidth; + out.patchHeight = ds->patchHeight; + out.fogNum = ds->fogNum; /* RBSP */ for ( i = 0; i < MAX_LIGHTMAPS; i++ ) { - out->lightmapNum[ i ] = -3; - out->lightmapStyles[ i ] = LS_NONE; - out->vertexStyles[ i ] = LS_NONE; + out.lightmapNum[ i ] = -3; + out.lightmapStyles[ i ] = LS_NONE; + out.vertexStyles[ i ] = LS_NONE; } - out->lightmapStyles[ 0 ] = LS_NORMAL; - out->vertexStyles[ 0 ] = LS_NORMAL; + 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 ] */ - out->lightmapOrigin = ds->lightmapOrigin; - out->lightmapVecs[ 0 ] = ds->bounds.mins; - out->lightmapVecs[ 1 ] = ds->bounds.maxs; - out->lightmapVecs[ 2 ] = ds->lightmapVecs[ 2 ]; + out.lightmapOrigin = ds->lightmapOrigin; + out.lightmapVecs[ 0 ] = ds->bounds.mins; + out.lightmapVecs[ 1 ] = ds->bounds.maxs; + out.lightmapVecs[ 2 ] = ds->lightmapVecs[ 2 ]; /* ydnar: gs mods: clear out the plane normal */ if ( !ds->planar ) { - out->lightmapVecs[ 2 ].set( 0 ); + out.lightmapVecs[ 2 ].set( 0 ); } /* emit the verts and indexes */ @@ -2452,7 +2436,6 @@ static void OptimizeTriangleSurface( mapDrawSurface_t *ds ){ void EmitTriangleSurface( mapDrawSurface_t *ds ){ int i, temp; - bspDrawSurface_t *out; /* invert the surface if necessary */ if ( ds->backSide || ds->shaderInfo->invert ) { @@ -2473,17 +2456,12 @@ void EmitTriangleSurface( mapDrawSurface_t *ds ){ } /* allocate a new surface */ - if ( numBSPDrawSurfaces == MAX_MAP_DRAW_SURFS ) { - Error( "MAX_MAP_DRAW_SURFS" ); - } - out = &bspDrawSurfaces[ numBSPDrawSurfaces ]; - ds->outputNum = numBSPDrawSurfaces; - numBSPDrawSurfaces++; - memset( out, 0, sizeof( *out ) ); + bspDrawSurface_t& out = bspDrawSurfaces.emplace_back(); + ds->outputNum = bspDrawSurfaces.size() - 1; /* ydnar/sd: handle wolf et foliage surfaces */ if ( ds->type == ESurfaceType::Foliage ) { - out->surfaceType = MST_FOLIAGE; + out.surfaceType = MST_FOLIAGE; } /* ydnar: gs mods: handle lightmapped terrain (force to planar type) */ @@ -2493,24 +2471,24 @@ void EmitTriangleSurface( mapDrawSurface_t *ds ){ ds->type == ESurfaceType::Foghull || ds->numVerts > maxLMSurfaceVerts || debugSurfaces ) { - out->surfaceType = MST_TRIANGLE_SOUP; + out.surfaceType = MST_TRIANGLE_SOUP; } /* set to a planar face */ else{ - out->surfaceType = MST_PLANAR; + out.surfaceType = MST_PLANAR; } /* set it up */ if ( debugSurfaces ) { - out->shaderNum = EmitShader( "debugsurfaces", NULL, NULL ); + out.shaderNum = EmitShader( "debugsurfaces", NULL, NULL ); } else{ - out->shaderNum = EmitShader( ds->shaderInfo->shader, &ds->shaderInfo->contentFlags, &ds->shaderInfo->surfaceFlags ); + out.shaderNum = EmitShader( ds->shaderInfo->shader, &ds->shaderInfo->contentFlags, &ds->shaderInfo->surfaceFlags ); } - out->patchWidth = ds->patchWidth; - out->patchHeight = ds->patchHeight; - out->fogNum = ds->fogNum; + 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 ) { @@ -2537,22 +2515,22 @@ void EmitTriangleSurface( mapDrawSurface_t *ds ){ /* RBSP */ for ( i = 0; i < MAX_LIGHTMAPS; i++ ) { - out->lightmapNum[ i ] = -3; - out->lightmapStyles[ i ] = LS_NONE; - out->vertexStyles[ i ] = LS_NONE; + out.lightmapNum[ i ] = -3; + out.lightmapStyles[ i ] = LS_NONE; + out.vertexStyles[ i ] = LS_NONE; } - out->lightmapStyles[ 0 ] = LS_NORMAL; - out->vertexStyles[ 0 ] = LS_NORMAL; + out.lightmapStyles[ 0 ] = LS_NORMAL; + out.vertexStyles[ 0 ] = LS_NORMAL; /* lightmap vectors (lod bounds for patches */ - out->lightmapOrigin = ds->lightmapOrigin; - out->lightmapVecs[ 0 ] = ds->lightmapVecs[ 0 ]; - out->lightmapVecs[ 1 ] = ds->lightmapVecs[ 1 ]; - out->lightmapVecs[ 2 ] = ds->lightmapVecs[ 2 ]; + out.lightmapOrigin = ds->lightmapOrigin; + out.lightmapVecs[ 0 ] = ds->lightmapVecs[ 0 ]; + out.lightmapVecs[ 1 ] = ds->lightmapVecs[ 1 ]; + out.lightmapVecs[ 2 ] = ds->lightmapVecs[ 2 ]; /* ydnar: gs mods: clear out the plane normal */ if ( !ds->planar ) { - out->lightmapVecs[ 2 ].set( 0 ); + out.lightmapVecs[ 2 ].set( 0 ); } /* optimize the surface's triangles */ @@ -3302,18 +3280,17 @@ void FilterDrawsurfsIntoTree( entity_t *e, tree_t& tree ){ numRefs += refs; /* emit extra surface data */ - SetSurfaceExtra( ds, numBSPDrawSurfaces - 1 ); + SetSurfaceExtra( *ds ); //% Sys_FPrintf( SYS_VRB, "%d verts %d indexes\n", ds->numVerts, ds->numIndexes ); /* one last sanity check */ { - bspDrawSurface_t *out; - out = &bspDrawSurfaces[ numBSPDrawSurfaces - 1 ]; - if ( out->numVerts == 3 && out->numIndexes > 3 ) { + const bspDrawSurface_t& out = bspDrawSurfaces.back(); + if ( out.numVerts == 3 && out.numIndexes > 3 ) { Sys_Printf( "\n" ); - Sys_Warning( "Potentially bad %s surface (%d: %d, %d)\n %s\n", + Sys_Warning( "Potentially bad %s surface (%zu: %d, %d)\n %s\n", surfaceTypeName( ds->type ), - numBSPDrawSurfaces - 1, out->numVerts, out->numIndexes, si->shader.c_str() ); + bspDrawSurfaces.size(), out.numVerts, out.numIndexes, si->shader.c_str() ); } } @@ -3327,7 +3304,7 @@ void FilterDrawsurfsIntoTree( entity_t *e, tree_t& tree ){ /* 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 (%zu) emitted drawsurfs\n", numSurfs, bspDrawSurfaces.size() ); Sys_FPrintf( SYS_VRB, "%9d stripped face surfaces\n", numStripSurfaces ); Sys_FPrintf( SYS_VRB, "%9d fanned face surfaces\n", numFanSurfaces ); Sys_FPrintf( SYS_VRB, "%9d maxarea'd face surfaces\n", numMaxAreaSurfaces ); diff --git a/tools/quake3/q3map2/surface_extra.cpp b/tools/quake3/q3map2/surface_extra.cpp index 1c15830a..d27ae707 100644 --- a/tools/quake3/q3map2/surface_extra.cpp +++ b/tools/quake3/q3map2/surface_extra.cpp @@ -41,8 +41,8 @@ struct surfaceExtra_t { - mapDrawSurface_t *mds; - shaderInfo_t *si; + const mapDrawSurface_t *mds; + const shaderInfo_t *si; int parentSurfaceNum; int entityNum; int castShadows, recvShadows; @@ -96,31 +96,23 @@ void SetDefaultSampleSize( int sampleSize ){ stores extra (q3map2) data for the specific numbered drawsurface */ -void SetSurfaceExtra( mapDrawSurface_t *ds, int num ){ - surfaceExtra_t *se; - - - /* dummy check */ - if ( ds == NULL || num < 0 ) { - return; - } - +void SetSurfaceExtra( const mapDrawSurface_t& ds ){ /* get a new extra */ - se = AllocSurfaceExtra(); + surfaceExtra_t *se = AllocSurfaceExtra(); /* copy out the relevant bits */ - se->mds = ds; - se->si = ds->shaderInfo; - se->parentSurfaceNum = ds->parent != NULL ? ds->parent->outputNum : -1; - se->entityNum = ds->entityNum; - se->castShadows = ds->castShadows; - se->recvShadows = ds->recvShadows; - se->sampleSize = ds->sampleSize; - se->longestCurve = ds->longestCurve; - se->lightmapAxis = ds->lightmapAxis; + se->mds = &ds; + se->si = ds.shaderInfo; + se->parentSurfaceNum = ds.parent != NULL ? ds.parent->outputNum : -1; + se->entityNum = ds.entityNum; + se->castShadows = ds.castShadows; + se->recvShadows = ds.recvShadows; + se->sampleSize = ds.sampleSize; + se->longestCurve = ds.longestCurve; + se->lightmapAxis = ds.lightmapAxis; /* debug code */ - //% Sys_FPrintf( SYS_VRB, "SetSurfaceExtra(): entityNum = %d\n", ds->entityNum ); + //% Sys_FPrintf( SYS_VRB, "SetSurfaceExtra(): entityNum = %d\n", ds.entityNum ); } @@ -138,7 +130,7 @@ static surfaceExtra_t *GetSurfaceExtra( int num ){ } -shaderInfo_t *GetSurfaceExtraShaderInfo( int num ){ +const shaderInfo_t *GetSurfaceExtraShaderInfo( int num ){ return GetSurfaceExtra( num )->si; } diff --git a/tools/quake3/q3map2/writebsp.cpp b/tools/quake3/q3map2/writebsp.cpp index 2c8be748..fa22ec87 100644 --- a/tools/quake3/q3map2/writebsp.cpp +++ b/tools/quake3/q3map2/writebsp.cpp @@ -526,7 +526,7 @@ void BeginModel( void ){ Sys_FPrintf( SYS_VRB, "Lightgrid bounds: { %f %f %f } { %f %f %f }\n", lgMinmax.mins[0], lgMinmax.mins[1], lgMinmax.mins[2], lgMinmax.maxs[0], lgMinmax.maxs[1], lgMinmax.maxs[2] ); /* set firsts */ - mod.firstBSPSurface = numBSPDrawSurfaces; + mod.firstBSPSurface = bspDrawSurfaces.size(); mod.firstBSPBrush = bspBrushes.size(); } @@ -547,7 +547,7 @@ void EndModel( entity_t *e, node_t *headnode ){ EmitDrawNode_r( headnode ); /* set surfaces and brushes */ - mod.numBSPSurfaces = numBSPDrawSurfaces - mod.firstBSPSurface; + mod.numBSPSurfaces = bspDrawSurfaces.size() - mod.firstBSPSurface; mod.firstBSPBrush = e->firstBrush; mod.numBSPBrushes = e->numBrushes; }