ref: gl: drop broken minlight/scale cvars for litwater. Keep them for mods. Fix post-merge issues

* Use offsets into dbspmodel_t struct, get rid of srcmodel global variable.
* Allocate dbspmodel_t when it's required
* Make srclumps const, move Blue-Shift hack into lump loader's flag.

Documentation/extensions/litwater.md

@@ -0,0 +1,19 @@
+## Lightmapped water
+
+Xash3D FWGS supports lightmapped water, as an extension. It adds three new cvars and new worldspawn key values.
+
+### For level designers:
+
+If you're a level designer and intend to make your level to have lightmapped water, you can put these keyvalues to worldspawn entity description (always first entity in entities list):
+
+| Key                    | Value   | Description |
+| ---------------------- | ------- | ----------- |
+| `_litwater`            | integer | Set to any non-zero value to enable lightmapped water. Overrides `gl_litwater_force` cvar value. |
+| `_litwater_minlight`   | integer | Minimal lightmap value water surface will receive. Helps to avoid too dark areas when water isn't properly lit. If not set, defaults to zero. |
+| `_litwater_scale`      | float   | Scales up lightmap value for water surfaces. If not set, defaults to 1.0. |
+
+### For players:
+
+Some of the maps already have computed lightmap for water surfaces and sometimes water has been properly lit but the support hasn't been declared by the level designer.
+
+As a player, you can enable it in `Video options` menu or through console with `gl_litwater_force` cvar. There are also `gl_litwater_minlight` and `gl_litwater_scale` cvars that function similar to keys above. The default values has been set to `192` and `1.25` respectively to slightly avoid issues with maps that wasn't intended to have lightmapped water.

engine/client/sound/s_vox.c

@@ -403,11 +403,11 @@ static qboolean VOX_ParseWordParams( char *psz, voxword_t *pvoxword, voxword_t *
 
 		command = *psz++;
 
-		if( !isdigit( *psz ))
+		if( !isdigit((byte)*psz ))
 			break;
 
 		memset( sznum, 0, sizeof( sznum ));
-		for( i = 0; i < sizeof( sznum ) - 1 && isdigit( *psz ); i++, psz++ )
+		for( i = 0; i < sizeof( sznum ) - 1 && isdigit((byte)*psz ); i++, psz++ )
 			sznum[i] = *psz;
 
 		i = Q_atoi( sznum );

engine/common/host.c

@@ -833,7 +833,7 @@ static uint32_t Host_CheckBugcomp( void )
 	if( !Sys_CheckParm( "-bugcomp" ))
 		return 0;
 
-	if( Sys_GetParmFromCmdLine( "-bugcomp", args ) && isalpha( args[0] ))
+	if( Sys_GetParmFromCmdLine( "-bugcomp", args ) && isalpha((byte)args[0] ))
 	{
 		Q_splitstr( args, '+', &flags, Host_CheckBugcomp_splitstr_handler );
 	}

engine/common/imagelib/img_wad.c

@@ -514,7 +514,7 @@ qboolean Image_LoadMIP( const char *name, const byte *buffer, fs_offset_t filesi
 				// three checks here: check if we can load luma, check the texture name and, finally,
 				// validate that palette isn't NULL
 				if( Image_CheckFlag( IL_ALLOW_WAD3_LUMA )
-					&& ( mip.name[0] == '~' || ( mip.name[0] == '+' && isdigit( mip.name[1] ) && mip.name[2] == '~' ))
+					&& ( mip.name[0] == '~' || ( mip.name[0] == '+' && isdigit((byte)mip.name[1] ) && mip.name[2] == '~' ))
 					&& pal != NULL )
 				{
 					SetBits( image.flags, IMAGE_HAS_LUMA );

engine/common/lib_common.c

@@ -327,7 +327,7 @@ static char *COM_GetItaniumName( const char * const in_name )
 	{
 		// parse symbol length marker
 		len = 0;
-		for( ; isdigit( *f ) && remaining > 0; f++, remaining-- )
+		for( ; isdigit((byte)*f ) && remaining > 0; f++, remaining-- )
 			len = len * 10 + ( *f - '0' );
 
 		// sane value
@@ -344,7 +344,7 @@ static char *COM_GetItaniumName( const char * const in_name )
 		if( *f == 'E' )
 			break;
 
-		if( !isdigit( *f ) || remaining <= 0 )
+		if( !isdigit((byte)*f ) || remaining <= 0 )
 			goto invalid_format;
 	}
 

engine/common/mod_bmodel.c

@@ -166,32 +166,32 @@ typedef enum
 	LOADLUMP_BSPX,     // ... from BSPX data
 } loadlump_source_t;
 
-#define LUMP_SAVESTATS  BIT( 0 )
-#define LUMP_TESTONLY   BIT( 1 )
-#define LUMP_SILENT     BIT( 2 )
-#define LUMP_BSP30EXT   BIT( 3 ) // extra marker for Mod_LoadLump
-#define LUMP_BSPX       BIT( 4 )
+#define LUMP_SAVESTATS   BIT( 0 )
+#define LUMP_BSHIFT_SWAP BIT( 1 )
+#define LUMP_SILENT      BIT( 2 )
+#define LUMP_BSP30EXT    BIT( 3 ) // extra marker for Mod_LoadLump
+#define LUMP_BSPX        BIT( 4 )
 
 typedef struct
 {
-	int          lumpnumber;
+	const int    lumpnumber;
 
 	// BSPX
 	const char   lumpname[24];
 
-	int          flags;
+	const int    flags;
 	const size_t mincount;
 	const size_t maxcount;
 	const int    entrysize;
 	const int    entrysize32; // extended size (0 if not available)
 	const char   *loadname;
-	const void   **dataptr;
-	size_t       *count;
+	const size_t dataofs;  // offsetof into dbspmodel_t for data pointer
+	const size_t countofs; // offsetof into dbspmodel_t for count/size
 #if XASH_BIG_ENDIAN // do not waste memory on little endian
 	const swap_struct_def_t *swap;
-	size_t       swaplen;
+	const size_t swaplen;
 	const swap_struct_def_t *swap32;
-	size_t       swaplen32;
+	const size_t swaplen32;
 #endif
 } mlumpinfo_t;
 
@@ -344,11 +344,10 @@ le_struct_begin( mip_swap )
 le_struct_end();
 
 world_static_t     world;
-static dbspmodel_t srcmodel;
 static loadstat_t  loadstat;
 static model_t     *worldmodel;
 static byte        g_visdata[(MAX_MAP_LEAFS+7)/8];	// intermediate buffer
-static mlumpinfo_t srclumps[HEADER_LUMPS] =
+static const mlumpinfo_t srclumps[HEADER_LUMPS] =
 {
 	{
 		.lumpnumber  = LUMP_ENTITIES,
@@ -356,8 +355,8 @@ static mlumpinfo_t srclumps[HEADER_LUMPS] =
 		.maxcount    = MAX_MAP_ENTSTRING,
 		.entrysize   = sizeof( byte ),
 		.loadname    = "entities",
-		.dataptr     = (const void **)&srcmodel.entdata,
-		.count       = &srcmodel.entdatasize,
+		.dataofs     = offsetof( dbspmodel_t, entdata ),
+		.countofs    = offsetof( dbspmodel_t, entdatasize ),
 	},
 	{
 		.lumpnumber  = LUMP_PLANES,
@@ -365,8 +364,8 @@ static mlumpinfo_t srclumps[HEADER_LUMPS] =
 		.maxcount    = MAX_MAP_PLANES,
 		.entrysize   = sizeof( dplane_t ),
 		.loadname    = "planes",
-		.dataptr     = (const void **)&srcmodel.planes,
-		.count       = &srcmodel.numplanes,
+		.dataofs     = offsetof( dbspmodel_t, planes ),
+		.countofs    = offsetof( dbspmodel_t, numplanes ),
 		LUMP_SWAP( dplane_swap )
 	},
 	{
@@ -375,16 +374,16 @@ static mlumpinfo_t srclumps[HEADER_LUMPS] =
 		.maxcount    = MAX_MAP_MIPTEX,
 		.entrysize   = sizeof( byte ),
 		.loadname    = "textures",
-		.dataptr     = (const void **)&srcmodel.textures,
-		.count       = &srcmodel.texdatasize,
+		.dataofs     = offsetof( dbspmodel_t, textures ),
+		.countofs    = offsetof( dbspmodel_t, texdatasize ),
 	},
 	{
 		.lumpnumber  = LUMP_VERTEXES,
 		.maxcount    = MAX_MAP_VERTS,
 		.entrysize   = sizeof( dvertex_t ),
 		.loadname    = "vertexes",
-		.dataptr     = (const void **)&srcmodel.vertexes,
-		.count       = &srcmodel.numvertexes,
+		.dataofs     = offsetof( dbspmodel_t, vertexes ),
+		.countofs    = offsetof( dbspmodel_t, numvertexes ),
 		LUMP_SWAP( dvertex_swap )
 	},
 	{
@@ -392,8 +391,8 @@ static mlumpinfo_t srclumps[HEADER_LUMPS] =
 		.maxcount    = MAX_MAP_VISIBILITY,
 		.entrysize   = sizeof( byte ),
 		.loadname    = "visibility",
-		.dataptr     = (const void **)&srcmodel.visdata,
-		.count       = &srcmodel.visdatasize,
+		.dataofs     = offsetof( dbspmodel_t, visdata ),
+		.countofs    = offsetof( dbspmodel_t, visdatasize ),
 	},
 	{
 		.lumpnumber  = LUMP_NODES,
@@ -403,8 +402,8 @@ static mlumpinfo_t srclumps[HEADER_LUMPS] =
 		.entrysize32 = sizeof( dnode32_t ),
 		.loadname    = "nodes",
 		.flags       = CHECK_OVERFLOW,
-		.dataptr     = (const void **)&srcmodel.nodes,
-		.count       = &srcmodel.numnodes,
+		.dataofs     = offsetof( dbspmodel_t, nodes ),
+		.countofs    = offsetof( dbspmodel_t, numnodes ),
 		LUMP_SWAP32( dnode_swap, dnode32_swap )
 	},
 	{
@@ -414,8 +413,8 @@ static mlumpinfo_t srclumps[HEADER_LUMPS] =
 		.entrysize   = sizeof( dtexinfo_t ),
 		.loadname    = "texinfo",
 		.flags       = CHECK_OVERFLOW,
-		.dataptr     = (const void **)&srcmodel.texinfo,
-		.count       = &srcmodel.numtexinfo,
+		.dataofs     = offsetof( dbspmodel_t, texinfo ),
+		.countofs    = offsetof( dbspmodel_t, numtexinfo ),
 		LUMP_SWAP( dtexinfo_swap )
 	},
 	{
@@ -426,8 +425,8 @@ static mlumpinfo_t srclumps[HEADER_LUMPS] =
 		.entrysize32 = sizeof( dface32_t ),
 		.loadname    = "faces",
 		.flags       = CHECK_OVERFLOW,
-		.dataptr     = (const void **)&srcmodel.surfaces,
-		.count       = &srcmodel.numsurfaces,
+		.dataofs     = offsetof( dbspmodel_t, surfaces ),
+		.countofs    = offsetof( dbspmodel_t, numsurfaces ),
 		LUMP_SWAP32( dface_swap, dface32_swap )
 	},
 	{
@@ -437,8 +436,8 @@ static mlumpinfo_t srclumps[HEADER_LUMPS] =
 		.entrysize   = sizeof( byte ),
 		.loadname    = "lightmaps",
 		.flags       = 0,
-		.dataptr     = (const void **)&srcmodel.lightdata,
-		.count       = &srcmodel.lightdatasize,
+		.dataofs     = offsetof( dbspmodel_t, lightdata ),
+		.countofs    = offsetof( dbspmodel_t, lightdatasize ),
 	},
 	{
 		.lumpnumber  = LUMP_CLIPNODES,
@@ -448,8 +447,8 @@ static mlumpinfo_t srclumps[HEADER_LUMPS] =
 		.entrysize32 = sizeof( dclipnode32_t ),
 		.loadname    = "clipnodes",
 		.flags       = 0,
-		.dataptr     = (const void **)&srcmodel.clipnodes,
-		.count       = &srcmodel.numclipnodes,
+		.dataofs     = offsetof( dbspmodel_t, clipnodes ),
+		.countofs    = offsetof( dbspmodel_t, numclipnodes ),
 		LUMP_SWAP32( dclipnode_swap, dclipnode32_swap )
 	},
 	{
@@ -460,8 +459,8 @@ static mlumpinfo_t srclumps[HEADER_LUMPS] =
 		.entrysize32 = sizeof( dleaf32_t ),
 		.loadname    = "leafs",
 		.flags       = CHECK_OVERFLOW,
-		.dataptr     = (const void **)&srcmodel.leafs,
-		.count       = &srcmodel.numleafs,
+		.dataofs     = offsetof( dbspmodel_t, leafs ),
+		.countofs    = offsetof( dbspmodel_t, numleafs ),
 		LUMP_SWAP32( dleaf_swap, dleaf32_swap )
 	},
 	{
@@ -472,8 +471,8 @@ static mlumpinfo_t srclumps[HEADER_LUMPS] =
 		.entrysize32 = sizeof( dmarkface32_t ),
 		.loadname    = "markfaces",
 		.flags       = 0,
-		.dataptr     = (const void **)&srcmodel.markfaces,
-		.count       = &srcmodel.nummarkfaces,
+		.dataofs     = offsetof( dbspmodel_t, markfaces ),
+		.countofs    = offsetof( dbspmodel_t, nummarkfaces ),
 	},
 	{
 		.lumpnumber  = LUMP_EDGES,
@@ -483,8 +482,8 @@ static mlumpinfo_t srclumps[HEADER_LUMPS] =
 		.entrysize32 = sizeof( dedge32_t ),
 		.loadname    = "edges",
 		.flags       = 0,
-		.dataptr     = (const void **)&srcmodel.edges,
-		.count       = &srcmodel.numedges,
+		.dataofs     = offsetof( dbspmodel_t, edges ),
+		.countofs    = offsetof( dbspmodel_t, numedges ),
 		LUMP_SWAP32( dedge_swap, dedge32_swap )
 	},
 	{
@@ -494,8 +493,8 @@ static mlumpinfo_t srclumps[HEADER_LUMPS] =
 		.entrysize   = sizeof( dsurfedge_t ),
 		.loadname    = "surfedges",
 		.flags       = 0,
-		.dataptr     = (const void **)&srcmodel.surfedges,
-		.count       = &srcmodel.numsurfedges,
+		.dataofs     = offsetof( dbspmodel_t, surfedges ),
+		.countofs    = offsetof( dbspmodel_t, numsurfedges ),
 	},
 	{
 		.lumpnumber  = LUMP_MODELS,
@@ -504,8 +503,8 @@ static mlumpinfo_t srclumps[HEADER_LUMPS] =
 		.entrysize   = sizeof( dmodel_t ),
 		.loadname    = "models",
 		.flags       = CHECK_OVERFLOW,
-		.dataptr     = (const void **)&srcmodel.submodels,
-		.count       = &srcmodel.numsubmodels,
+		.dataofs     = offsetof( dbspmodel_t, submodels ),
+		.countofs    = offsetof( dbspmodel_t, numsubmodels ),
 		LUMP_SWAP( dmodel_swap )
 	},
 };
@@ -518,8 +517,8 @@ static const mlumpinfo_t extlumps[EXTRA_LUMPS] =
 		.maxcount    = MAX_MAP_LIGHTING,
 		.entrysize   = sizeof( byte ),
 		.loadname    = "deluxmaps",
-		.dataptr     = (const void **)&srcmodel.deluxdata,
-		.count       = &srcmodel.deluxdatasize,
+		.dataofs     = offsetof( dbspmodel_t, deluxdata ),
+		.countofs    = offsetof( dbspmodel_t, deluxdatasize ),
 	},
 	{
 		.lumpnumber  = LUMP_FACEINFO,
@@ -528,8 +527,8 @@ static const mlumpinfo_t extlumps[EXTRA_LUMPS] =
 		.entrysize   = sizeof( dfaceinfo_t ),
 		.loadname    = "faceinfos",
 		.flags       = CHECK_OVERFLOW,
-		.dataptr     = (const void **)&srcmodel.faceinfo,
-		.count       = &srcmodel.numfaceinfo,
+		.dataofs     = offsetof( dbspmodel_t, faceinfo ),
+		.countofs    = offsetof( dbspmodel_t, numfaceinfo ),
 		LUMP_SWAP( dfaceinfo_swap )
 	},
 	{
@@ -538,8 +537,8 @@ static const mlumpinfo_t extlumps[EXTRA_LUMPS] =
 		.maxcount    = MAX_MAP_LIGHTING / 3,
 		.entrysize   = sizeof( byte ),
 		.loadname    = "shadowmap",
-		.dataptr     = (const void **)&srcmodel.shadowdata,
-		.count       = &srcmodel.shadowdatasize,
+		.dataofs     = offsetof( dbspmodel_t, shadowdata ),
+		.countofs    = offsetof( dbspmodel_t, shadowdatasize ),
 	},
 };
 
@@ -550,16 +549,16 @@ static const mlumpinfo_t bspxlumps[] =
 		.maxcount    = MAX_MAP_LIGHTING,
 		.entrysize   = sizeof( byte ),
 		.loadname    = "rgblighting",
-		.dataptr     = (const void **)&srcmodel.rgblightdata,
-		.count       = &srcmodel.rgblightdatasize,
+		.dataofs     = offsetof( dbspmodel_t, rgblightdata ),
+		.countofs    = offsetof( dbspmodel_t, rgblightdatasize ),
 	},
 	{
 		.lumpname    = "LIGHTINGDIR",
 		.maxcount    = MAX_MAP_LIGHTING,
 		.entrysize   = sizeof( byte ),
 		.loadname    = "lightingdir",
-		.dataptr     = (const void **)&srcmodel.deluxdata,
-		.count       = &srcmodel.deluxdatasize,
+		.dataofs     = offsetof( dbspmodel_t, deluxdata ),
+		.countofs    = offsetof( dbspmodel_t, deluxdatasize ),
 	},
 };
 
@@ -758,7 +757,7 @@ Mod_LoadLump
 generic loader
 =================
 */
-static void Mod_LoadLump( const void *in, const mlumpinfo_t *info, mlumpstat_t *stat, int flags, loadlump_source_t source, const void *bspx_data )
+static void Mod_LoadLump( const void *in, const mlumpinfo_t *info, mlumpstat_t *stat, int flags, loadlump_source_t source, const void *bspx_data, dbspmodel_t *bmod )
 {
 	int     version = ((const dheader_t *)in)->version, i;
 	size_t  numelems, real_entrysize;
@@ -769,7 +768,16 @@ static void Mod_LoadLump( const void *in, const mlumpinfo_t *info, mlumpstat_t *
 	case LOADLUMP_STANDARD:
 	{
 		const dheader_t *header = in;
-		l = header->lumps[info->lumpnumber];
+		int lumpnumber = info->lumpnumber;
+
+		if( FBitSet( flags, LUMP_BSHIFT_SWAP ))
+		{
+			if( lumpnumber == LUMP_ENTITIES )
+				lumpnumber = LUMP_PLANES;
+			else if( lumpnumber == LUMP_PLANES )
+				lumpnumber = LUMP_ENTITIES;
+		}
+		l = header->lumps[lumpnumber];
 		break;
 	}
 	case LOADLUMP_BSP30EXT:
@@ -836,7 +844,7 @@ static void Mod_LoadLump( const void *in, const mlumpinfo_t *info, mlumpstat_t *
 	}
 
 	// bmodels not required the visibility
-	if( !FBitSet( flags, LUMP_TESTONLY ) && !world.loading && info->lumpnumber == LUMP_VISIBILITY )
+	if( info->lumpnumber == LUMP_VISIBILITY && !world.loading && bmod )
 		SetBits( flags, LUMP_SILENT ); // shut up warning
 
 	// fill the stats for world
@@ -914,36 +922,31 @@ static void Mod_LoadLump( const void *in, const mlumpinfo_t *info, mlumpstat_t *
 		}
 	}
 
-	if( FBitSet( flags, LUMP_TESTONLY ))
-		return; // don't fill the intermediate struct
+	// if no bmod is passed, we are only testing if BSP lumps are not corrupted
+	if( !bmod )
+		return;
+
+	byte *data = (byte *)in + l.fileofs;
 
 	// all checks are passed, store pointers
-	if( info->dataptr )
-		*info->dataptr = (void *)((byte *)in + l.fileofs);
-
-	if( info->count )
-		*info->count = numelems;
+	*(byte **)((byte *)bmod + info->dataofs) = data;
+	*(size_t *)((byte *)bmod + info->countofs) = numelems;
 
 	// finally, process the data
 #if XASH_BIG_ENDIAN
 	const swap_struct_def_t *swap = real_entrysize == info->entrysize32 ? info->swap32 : info->swap;
 	size_t swaplen = real_entrysize == info->entrysize32 ? info->swaplen32 : info->swaplen;
 
-	if( info->dataptr && *info->dataptr )
+	if( swap )
 	{
-		byte *data = (byte *)*info->dataptr;
-
-		if( swap )
-		{
-			for( size_t j = 0; j < numelems; j++ )
-				swap_struct_( swap, swaplen, data + j * real_entrysize );
-		}
-		// some lumps don't need a swapdef, as all needed data in the lump info
-		else if( real_entrysize > 1 )
-		{
-			for( size_t j = 0; j < numelems; j++ )
-				swap_field_( data + j * real_entrysize, real_entrysize );
-		}
+		for( size_t j = 0; j < numelems; j++ )
+			swap_struct_( swap, swaplen, data + j * real_entrysize );
+	}
+	// some lumps don't need a swapdef, as all needed data in the lump info
+	else if( real_entrysize > 1 )
+	{
+		for( size_t j = 0; j < numelems; j++ )
+			swap_field_( data + j * real_entrysize, real_entrysize );
 	}
 #endif
 }
@@ -2404,6 +2407,9 @@ static void Mod_LoadEntities( model_t *mod, const dbspmodel_t *bmod )
 	world.wadlist = NULL;
 	world.wadcount = 0;
 
+	world.litwater_minlight = -1;
+	world.litwater_scale = -1.0f;
+
 	// parse all the wads for loading textures in right ordering
 	while(( pfile = COM_ParseFile( pfile, token, sizeof( token ))) != NULL )
 	{
@@ -2447,6 +2453,15 @@ static void Mod_LoadEntities( model_t *mod, const dbspmodel_t *bmod )
 				Mem_Free( world.generator );
 				world.generator = copystring( token );
 			}
+			else if( !Q_stricmp( keyname, "_litwater" ))
+			{
+				if( Q_atoi( token ) != 0 )
+					SetBits( world.flags, FWORLD_HAS_LITWATER );
+			}
+			else if( !Q_stricmp( keyname, "_litwater_minlight" ))
+				world.litwater_minlight = Q_atoi( token );
+			else if( !Q_stricmp( keyname, "_litwater_scale" ))
+				world.litwater_scale = Q_atof( token );
 		}
 		return;	// all done
 	}
@@ -4228,14 +4243,12 @@ static qboolean Mod_LoadBmodelLumps( model_t *mod, byte *mod_base, size_t buffer
 {
 	dheader_t   *header = (dheader_t *)mod_base;
 	int         *extident = (int *)(mod_base + sizeof( dheader_t ));
-	dbspmodel_t *bmod = &srcmodel;
 	char        wadvalue[2048];
 	size_t      len = 0;
 	int         i, stat_index = 0, ret, flags = 0;
 	fs_offset_t bspx_header_offset;
 
 	// always reset the intermediate struct
-	memset( bmod, 0, sizeof( *bmod ));
 	memset( &loadstat, 0, sizeof( loadstat ));
 
 	Q_strncpy( loadstat.name, mod->name, sizeof( loadstat.name ));
@@ -4244,10 +4257,6 @@ static qboolean Mod_LoadBmodelLumps( model_t *mod, byte *mod_base, size_t buffer
 	// byte-swap BSP header and lump directory from little-endian
 	Mod_SwapBSPLumps( mod_base, bufferlen );
 
-	// restore default lump numbers
-	srclumps[0].lumpnumber = LUMP_ENTITIES;
-	srclumps[1].lumpnumber = LUMP_PLANES;
-
 	switch( header->version )
 	{
 	case HLBSP_VERSION:
@@ -4260,8 +4269,7 @@ static qboolean Mod_LoadBmodelLumps( model_t *mod, byte *mod_base, size_t buffer
 			 Mod_LumpLooksLikeEntities( mod_base + header->lumps[LUMP_PLANES].fileofs, header->lumps[LUMP_PLANES].filelen ))
 		{
 			// blue-shift swapped lumps
-			srclumps[0].lumpnumber = LUMP_PLANES;
-			srclumps[1].lumpnumber = LUMP_ENTITIES;
+			SetBits( flags, LUMP_BSHIFT_SWAP );
 		}
 		break;
 	case Q1BSP_VERSION:
@@ -4275,6 +4283,7 @@ static qboolean Mod_LoadBmodelLumps( model_t *mod, byte *mod_base, size_t buffer
 		return false;
 	}
 
+	dbspmodel_t *bmod = Mem_Calloc( mod->mempool, sizeof( *bmod ));
 	bmod->version = header->version;	// share up global
 	if( isworld )
 	{
@@ -4287,17 +4296,17 @@ static qboolean Mod_LoadBmodelLumps( model_t *mod, byte *mod_base, size_t buffer
 
 	// loading base lumps
 	for( i = 0; i < ARRAYSIZE( srclumps ); i++, stat_index++ )
-		Mod_LoadLump( mod_base, &srclumps[i], &worldstats[stat_index], flags, LOADLUMP_STANDARD, NULL );
+		Mod_LoadLump( mod_base, &srclumps[i], &worldstats[stat_index], flags, LOADLUMP_STANDARD, NULL, bmod );
 
 	// loading extralumps
 	for( i = 0; i < ARRAYSIZE( extlumps ); i++, stat_index++ )
-		Mod_LoadLump( mod_base, &extlumps[i], &worldstats[stat_index], flags, LOADLUMP_BSP30EXT, NULL );
+		Mod_LoadLump( mod_base, &extlumps[i], &worldstats[stat_index], flags, LOADLUMP_BSP30EXT, NULL, bmod );
 
 	// loading bspx lumps
 	if( bspx_header_offset >= 0 )
 	{
 		for( i = 0; i < ARRAYSIZE( bspxlumps ); i++, stat_index++ )
-			Mod_LoadLump( mod_base, &bspxlumps[i], &worldstats[stat_index], flags, LOADLUMP_BSPX, mod_base + bspx_header_offset );
+			Mod_LoadLump( mod_base, &bspxlumps[i], &worldstats[stat_index], flags, LOADLUMP_BSPX, mod_base + bspx_header_offset, bmod );
 	}
 
 	if( !bmod->isworld ) // a1ba: why world excluded here?
@@ -4305,6 +4314,7 @@ static qboolean Mod_LoadBmodelLumps( model_t *mod, byte *mod_base, size_t buffer
 		if( loadstat.numerrors )
 		{
 			Con_DPrintf( "%s: %i error(s), %i warning(s)\n", __func__, loadstat.numerrors, loadstat.numwarnings );
+			Mem_Free( bmod );
 			return false; // there were errors, we can't load this map
 		}
 
@@ -4369,6 +4379,7 @@ static qboolean Mod_LoadBmodelLumps( model_t *mod, byte *mod_base, size_t buffer
 		Con_Reportf( "Wad files required to run the map: \"%s\"\n", wadvalue );
 	}
 
+	Mem_Free( bmod );
 	return true;
 }
 
@@ -4411,7 +4422,7 @@ qboolean Mod_TestBmodelLumps( file_t *f, const char *name, byte *mod_base, size_
 {
 	dheader_t   *header = (dheader_t *)mod_base;
 	int         *extident = (int *)( mod_base + sizeof( dheader_t ));
-	int         i, flags = LUMP_TESTONLY, stat_index = 0;
+	int         i, flags = 0, stat_index = 0;
 
 	// always reset the intermediate struct
 	memset( &loadstat, 0, sizeof( loadstat_t ));
@@ -4427,10 +4438,6 @@ qboolean Mod_TestBmodelLumps( file_t *f, const char *name, byte *mod_base, size_
 	// byte-swap BSP header and lump directory from little-endian
 	Mod_SwapBSPLumps( mod_base, buffersize );
 
-	// restore default lump numbers
-	srclumps[0].lumpnumber = LUMP_ENTITIES;
-	srclumps[1].lumpnumber = LUMP_PLANES;
-
 	switch( header->version )
 	{
 	case HLBSP_VERSION:
@@ -4452,11 +4459,7 @@ qboolean Mod_TestBmodelLumps( file_t *f, const char *name, byte *mod_base, size_
 					return false;
 
 				if( ret )
-				{
-					// blue-shift swapped lumps
-					srclumps[0].lumpnumber = LUMP_PLANES;
-					srclumps[1].lumpnumber = LUMP_ENTITIES;
-				}
+					SetBits( flags, LUMP_BSHIFT_SWAP );
 			}
 		}
 		break;
@@ -4472,15 +4475,15 @@ qboolean Mod_TestBmodelLumps( file_t *f, const char *name, byte *mod_base, size_
 	}
 
 	// get entities lump to caller
-	*entities = header->lumps[srclumps[0].lumpnumber];
+	*entities = header->lumps[FBitSet( flags, LUMP_BSHIFT_SWAP ) ? LUMP_PLANES : LUMP_ENTITIES];
 
 	// loading base lumps
 	for( i = 0; i < ARRAYSIZE( srclumps ); i++, stat_index++ )
-		Mod_LoadLump( mod_base, &srclumps[i], &worldstats[stat_index], flags, LOADLUMP_STANDARD, NULL );
+		Mod_LoadLump( mod_base, &srclumps[i], &worldstats[stat_index], flags, LOADLUMP_STANDARD, NULL, NULL );
 
 	// loading extralumps
 	for( i = 0; i < ARRAYSIZE( extlumps ); i++, stat_index++ )
-		Mod_LoadLump( mod_base, &extlumps[i], &worldstats[stat_index], flags, LOADLUMP_BSP30EXT, NULL );
+		Mod_LoadLump( mod_base, &extlumps[i], &worldstats[stat_index], flags, LOADLUMP_BSP30EXT, NULL, NULL );
 
 	// FIXME: BSPX testing
 

engine/common/mod_local.h

@@ -124,6 +124,10 @@ typedef struct world_static_s
 
 	wadentry_t   *wadlist;
 	int          wadcount;
+
+	// lightmapped water extra info
+	float        litwater_scale;
+	int          litwater_minlight;
 } world_static_t;
 
 #ifndef REF_DLL

engine/common/sys_con.c

@@ -86,7 +86,7 @@ void Sys_InitLog( void )
 
 	if( Sys_CheckParm( "-log" ))
 	{
-		if( !Sys_GetParmFromCmdLine( "-log", s_ld.log_path ) || !isalnum( s_ld.log_path[0] ))
+		if( !Sys_GetParmFromCmdLine( "-log", s_ld.log_path ) || !isalnum((byte)s_ld.log_path[0] ))
 			Q_strncpy( s_ld.log_path, "engine.log", sizeof( s_ld.log_path ));
 
 		COM_DefaultExtension( s_ld.log_path, ".log", sizeof( s_ld.log_path ));

engine/ref_api.h

@@ -105,6 +105,7 @@ GNU General Public License for more details.
 #define FWORLD_CUSTOM_SKYBOX BIT( 1 )
 #define FWORLD_WATERALPHA    BIT( 2 )
 #define FWORLD_HAS_DELUXEMAP BIT( 3 )
+#define FWORLD_HAS_LITWATER  BIT( 4 )
 
 // special rendermode for screenfade modulate
 // (probably will be expanded at some point)

engine/server/sv_client.c

@@ -3219,9 +3219,11 @@ void SV_ConnectionlessPacket( netadr_t from, sizebuf_t *msg )
 		return;
 	}
 
-	if( !Q_strcmp( pcmd, A2S_GOLDSRC_INFO ) || pcmd[0] == A2S_GOLDSRC_PLAYERS || pcmd[0] == A2S_GOLDSRC_RULES )
+	// Must check `args` because A2S_GOLDSRC_INFO contains spaces.
+	// `pcmd` points only to the first word from the query string.
+	if( !Q_strcmp( args, A2S_GOLDSRC_INFO ) || pcmd[0] == A2S_GOLDSRC_PLAYERS || pcmd[0] == A2S_GOLDSRC_RULES )
 	{
-		SV_SourceQuery_HandleConnnectionlessPacket( pcmd, from );
+		SV_SourceQuery_HandleConnnectionlessPacket( args, from );
 	}
 	else if( !Q_strcmp( pcmd, A2A_NETINFO ))
 	{

engine/server/sv_main.c

@@ -801,7 +801,7 @@ qboolean SV_ProcessUserAgent( netadr_t from, const char *useragent )
 	{
 		char c = id[i];
 
-		if( !isdigit( id[i] ) && !( c >= 'a' && c <= 'f' ))
+		if( !isdigit((byte)id[i] ) && !( c >= 'a' && c <= 'f' ))
 		{
 			SV_RejectConnection( from, "invalid authentication certificate\n" );
 			return false;

public/crtlib.c

@@ -929,12 +929,12 @@ void COM_TrimSpace( char *dst, const char *src, size_t size )
 		return;
 
 	// remove spaces from the start
-	for( ; *src && isspace( *src ); src++ );
+	for( ; *src && isspace((byte)*src ); src++ );
 
 	int len = Q_strlen( src );
 
 	// remove spaces from the end
-	for( ; len > 0 && isspace( src[len - 1] ); len-- );
+	for( ; len > 0 && isspace((byte)src[len - 1] ); len-- );
 
 	if( len > 0 )
 	{

public/crtlib.h

@@ -170,9 +170,15 @@ static inline qboolean Q_istype( const char *str, int (*istype)( int c ))
 {
 	if( likely( str && *str ))
 	{
-		while( istype( *str )) str++;
-		if( !*str ) return true;
+		// a1ba: explicitly cast char to unsigned char to not trigger UB
+		// in ctype functions
+		while( istype((byte)*str ))
+			str++;
+
+		if( !*str )
+			return true;
 	}
+
 	return false;
 }
 

ref/gl/gl_local.h

@@ -720,6 +720,7 @@ extern convar_t	gl_msaa;
 extern convar_t	gl_stencilbits;
 extern convar_t	gl_overbright;
 extern convar_t gl_fog;
+extern convar_t	gl_litwater_force;
 
 extern convar_t	r_lighting_ambient;
 extern convar_t	r_studio_lambert;

ref/gl/gl_opengl.c

@@ -22,6 +22,7 @@ CVAR_DEFINE_AUTO( gl_msaa, "1", FCVAR_GLCONFIG, "enable or disable multisample a
 CVAR_DEFINE_AUTO( gl_stencilbits, "8", FCVAR_GLCONFIG|FCVAR_READ_ONLY, "pixelformat stencil bits (0 - auto)" );
 CVAR_DEFINE_AUTO( gl_overbright, "1", FCVAR_GLCONFIG, "overbrights" );
 CVAR_DEFINE_AUTO( gl_fog, "1", FCVAR_GLCONFIG, "allow for rendering fog using built-in OpenGL fog implementation" );
+CVAR_DEFINE_AUTO( gl_litwater_force, "0", FCVAR_GLCONFIG, "force enable lightmapped water, even if support not declared in the map" );
 CVAR_DEFINE_AUTO( r_lighting_ambient, "0.3", FCVAR_GLCONFIG, "map ambient lighting scale" );
 CVAR_DEFINE_AUTO( r_detailtextures, "1", FCVAR_GLCONFIG, "enable detail textures support" );
 CVAR_DEFINE_AUTO( r_novis, "0", 0, "ignore vis information (perfomance test)" );
@@ -987,8 +988,7 @@ static void GL_InitExtensionsBigGL( void )
 
 	if( !GL_CheckExtension( "glDrawRangeElements", drawrangeelementsfuncs, ARRAYSIZE( drawrangeelementsfuncs ), "gl_drawrangeelements", GL_DRAW_RANGEELEMENTS_EXT, 0 ) )
 	{
-		if( GL_CheckExtension( "glDrawRangeElementsEXT", drawrangeelementsextfuncs, ARRAYSIZE( drawrangeelementsextfuncs ),
-			"gl_drawrangelements", GL_DRAW_RANGEELEMENTS_EXT, 0 ))
+		if( GL_CheckExtension( "glDrawRangeElementsEXT", drawrangeelementsextfuncs, ARRAYSIZE( drawrangeelementsextfuncs ), "gl_drawrangeelements", GL_DRAW_RANGEELEMENTS_EXT, 0 ))
 		{
 #if !XASH_GL_STATIC
 			pglDrawRangeElements = pglDrawRangeElementsEXT;
@@ -1184,6 +1184,7 @@ static void GL_InitCommands( void )
 	gEngfuncs.Cvar_RegisterVariable( &gl_round_down );
 	gEngfuncs.Cvar_RegisterVariable( &gl_overbright );
 	gEngfuncs.Cvar_RegisterVariable( &gl_fog );
+	gEngfuncs.Cvar_RegisterVariable( &gl_litwater_force );
 
 	gEngfuncs.Cvar_RegisterVariable( &gl_polyoffset );
 	gEngfuncs.Cvar_RegisterVariable( &gl_polyoffset_bmodels );

ref/gl/gl_rsurf.c

@@ -76,6 +76,39 @@ static inline qboolean R_SeparatePassActive( const separate_pass_t *sp )
 	return sp->last >= 0 ? true : false;
 }
 
+static qboolean Mod_HaveLightmappedWater( void )
+{
+	// if this flag set, it's level designer's job to ensure water has been properly lit
+	if( FBitSet( tr.world->flags, FWORLD_HAS_LITWATER ))
+		return true;
+
+	// otherwise, check user preference, as some maps have lightmapped water
+	return gl_litwater_force.value ? true : false;
+}
+
+static int Mod_LightmappedWaterMinlight( void )
+{
+	if( FBitSet( tr.world->flags, FWORLD_HAS_LITWATER ))
+	{
+		if( tr.world->litwater_minlight >= 0 )
+			return tr.world->litwater_minlight;
+	}
+
+	return 0;
+}
+
+static float Mod_LightmappedWaterScale( void )
+{
+	if( FBitSet( tr.world->flags, FWORLD_HAS_LITWATER ))
+	{
+		if( tr.world->litwater_scale >= 0.0f )
+			return tr.world->litwater_scale;
+
+	}
+
+	return 1.0f;
+}
+
 byte *Mod_GetCurrentVis( void )
 {
 	if( gEngfuncs.drawFuncs->Mod_GetCurrentVis && tr.fCustomRendering )
@@ -252,12 +285,29 @@ static void SubdividePolygon_r( model_t *loadmodel, msurface_t *warpface, int nu
 	{
 		VectorCopy( verts, poly->verts[i] );
 		R_TextureCoord( verts, warpface, &poly->verts[i][3] );
+		// lightmap texcoords for subdivided surfaces will be calculated later
+	}
+}
 
-		// for speed reasons
-		if( !FBitSet( warpface->flags, SURF_DRAWTURB ))
+static void GL_BuildLightmapWater( model_t *mod, msurface_t *fa )
+{
+	float sample_size;
+	glpoly2_t *poly;
+
+	if( !mod || !fa->texinfo || !fa->texinfo->texture )
+		return; // bad polygon?
+
+	sample_size = gEngfuncs.Mod_SampleSizeForFace( fa );
+
+	for( poly = fa->polys; poly; poly = poly->next )
+	{
+		int i;
+
+		for( i = 0; i < poly->numverts; i++ )
 		{
-			// lightmap texture coordinates
-			R_LightmapCoord( verts, warpface, sample_size, &poly->verts[i][5] );
+			vec3_t vec;
+			VectorCopy( poly->verts[i], vec );
+			R_LightmapCoord( vec, fa, sample_size, &poly->verts[i][5] );
 		}
 	}
 }
@@ -703,6 +753,8 @@ static void R_BuildLightMap( const msurface_t *surf, byte *dest, int stride, qbo
 	const mextrasurf_t *info = surf->info;
 	int lightscale;
 
+	const int litwater_minlight = Mod_LightmappedWaterMinlight();
+	const float litwater_scale = Mod_LightmappedWaterScale();
 	const int sample_size = gEngfuncs.Mod_SampleSizeForFace( surf );
 	const int smax = ( info->lightextents[0] / sample_size ) + 1;
 	const int tmax = ( info->lightextents[1] / sample_size ) + 1;
@@ -752,6 +804,14 @@ static void R_BuildLightMap( const msurface_t *surf, byte *dest, int stride, qbo
 			{
 				int t = bl[i] * lightscale >> 14;
 
+				// amp up water lightmap to avoid too dark water
+				// when the it wasn't properly lit by the level designer
+				if( FBitSet( surf->flags, SURF_DRAWTURB ))
+				{
+					float ft = t * litwater_scale;
+					t = Q_max( Q_rint( ft ), litwater_minlight );
+				}
+
 				if( t > 1023 )
 					t = 1023;
 
@@ -977,6 +1037,58 @@ static void EmitWaterPolys( msurface_t *warp, qboolean reverse, qboolean ripples
 	GL_SetupFogColorForSurfaces();
 }
 
+/*
+================
+EmitWaterLightPolys
+
+Render water lightmaps
+================
+*/
+static void EmitWaterLightPolys( msurface_t *warp, float soffset, float toffset, qboolean dynamic )
+{
+	const qboolean useQuads = FBitSet( warp->flags, SURF_DRAWTURB_QUADS );
+	glpoly2_t *p;
+	float waveHeight = RI.currententity->curstate.scale;
+
+	// set the current waveheight
+	if( warp->polys->verts[0][2] >= RI.rvp.vieworigin[2] )
+		waveHeight = -waveHeight;
+
+	if( useQuads )
+		pglBegin( GL_QUADS );
+
+	for( p = warp->polys; p; p = p->next )
+	{
+		float	*v = p->verts[0];
+		int i;
+
+		if( !useQuads )
+			pglBegin( GL_POLYGON );
+
+		for( i = 0; i < p->numverts; i++, v += VERTEXSIZE )
+		{
+			if( !dynamic ) pglTexCoord2f( v[5], v[6] );
+			else pglTexCoord2f( v[5] - soffset, v[6] - toffset );
+
+			if( waveHeight )
+			{
+				float nv = r_turbsin[(int)(gp_cl->time * 160.0f + v[1] + v[0]) & 255] + 8.0f;
+				nv = (r_turbsin[(int)(v[0] * 5.0f + gp_cl->time * 171.0f - v[1]) & 255] + 8.0f ) * 0.8f + nv;
+				nv = nv * waveHeight + v[2];
+
+				pglVertex3f( v[0], v[1], nv );
+			}
+			else pglVertex3fv( v );
+		}
+
+		if( !useQuads )
+			pglEnd ();
+	}
+
+	if( useQuads )
+		pglEnd();
+}
+
 /*
 ================
 DrawGLPolyChain
@@ -984,10 +1096,16 @@ DrawGLPolyChain
 Render lightmaps
 ================
 */
-static void DrawGLPolyChain( glpoly2_t *p, float soffset, float toffset )
+static void DrawGLPolyChain( glpoly2_t *p, float soffset, float toffset, msurface_t *surf )
 {
 	const qboolean dynamic = soffset != 0.0f || toffset != 0.0f;
 
+	if( FBitSet( surf->flags, SURF_DRAWTURB ))
+	{
+		EmitWaterLightPolys( surf, soffset, toffset, dynamic );
+		return;
+	}
+
 	for( ; p != NULL; p = p->chain )
 	{
 		float	*v;
@@ -1020,6 +1138,8 @@ static qboolean R_HasLightmap( void )
 		switch( RI.currententity->curstate.rendermode )
 		{
 		case kRenderTransTexture:
+			return FBitSet( RI.currentmodel->flags, MODEL_LIQUID ) ? true : false;
+
 		case kRenderTransColor:
 		case kRenderTransAdd:
 		case kRenderGlow:
@@ -1049,21 +1169,29 @@ static void R_BlendLightmaps( void )
 		pglEnable( GL_BLEND );
 	else pglDisable( GL_BLEND );
 
-	// lightmapped solid surfaces
-	pglDepthMask( GL_FALSE );
-	pglDepthFunc( GL_EQUAL );
-
 	pglDisable( GL_ALPHA_TEST );
-	if( gl_overbright.value )
+
+	if( RI.currententity->curstate.rendermode == kRenderTransTexture )
 	{
-		pglBlendFunc( GL_DST_COLOR, GL_SRC_COLOR );
-		if(!( R_HasEnabledVBO() && !r_vbo_overbrightmode.value ))
-			pglColor4f( 128.0f / 192.0f, 128.0f / 192.0f, 128.0f / 192.0f, 1.0f );
+		pglBlendFunc( GL_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA );
 	}
 	else
 	{
-		pglBlendFunc( GL_ZERO, GL_SRC_COLOR );
+		// lightmapped solid surfaces
+		pglDepthMask( GL_FALSE );
+		pglDepthFunc( GL_EQUAL );
+		if( gl_overbright.value )
+		{
+			pglBlendFunc( GL_DST_COLOR, GL_SRC_COLOR );
+			if(!( R_HasEnabledVBO() && !r_vbo_overbrightmode.value ))
+				pglColor4f( 128.0f / 192.0f, 128.0f / 192.0f, 128.0f / 192.0f, 1.0f );
+		}
+		else
+		{
+			pglBlendFunc( GL_ZERO, GL_SRC_COLOR );
+		}
 	}
+
 	pglTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
 
 	// render static lightmaps first
@@ -1075,7 +1203,7 @@ static void R_BlendLightmaps( void )
 
 			for( surf = gl_lms.lightmap_surfaces[i]; surf != NULL; surf = surf->info->lightmapchain )
 			{
-				if( surf->polys ) DrawGLPolyChain( surf->polys, 0.0f, 0.0f );
+				DrawGLPolyChain( surf->polys, 0.0f, 0.0f, surf );
 			}
 		}
 	}
@@ -1116,12 +1244,10 @@ static void R_BlendLightmaps( void )
 				// draw all surfaces that use this lightmap
 				for( drawsurf = newsurf; drawsurf != surf; drawsurf = drawsurf->info->lightmapchain )
 				{
-					if( drawsurf->polys )
-					{
-						DrawGLPolyChain( drawsurf->polys,
+					DrawGLPolyChain( drawsurf->polys,
 						( drawsurf->light_s - drawsurf->info->dlight_s ) * ( 1.0f / (float)BLOCK_SIZE ),
-						( drawsurf->light_t - drawsurf->info->dlight_t ) * ( 1.0f / (float)BLOCK_SIZE ));
-					}
+						( drawsurf->light_t - drawsurf->info->dlight_t ) * ( 1.0f / (float)BLOCK_SIZE ),
+						drawsurf );
 				}
 
 				newsurf = drawsurf;
@@ -1145,12 +1271,10 @@ static void R_BlendLightmaps( void )
 
 		for( surf = newsurf; surf != NULL; surf = surf->info->lightmapchain )
 		{
-			if( surf->polys )
-			{
-				DrawGLPolyChain( surf->polys,
+			DrawGLPolyChain( surf->polys,
 				( surf->light_s - surf->info->dlight_s ) * ( 1.0f / (float)BLOCK_SIZE ),
-				( surf->light_t - surf->info->dlight_t ) * ( 1.0f / (float)BLOCK_SIZE ));
-			}
+				( surf->light_t - surf->info->dlight_t ) * ( 1.0f / (float)BLOCK_SIZE ),
+				surf );
 		}
 	}
 
@@ -1418,8 +1542,13 @@ static void R_RenderBrushPoly( msurface_t *fa, int cull_type )
 
 	if( FBitSet( fa->flags, SURF_DRAWTURB ))
 	{
-		// warp texture, no lightmaps
+		// warp texture
 		EmitWaterPolys( fa, cull_type == CULL_BACKSIDE, R_UploadRipples( t ));
+
+		// add lightmaps if requested
+		if( Mod_HaveLightmappedWater( ))
+			R_RenderLightmapForSurface( fa );
+
 		return;
 	}
 	else GL_Bind( XASH_TEXTURE0, t->gl_texturenum );
@@ -1600,11 +1729,20 @@ void R_DrawWaterSurfaces( void )
 			continue;
 
 		for( ; s; s = s->texturechain )
+		{
 			EmitWaterPolys( s, false, R_UploadRipples( t ));
 
+			if( Mod_HaveLightmappedWater( ))
+				R_RenderLightmapForSurface( s );
+		}
+
 		t->texturechain = NULL;
 	}
 
+// litwater: not sure if needed
+	GL_ResetFogColor();
+	R_BlendLightmaps();
+
 	R_ResetSeparatePass( &draw_wateralpha );
 
 	pglDisable( GL_BLEND );
@@ -1717,8 +1855,16 @@ static int R_SortBrushModelSurfaces( cl_entity_t *e, model_t *clmodel, vec3_t mi
 
 		if( cull_type == CULL_BACKSIDE )
 		{
-			if( !FBitSet( psurf->flags, SURF_DRAWTURB ) && !( psurf->pdecals && e->curstate.rendermode == kRenderTransTexture ))
-				continue;
+			if( FBitSet( psurf->flags, SURF_DRAWTURB ))
+			{
+				if( Mod_HaveLightmappedWater( ))
+					continue; // we don't want back faces when drawing lightmaps to avoid Z fighting
+			}
+			else
+			{
+				if( !( psurf->pdecals && e->curstate.rendermode == kRenderTransTexture ))
+					continue;
+			}
 		}
 
 		if( num_sorted < gpGlobals->max_surfaces )
@@ -3917,7 +4063,10 @@ void GL_BuildLightmaps( void )
 			GL_CreateSurfaceLightmap( m->surfaces + j, m );
 
 			if( m->surfaces[j].flags & SURF_DRAWTURB )
+			{
+				GL_BuildLightmapWater( m, m->surfaces + j );
 				continue;
+			}
 
 			nColinElim += GL_BuildPolygonFromSurface( m, m->surfaces + j );
 		}

utils/mdldec/mdldec.c

@@ -49,12 +49,12 @@ IsValidName
 */
 static qboolean IsValidName( char *name )
 {
-	if( !( isalpha( *name ) || isdigit( *name )))
+	if( !( isalpha((byte)*name ) || isdigit((byte)*name )))
 		return false;
 
 	while( *( ++name ))
 	{
-		if( isalpha( *name ) || isdigit( *name )
+		if( isalpha((byte)*name ) || isdigit((byte)*name )
 		    || *name == '.' || *name == '-' || *name == '_'
 		    || *name == ' ' || *name == '(' || *name == ')'
 		    || *name == '[' || *name == ']')