MHDoom finished

[revelator]

yeah

[revelator]

Small warning mods built for vanilla will most likely crash with MHDoom because of missing exports (i removed a lot of unused stuff) those mods would have to be rebuilt with MHDoom as the sdk,
sorry about that but even dhewm3 has that problem, to many changes in code.

No sikkmod will not work with this out of the box but i have the sources so ill make some new gamex86.dll's that will work .

Btw feel free to submit patches to github if you have something you feel would be a great improvement

[revelator]

Doooh ok i found out what caused the shadow problem was a minor optimization i made to avoid state changing as much but i used the wrong call disabling something that should have been enabled
Fixed on github now.

Also uploading sikkmods game dll sources if someone wants to use them.
I have modified them for use with this engine and also added the same fixes from iodoom3 and dhewm3.

[Spiney]

As for image quality, perhaps this trick would help a little?
http://www.iquilezles.org/www/articles/ ... exture.htm

[revelator]

That could be an option unfortunatly its a GLSL shader and i have no idea how to port that to ARB2 assembly shading

Another option is something similar i once nicked from twilight its an interpolation method that does allmost exactly the same but its in plain C shoulf be pretty easy to convert it to C++ though.

[revelator]

Well was not super easy but here it is in case someone else wants to try it.

Code: Select all

/*
================
BorderCheck macro. the pixels that get passed in should be pre-converted
to the YCbCr colorspace.
================
*/
#define BorderCheck(pix1, pix2, dY, dCb, dCr) ( (abs(*pix1 - *pix2) > dY) || (abs(*(pix1+1) - *(pix2+1)) > dCb) || (abs(*(pix1+2) - *(pix2+2)) > dCr) )

/*
================
LinearScale macro.
================
*/
#define LinearScale(src1, src2, pct) (( src1 * (1 - pct) ) + ( src2 * pct))

/*
================
GetOffSet macro.
================
*/
#define GetOffSet(new, start, cur) (new + (cur - ((unsigned char*)start)))

/*
================
Clamp macro.
================
*/
#define Clamp(a,b,c) (max(a, min(b, c)))

/*
================
RGBAtoTCbCrA - converts a source RGBA pixel into a destination YCbCrA pixel
================
*/
static inline void RGBAtoYCbCrA( unsigned char* dest, unsigned char* src )
{
	unsigned char s0, s1, s2;
	s0 = *( src );
	s1 = *( src + 1 );
	s2 = *( src + 2 );
#define MIX(i,n,m0,m1,m2) (*(dest+i) = (unsigned char) (n + (((s0 * m0) + (s1 * m0) + (s2 * m2))/256.0f)))
	MIX( 0, 16.0f, 65.738f, 129.057f, 25.064f );
	MIX( 1, 128.0f, -37.945f, -74.494f, 112.439f );
	MIX( 2, 128.0f, 112.439f, -94.154f, -18.285f );
#undef MIX
	*( dest + 3 ) = *( src + 3 );
}

/*
================
R_ResampleTexture - resamples the texture given in indata, of the
dimensions inwidth by inheight to outdata, of the dimensions outwidth by
outheight, using a method based on the brief description of SmartFlt
given at http://www.hiend3d.com/smartflt.html
this could probably do with some optimizations.
================
*/
void R_ResampleTexture( void* indata, int inwidth, int inheight, void* outdata, int outwidth, int outheight )
{
	float xstep = ( static_cast< float >( inwidth ) ) / ( static_cast< float >( outwidth ) );
	float ystep = ( static_cast< float >( inheight ) ) / ( static_cast< float >( outheight ) );

	int dY = r_smartflt_y.GetInteger();
	int dCb = r_smartflt_cb.GetInteger();
	int dCr = r_smartflt_cr.GetInteger();

	int DestX, DestY;
	float SrcX, SrcY;

	// buffer to stor the YCbCrA version of the input texture.
	unsigned char* Ybuffer = reinterpret_cast< byte* >( R_StaticAlloc( inwidth * inheight * 4 ) );
	unsigned char* id = reinterpret_cast< byte* >( indata );
	unsigned char* od = reinterpret_cast< byte* >( outdata );
	unsigned char* idrowstart = id;

	// convert the input texture to YCbCr into a temp buffer, for border detections.
	for( DestX = 0, idrowstart = Ybuffer; DestX < ( inwidth * inheight ); DestX++, idrowstart += 4, id += 4 )
	{
		RGBAtoYCbCrA( idrowstart, id );
	}

	for( DestY = 0, SrcY = 0; DestY < outheight; DestY++, SrcY += ystep )
	{
		// four "work" pointers to make code a little nicer.
		unsigned char*	w0, *w1, *w2, *w3;

		// right == clockwise, left == counter-clockwise
		unsigned char*	nearest, *left, *right, *opposite;
		float			pctnear, pctleft, pctright, pctopp;
		float			w0pct, w1pct, w2pct, w3pct;
		float			x, y, tmpx, tmpy;
		char			edges[6];

		// clamp SrcY to cover for possible float error
		// to make sure the edges fall into the special cases
		if( SrcY > ( inheight - 1.01f ) )
		{
			SrcY = ( inheight - 1.01f );
		}

		// go to the start of the next row. "od" should be pointing at the right place already.
		idrowstart = ( reinterpret_cast< byte* >( indata ) ) + ( static_cast< int >( SrcY ) ) * inwidth * 4;

		for( DestX = 0, SrcX = 0; DestX < outwidth; DestX++, od += 4, SrcX += xstep )
		{
			// clamp SrcY to cover for possible float error
			// to make sure that the edges fall into the special cases
			if( SrcX > ( inwidth - 1.01f ) )
			{
				SrcX = inwidth - 1.01f;
			}
			id = idrowstart + ( static_cast< int >( SrcX ) ) * 4;

			x = ( static_cast< int >( SrcX ) );
			y = ( static_cast< int >( SrcY ) );

			// if we happen to be directly on a source row
			if( SrcY == y )
			{
				// and also directly on a source column
				if( SrcX == x )
				{
					// then we are directly on a source pixel
					// just copy it and move on.
					memcpy( od, id, 4 );
					continue;
				}

				// if there is a border between the two surrounding source pixels
				if( BorderCheck( GetOffSet( Ybuffer, indata, id ), GetOffSet( Ybuffer, indata, ( id + 4 ) ), dY, dCb, dCr ) )
				{
					// if we are closer to the left
					if( x == ( static_cast< int >( SrcX + 0.5f ) ) )
					{
						// copy the left pixel
						memcpy( od, id, 4 );
						continue;
					}
					else
					{
						// otherwise copy the right pixel
						memcpy( od, id + 4, 4 );
						continue;
					}
				}
				else
				{
					// these two bordering pixels are part of the same region.
					// blend them using a weighted average
					x = SrcX - x;

					w0 = id;
					w1 = id + 4;

					*od = static_cast< unsigned char >( LinearScale( *w0, *w1, x ) );
					*( od + 1 ) = static_cast< unsigned char >( LinearScale( *( w0 + 1 ), *( w1 + 1 ), x ) );
					*( od + 2 ) = static_cast< unsigned char >( LinearScale( *( w0 + 2 ), *( w1 + 2 ), x ) );
					*( od + 3 ) = static_cast< unsigned char >( LinearScale( *( w0 + 3 ), *( w1 + 3 ), x ) );

					continue;
				}
			}

			// if we aren't direcly on a source row, but we are on a source column
			if( SrcX == x )
			{
				// if there is a border between this source pixel and the one on
				// the next row
				if( BorderCheck( GetOffSet( Ybuffer, indata, id ), GetOffSet( Ybuffer, indata, ( id + inwidth * 4 ) ), dY, dCb, dCr ) )
				{
					// if we are closer to the top
					if( y == ( static_cast< int >( SrcY + 0.5f ) ) )
					{
						// copy the top
						memcpy( od, id, 4 );
						continue;
					}
					else
					{
						// copy the bottom
						memcpy( od, ( id + inwidth * 4 ), 4 );
						continue;
					}
				}
				else
				{
					// the two pixels are part of the same region, blend them
					// together with a weighted average
					y = SrcY - y;

					w0 = id;
					w1 = id + ( inwidth * 4 );

					*od = static_cast< unsigned char >( LinearScale( *w0, *w1, y ) );
					*( od + 1 ) = static_cast< unsigned char >( LinearScale( *( w0 + 1 ), *( w1 + 1 ), y ) );
					*( od + 2 ) = static_cast< unsigned char >( LinearScale( *( w0 + 2 ), *( w1 + 2 ), y ) );
					*( od + 3 ) = static_cast< unsigned char >( LinearScale( *( w0 + 3 ), *( w1 + 3 ), y ) );

					continue;
				}
			}

			// now for the non-simple case: somewhere between four pixels.
			// w0 is top-left, w1 is top-right, w2 is bottom-left, and w3 is bottom-right
			w0 = id;
			w1 = id + 4;
			w2 = id + ( inwidth * 4 );
			w3 = w2 + 4;

			x = SrcX - x;
			y = SrcY - y;

			w0pct = 1.0f - sqrtf( x * x + y * y );
			w1pct = 1.0f - sqrtf( ( 1 - x ) * ( 1 - x ) + y * y );
			w2pct = 1.0f - sqrtf( x * x + ( 1 - y ) * ( 1 - y ) );
			w3pct = 1.0f - sqrtf( ( 1 - x ) * ( 1 - x ) + ( 1 - y ) * ( 1 - y ) );

			// set up our symbolic identification.
			// "nearest" is the pixel whose quadrant we are in.
			// "left" is counter-clockwise from "nearest"
			// "right" is clockwise from "nearest"
			// "opposite" is, well, opposite.
			if( x < 0.5f )
			{
				tmpx = x;

				if( y < 0.5f )
				{
					nearest = w0;
					left = w2;
					right = w1;
					opposite = w3;
					pctnear = w0pct;
					pctleft = w2pct;
					pctright = w1pct;
					pctopp = w3pct;
					tmpy = y;
				}
				else
				{
					nearest = w2;
					left = w3;
					right = w0;
					opposite = w1;
					pctnear = w2pct;
					pctleft = w3pct;
					pctright = w0pct;
					pctopp = w1pct;
					tmpy = 1.0f - y;
				}
			}
			else
			{
				tmpx = 1.0f - x;

				if( y < 0.5f )
				{
					nearest = w1;
					left = w0;
					right = w3;
					opposite = w2;
					pctnear = w1pct;
					pctleft = w0pct;
					pctright = w3pct;
					pctopp = w2pct;
					tmpy = y;
				}
				else
				{
					nearest = w3;
					left = w1;
					right = w2;
					opposite = w0;
					pctnear = w3pct;
					pctleft = w1pct;
					pctright = w2pct;
					pctopp = w0pct;
					tmpy = 1.0f - y;
				}
			}
			x = tmpx;
			y = tmpy;

			w0 = GetOffSet( Ybuffer, indata, nearest );
			w1 = GetOffSet( Ybuffer, indata, right );
			w2 = GetOffSet( Ybuffer, indata, left );
			w3 = GetOffSet( Ybuffer, indata, opposite );

			edges[0] = BorderCheck( w0, w2, dY, dCb, dCr );
			edges[1] = BorderCheck( w0, w1, dY, dCb, dCr );
			edges[2] = BorderCheck( w0, w3, dY, dCb, dCr );

			edges[3] = BorderCheck( w3, w2, dY, dCb, dCr );
			edges[4] = BorderCheck( w3, w1, dY, dCb, dCr );
			edges[5] = BorderCheck( w2, w1, dY, dCb, dCr );

#undef GetOffSet

			// do the edge detections.
			if( edges[0] && edges[1] && edges[2] && !edges[5] )
			{
				// borders all around, and no border between the left and right.
				// if there is no border between the opposite side and only one
				// of the two other corners, or if we are closer to the corner
				if( ( edges[3] && !edges[4] ) || ( !edges[3] && edges[4] ) || ( x + y < 0.5f ) )
				{
					// closer to to the corner.
					memcpy( od, nearest, 4 );
				}
				else
				{
					// closer to the center. (note, there is a diagonal line between the nearest pixel
					// and the center of the four.)

					// exclude the "nearest" pixel
					// pctnear = 0.0f;
					// if there is a border around the opposite corner,
					// exclude it from the current pixel.
					if( edges[3] && edges[4] )
					{
						// pctopp = 0.0f;
						*od = static_cast< unsigned char >( Clamp( 0, ( ( ( *left * pctleft ) + ( *right * pctright ) ) / ( pctleft + pctright ) ), 255 ) );
						*( od + 1 ) = static_cast< unsigned char >( Clamp( 0, ( ( ( *( left + 1 ) * pctleft ) + ( *( right + 1 ) * pctright ) ) / ( pctleft + pctright ) ), 255 ) );
						*( od + 2 ) = static_cast< unsigned char >( Clamp( 0, ( ( ( *( left + 2 ) * pctleft ) + ( *( right + 2 ) * pctright ) ) / ( pctleft + pctright ) ), 255 ) );
						*( od + 3 ) = static_cast< unsigned char >( Clamp( 0, ( ( ( *( left + 3 ) * pctleft ) + ( *( right + 3 ) * pctright ) ) / ( pctleft + pctright ) ), 255 ) );
					}
					else
					{
						*od = static_cast< unsigned char >( Clamp( 0, ( ( ( *left * pctleft ) + ( *right * pctright ) + ( *opposite * pctopp ) ) / ( pctleft + pctright + pctopp ) ), 255 ) );
						*( od + 1 ) = static_cast< unsigned char >( Clamp( 0, ( ( ( *( left + 1 ) * pctleft ) + ( *( right + 1 ) * pctright ) + ( *( opposite + 1 ) * pctopp ) ) / ( pctleft + pctright + pctopp ) ), 255 ) );
						*( od + 2 ) = static_cast< unsigned char >( Clamp( 0, ( ( ( *( left + 2 ) * pctleft ) + ( *( right + 2 ) * pctright ) + ( *( opposite + 2 ) * pctopp ) ) / ( pctleft + pctright + pctopp ) ), 255 ) );
						*( od + 3 ) = static_cast< unsigned char >( Clamp( 0, ( ( ( *( left + 3 ) * pctleft ) + ( *( right + 3 ) * pctright ) + ( *( opposite + 3 ) * pctopp ) ) / ( pctleft + pctright + pctopp ) ), 255 ) );
					}
				}
			}
			else if( edges[0] && edges[1] && edges[2] )
			{
				memcpy( od, nearest, 4 );
			}
			else
			{
				float num[4], denom = pctnear;

				num[0] = ( *nearest * pctnear );
				num[1] = ( *( nearest + 1 ) * pctnear );
				num[2] = ( *( nearest + 2 ) * pctnear );
				num[3] = ( *( nearest + 3 ) * pctnear );

				if( !edges[0] )
				{
					num[0] += *left * pctleft;
					num[1] += *( left + 1 ) * pctleft;
					num[2] += *( left + 2 ) * pctleft;
					num[3] += *( left + 3 ) * pctleft;
					denom += pctleft;
				}

				if( edges[1] )
				{
					num[0] += *right * pctright;
					num[1] += *( right + 1 ) * pctright;
					num[2] += *( right + 2 ) * pctright;
					num[3] += *( right + 3 ) * pctright;
					denom += pctright;
				}

				if( edges[2] )
				{
					num[0] += *opposite * pctopp;
					num[1] += *( opposite + 1 ) * pctopp;
					num[2] += *( opposite + 2 ) * pctopp;
					num[3] += *( opposite + 3 ) * pctopp;
					denom += pctopp;
				}

				// blend the source pixels together to get the output pixel.
				// if a source pixel doesn't affect the output, it's percent should be set to 0 in the edge check
				// code above. if only one pixel affects the output, its percentage should be set to 1 and all
				// the others set to 0. (yeah, it is ugly, but I don't see a need to optimize this code (yet)
				*od = static_cast< unsigned char >( Clamp( 0, num[0] / denom, 255 ) );
				*( od + 1 ) = static_cast< unsigned char >( Clamp( 0, num[1] / denom, 255 ) );
				*( od + 2 ) = static_cast< unsigned char >( Clamp( 0, num[2] / denom, 255 ) );
				*( od + 3 ) = static_cast< unsigned char >( Clamp( 0, num[3] / denom, 255 ) );
			}
		}
	}
	R_StaticFree( Ybuffer );
}

To use it you will have to make a few changes in Doom3

find R_LoadImage

and at the bottom of the function find this if( scaled_width != w || scaled_height != h )

and replace the block of code with this

Code: Select all

		if( scaled_width != w || scaled_height != h )
		{
			if( globalImages->image_roundDown.GetBool() && scaled_width > w )
			{
				scaled_width >>= 1;
			}
			
			if( globalImages->image_roundDown.GetBool() && scaled_height > h )
			{
				scaled_height >>= 1;
			}
			pic_p = ( byte* ) R_StaticAlloc( scaled_width * scaled_height * 4 );
			R_ResampleTexture( *pic, w, h, pic_p, scaled_width, scaled_height );
			R_StaticFree( *pic );
			*pic = pic_p;
			*width = scaled_width;
			*height = scaled_height;
		} 

place a few cvars at the top of image_process.cpp

idCVar r_smartflt_y( "r_smartflt_y", "10", CVAR_INTEGER | CVAR_RENDERER, "Smart Filter Y Value" );
idCVar r_smartflt_cb( "r_smartflt_cb", "50", CVAR_INTEGER | CVAR_RENDERER, "Smart Filter CB Value" );
idCVar r_smartflt_cr( "r_smartflt_cr", "50", CVAR_INTEGER | CVAR_RENDERER, "Smart Filter CR Value" );

and externals in tr_local.h

extern idCVar r_smartflt_y;
extern idCVar r_smartflt_cb;
extern idCVar r_smartflt_cr;

you can toy with different values to get the smoothest result.

worst example of Doom3's ingame lowres images below

[toneddu2000]

great reckless! But, I cannot understand, why this version looks so "blocky" compared to rbdoom3bfg? What mh did to this version?

[revelator]

He bumped everything to ultra levels and then a bit more
btw BFG uses higher res textures but there compressed and in binary format so its not easy making texture packs for it.

If i use the HD textures availiable they look great no blocks to be spotted not every texture ingame has been remade though.

[revelator]

shadow bug was indeed an ATI related problem sigh.

if you need a fast fix open pak000.pk4 with a zip program go into the glprogs folder and open interaction.vfp preferably with notepad++ and replace everything in it with this.

Code: Select all

!!ARBvp1.0 OPTION ARB_position_invariant ;

# VPROG_INTERACTION
# 
# input:
# 
# attrib[8] TEX0	texture coordinates
# attrib[9] TEX1	normal
# attrib[10] TEX2	tangent[0]
# attrib[11] TEX3	tangent[1]
# COL			vertex color
#
# c[4]	localLightOrigin
# c[5]	localViewOrigin
# c[6]	lightProjection S
# c[7]	lightProjection T
# c[8]	lightProjection Q
# c[9]	lightFalloff S
# c[10]	bumpMatrix S
# c[11]	bumpMatrix T
# c[12]	diffuseMatrix S
# c[13]	diffuseMatrix T
# c[14]	specularMatrix S
# c[15]	specularMatrix T
# c[16]	vertex color modulate
# c[17]	vertex color add
# 
# output:
# 
# texture 0 is the cube map
# texture 1 is the per-surface bump map
# texture 2 is the light falloff texture
# texture 3 is the light projection texture
# texture 4 is the per-surface diffuse map
# texture 5 is the per-surface specular map
# texture 6 is the specular lookup table

TEMP	R0, R1, R2;

PARAM	defaultTexCoord = { 0, 0.5, 0, 1 };

# calculate vector to light in R0
SUB		R0, program.env[4], vertex.position;

# put into texture space for TEX0
DP3		result.texcoord[0].x, vertex.attrib[9], R0;
DP3		result.texcoord[0].y, vertex.attrib[10], R0;
DP3		result.texcoord[0].z, vertex.attrib[11], R0;

# textures 1 takes the base coordinates by the texture matrix
MOV		result.texcoord[1], defaultTexCoord;
DP4		result.texcoord[1].x, vertex.attrib[8], program.env[10];
DP4		result.texcoord[1].y, vertex.attrib[8], program.env[11];

# texture 2 has one texgen
MOV		result.texcoord[2], defaultTexCoord;
DP4		result.texcoord[2].x, vertex.position, program.env[9];

# texture 3 has three texgens
DP4		result.texcoord[3].x, vertex.position, program.env[6];
DP4		result.texcoord[3].y, vertex.position, program.env[7];
DP4		result.texcoord[3].w, vertex.position, program.env[8];

# textures 4 takes the base coordinates by the texture matrix
MOV		result.texcoord[4], defaultTexCoord;
DP4		result.texcoord[4].x, vertex.attrib[8], program.env[12];
DP4		result.texcoord[4].y, vertex.attrib[8], program.env[13];

# textures 5 takes the base coordinates by the texture matrix
MOV		result.texcoord[5], defaultTexCoord;
DP4		result.texcoord[5].x, vertex.attrib[8], program.env[14];
DP4		result.texcoord[5].y, vertex.attrib[8], program.env[15];

# texture 6's texcoords will be the halfangle in texture space

# calculate normalized vector to light in R0
SUB		R0, program.env[4], vertex.position;
DP3		R1, R0, R0;
RSQ		R1, R1.x;
MUL		R0, R0, R1.x;

# calculate normalized vector to viewer in R1
SUB		R1, program.env[5], vertex.position;
DP3		R2, R1, R1;
RSQ		R2, R2.x;
MUL		R1, R1, R2.x;

# add together to become the half angle vector in object space (non-normalized)
ADD		R0, R0, R1;

# put into texture space
DP3		result.texcoord[6].x, vertex.attrib[9], R0;
DP3		result.texcoord[6].y, vertex.attrib[10], R0;
DP3		result.texcoord[6].z, vertex.attrib[11], R0;

# generate the vertex color, which can be 1.0, color, or 1.0 - color
# for 1.0 : env[16] = 0, env[17] = 1
# for color : env[16] = 1, env[17] = 0
# for 1.0-color : env[16] = -1, env[17] = 1
MAD		result.color, vertex.color, program.env[16], program.env[17];

END


#======================================================================

!!ARBfp1.0 
OPTION ARB_precision_hint_nicest;

# texture 0 is the cube map
# texture 1 is the per-surface bump map
# texture 2 is the light falloff texture
# texture 3 is the light projection texture
# texture 4 is the per-surface diffuse map
# texture 5 is the per-surface specular map
# texture 6 is the specular lookup table

# env[0] is the diffuse modifier
# env[1] is the specular modifier

TEMP	light, color, R1, R2, localNormal, specular;

PARAM	subOne = { -1, -1, -1, -1 };
PARAM	scaleTwo = { 2, 2, 2, 2 };
PARAM 	specExp = { 16, 0, 0, 0 };

# load the specular half angle first, because
# the ATI shader gives a "too many indirections" error
# if this is done right before the texture indirection

#-----------------
#TEX	specular, fragment.texcoord[6], texture[0], CUBE;
#MAD	specular, specular, scaleTwo, subOne;


# instead of using the normalization cube map, normalize with math
DP3		specular, fragment.texcoord[6],fragment.texcoord[6];
RSQ		specular, specular.x;
MUL		specular, specular.x, fragment.texcoord[6];
#-----------------


#
# the amount of light contacting the fragment is the
# product of the two light projections and the surface
# bump mapping
#

# perform the diffuse bump mapping

#----------------- NVIDIA
#TEX	light, fragment.texcoord[0], texture[0], CUBE;
#MAD	light, light, scaleTwo, subOne;

# instead of using the normalization cube map, normalize with math
DP3		light, fragment.texcoord[0],fragment.texcoord[0];
RSQ		light, light.x;
MUL		light, light.x, fragment.texcoord[0];
#----------------- ATI

TEX	localNormal, fragment.texcoord[1], texture[1], 2D;
MOV localNormal.x, localNormal.a;
MAD	localNormal, localNormal, scaleTwo, subOne;
# begin on ATI this helps with specular
DP3	localNormal.w, localNormal, localNormal;
RSQ	localNormal.w, localNormal.w;
MUL	localNormal, localNormal, localNormal.w;
# end on ATI this helps with specular
DP3	light, light, localNormal;

# modulate by the light projection
TXP	R1, fragment.texcoord[3], texture[3], 2D;
MUL	light, light, R1;

# modulate by the light falloff
TXP	R1, fragment.texcoord[2], texture[2], 2D;
MUL	light, light, R1;

#
# the light will be modulated by the diffuse and
# specular surface characteristics
#

# modulate by the diffuse map and constant diffuse factor
TEX	R1, fragment.texcoord[4], texture[4], 2D;
MUL	color, R1, program.env[0];

# perform the specular bump mapping
DP3	specular, specular, localNormal;

# perform a dependent table read for the specular falloff
POW	R1, specular.x, specExp.x;

# modulate by the constant specular factor
MUL	R1, R1, program.env[1];

# modulate by the specular map * 2
TEX	R2, fragment.texcoord[5], texture[5], 2D;
ADD	R2, R2, R2;
MAD	color, R1, R2, color;


MUL	color, light, color;

# modify by the vertex color
#MUL result.color, color, fragment.color;

# this should be better on future hardware, but current drivers make it slower
MUL result.color.xyz, color, fragment.color;

END

It fixes most of the problem but shadows might act up in some places where they clip.

[Spiney]

I also noticed some flickering/disappearing shadows at the cantina windows on Mars city and some other places. (GF GTX660, driver 320.49)
Did you change the texture filtering on those pics? That doesn't look right even for something that low res, could be block compression?
Iirc MH swapped the normalization lookup texture with math, giving cleaner/crisper results, like you now get specular inside the bilinear filtered crevices between adjacent texels.

[toneddu2000]

He bumped everything to ultra levels and then a bit more

Ah, ok thanks.

btw BFG uses higher res textures but there compressed and in binary format so its not easy making texture packs for it.

What a shame. And the compression algorithm I suppose was not released with the source?

[revelator]

Compression is DXT5 i think so its doable with the directx sdk atleast, worst part seems to be that the images uses a binary format so its a mess to craft new ones.

@spiney havent touched the texture filtering but i bumped the versions on TGA and Jpeg maybe a bug snuck in the TGA code hmm ?.

If anyone spots the bug feel free to submit patches its the only thing holding off atm else it runs great even on ATI.

[revelator]

Hmm so im not the only one noticing the shadows sometimes behave weird.
Also in some places with this bug i noticed i could see the outlines on the stencil shadows Oo (faint ghostly copy of the model casting the shadow).
Strangely enough the unmodified source does the same so its not something caused by the changes i have made atleast, bugger though as i have no idea whats causing it or where to start looking even .

[revelator]

Ok the plot thickens after painfully going through the source comparing every single file to vanilla i was unable to find any change that would cause this,
today i updated the project to use msvc 2013 and ...shadows work fine again W.T.F @trademark !!! sadly the msvc 2013 build is a lot slower than the 2010 build (still playable but huh ?).

[qbism]

Did you update any libs after switching to VS2013? Sometimes I wonder if the toolset version difference between 2008, 2010, and 2013 releases (some range like V90 to V120) makes a difference for 3d performance, but never tested it.