X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;f=image.c;h=e58c76a0524941111146a14d78fc92d9cc317e2d;hb=3a1e31d2cbf35505278d48bc9bf9d5e3902fd3b7;hp=5a151506f6d0646a92ef38471d89ff3fe712956c;hpb=ea3f4513f96a21ae1bcbaae4a4997968ace1ab95;p=xonotic%2Fdarkplaces.git

diff --git a/image.c b/image.c
index 5a151506..e58c76a0 100644
--- a/image.c
+++ b/image.c
@@ -2,6 +2,7 @@
 #include "quakedef.h"
 #include "image.h"
 #include "jpeg.h"
+#include "image_png.h"
 #include "r_shadow.h"
 
 int		image_width;
@@ -299,7 +300,7 @@ LoadTGA
 */
 unsigned char *LoadTGA (const unsigned char *f, int filesize, int matchwidth, int matchheight)
 {
-	int x, y, row_inc, compressed, readpixelcount, red, green, blue, alpha, runlen, pindex, alphabits;
+	int x, y, pix_inc, row_inc, red, green, blue, alpha, runlen, alphabits;
 	unsigned char *pixbuf, *image_rgba;
 	const unsigned char *fin, *enddata;
 	unsigned char *p;
@@ -385,35 +386,35 @@ unsigned char *LoadTGA (const unsigned char *f, int filesize, int matchwidth, in
 	}
 
 	// check our pixel_size restrictions according to image_type
-	if (targa_header.image_type == 2 || targa_header.image_type == 10)
+	switch (targa_header.image_type & ~8)
 	{
+	case 2:
 		if (targa_header.pixel_size != 24 && targa_header.pixel_size != 32)
 		{
 			Con_Print("LoadTGA: only 24bit and 32bit pixel sizes supported for type 2 and type 10 images\n");
 			PrintTargaHeader(&targa_header);
 			return NULL;
 		}
-	}
-	else if (targa_header.image_type == 1 || targa_header.image_type == 9)
-	{
-		if (targa_header.pixel_size != 8)
+		break;
+	case 3:
+		// set up a palette to make the loader easier
+		for (x = 0;x < 256;x++)
 		{
-			Con_Print("LoadTGA: only 8bit pixel size for type 1, 3, 9, and 11 images supported\n");
-			PrintTargaHeader(&targa_header);
-			return NULL;
+			palette[x*4+2] = x;
+			palette[x*4+1] = x;
+			palette[x*4+0] = x;
+			palette[x*4+3] = 255;
 		}
-	}
-	else if (targa_header.image_type == 3 || targa_header.image_type == 11)
-	{
+		// fall through to colormap case
+	case 1:
 		if (targa_header.pixel_size != 8)
 		{
 			Con_Print("LoadTGA: only 8bit pixel size for type 1, 3, 9, and 11 images supported\n");
 			PrintTargaHeader(&targa_header);
 			return NULL;
 		}
-	}
-	else
-	{
+		break;
+	default:
 		Con_Printf("LoadTGA: Only type 1, 2, 3, 9, 10, and 11 targa RGB images supported, image_type = %i\n", targa_header.image_type);
 		PrintTargaHeader(&targa_header);
 		return NULL;
@@ -452,80 +453,215 @@ unsigned char *LoadTGA (const unsigned char *f, int filesize, int matchwidth, in
 		row_inc = 0;
 	}
 
-	compressed = targa_header.image_type == 9 || targa_header.image_type == 10 || targa_header.image_type == 11;
 	x = 0;
 	y = 0;
 	red = green = blue = alpha = 255;
-	while (y < image_height)
-	{
-		// decoder is mostly the same whether it's compressed or not
-		readpixelcount = 1000000;
-		runlen = 1000000;
-		if (compressed && fin < enddata)
+	pix_inc = 1;
+	if ((targa_header.image_type & ~8) == 2)
+		pix_inc = targa_header.pixel_size / 8;
+	switch (targa_header.image_type)
+	{
+	case 1: // colormapped, uncompressed
+	case 3: // greyscale, uncompressed
+		if (fin + image_width * image_height * pix_inc > enddata)
+			break;
+		for (y = 0;y < image_height;y++, pixbuf += row_inc)
 		{
-			runlen = *fin++;
-			// high bit indicates this is an RLE compressed run
-			if (runlen & 0x80)
-				readpixelcount = 1;
-			runlen = 1 + (runlen & 0x7f);
+			for (x = 0;x < image_width;x++)
+			{
+				p = palette + *fin++ * 4;
+				*pixbuf++ = p[0];
+				*pixbuf++ = p[1];
+				*pixbuf++ = p[2];
+				*pixbuf++ = p[3];
+			}
 		}
-
-		while((runlen--) && y < image_height)
+		break;
+	case 2:
+		// BGR or BGRA, uncompressed
+		if (fin + image_width * image_height * pix_inc > enddata)
+			break;
+		if (targa_header.pixel_size == 32 && alphabits)
+		{
+			for (y = 0;y < image_height;y++, pixbuf += row_inc)
+			{
+				for (x = 0;x < image_width;x++, fin += pix_inc)
+				{
+					*pixbuf++ = fin[2];
+					*pixbuf++ = fin[1];
+					*pixbuf++ = fin[0];
+					*pixbuf++ = fin[3];
+				}
+			}
+		}
+		else
+		{
+			for (y = 0;y < image_height;y++, pixbuf += row_inc)
+			{
+				for (x = 0;x < image_width;x++, fin += pix_inc)
+				{
+					*pixbuf++ = fin[2];
+					*pixbuf++ = fin[1];
+					*pixbuf++ = fin[0];
+					*pixbuf++ = 255;
+				}
+			}
+		}
+		break;
+	case 9: // colormapped, RLE
+	case 11: // greyscale, RLE
+		for (y = 0;y < image_height;y++, pixbuf += row_inc)
 		{
-			if (readpixelcount > 0)
+			for (x = 0;x < image_width;)
 			{
-				readpixelcount--;
-				red = green = blue = alpha = 255;
-				if (fin < enddata)
+				if (fin >= enddata)
+					break; // error - truncated file
+				runlen = *fin++;
+				if (runlen & 0x80)
 				{
-					switch(targa_header.image_type)
+					// RLE - all pixels the same color
+					runlen += 1 - 0x80;
+					if (fin + pix_inc > enddata)
+						break; // error - truncated file
+					if (x + runlen > image_width)
+						break; // error - line exceeds width
+					p = palette + *fin++ * 4;
+					red = p[0];
+					green = p[1];
+					blue = p[2];
+					alpha = p[3];
+					for (;runlen--;x++)
 					{
-					case 1:
-					case 9:
-						// colormapped
-						pindex = *fin++;
-						if (pindex >= targa_header.colormap_length)
-							pindex = 0; // error
-						p = palette + pindex * 4;
-						red = p[0];
-						green = p[1];
-						blue = p[2];
-						alpha = p[3];
-						break;
-					case 2:
-					case 10:
-						// BGR or BGRA
-						blue = *fin++;
-						if (fin < enddata)
-							green = *fin++;
-						if (fin < enddata)
-							red = *fin++;
-						if (targa_header.pixel_size == 32 && fin < enddata)
-							alpha = *fin++;
-						break;
-					case 3:
-					case 11:
-						// greyscale
-						red = green = blue = *fin++;
-						break;
+						*pixbuf++ = red;
+						*pixbuf++ = green;
+						*pixbuf++ = blue;
+						*pixbuf++ = alpha;
+					}
+				}
+				else
+				{
+					// uncompressed - all pixels different color
+					runlen++;
+					if (fin + pix_inc * runlen > enddata)
+						break; // error - truncated file
+					if (x + runlen > image_width)
+						break; // error - line exceeds width
+					for (;runlen--;x++)
+					{
+						p = palette + *fin++ * 4;
+						*pixbuf++ = p[0];
+						*pixbuf++ = p[1];
+						*pixbuf++ = p[2];
+						*pixbuf++ = p[3];
+					}
+				}
+			}
+		}
+		break;
+	case 10:
+		// BGR or BGRA, RLE
+		if (targa_header.pixel_size == 32 && alphabits)
+		{
+			for (y = 0;y < image_height;y++, pixbuf += row_inc)
+			{
+				for (x = 0;x < image_width;)
+				{
+					if (fin >= enddata)
+						break; // error - truncated file
+					runlen = *fin++;
+					if (runlen & 0x80)
+					{
+						// RLE - all pixels the same color
+						runlen += 1 - 0x80;
+						if (fin + pix_inc > enddata)
+							break; // error - truncated file
+						if (x + runlen > image_width)
+							break; // error - line exceeds width
+						red = fin[2];
+						green = fin[1];
+						blue = fin[0];
+						alpha = fin[3];
+						fin += pix_inc;
+						for (;runlen--;x++)
+						{
+							*pixbuf++ = red;
+							*pixbuf++ = green;
+							*pixbuf++ = blue;
+							*pixbuf++ = alpha;
+						}
+					}
+					else
+					{
+						// uncompressed - all pixels different color
+						runlen++;
+						if (fin + pix_inc * runlen > enddata)
+							break; // error - truncated file
+						if (x + runlen > image_width)
+							break; // error - line exceeds width
+						for (;runlen--;x++, fin += pix_inc)
+						{
+							*pixbuf++ = fin[2];
+							*pixbuf++ = fin[1];
+							*pixbuf++ = fin[0];
+							*pixbuf++ = fin[3];
+						}
 					}
-					if (!alphabits)
-						alpha = 255;
 				}
 			}
-			*pixbuf++ = red;
-			*pixbuf++ = green;
-			*pixbuf++ = blue;
-			*pixbuf++ = alpha;
-			x++;
-			if (x == image_width)
+		}
+		else
+		{
+			for (y = 0;y < image_height;y++, pixbuf += row_inc)
 			{
-				// end of line, advance to next
-				x = 0;
-				y++;
-				pixbuf += row_inc;
+				for (x = 0;x < image_width;)
+				{
+					if (fin >= enddata)
+						break; // error - truncated file
+					runlen = *fin++;
+					if (runlen & 0x80)
+					{
+						// RLE - all pixels the same color
+						runlen += 1 - 0x80;
+						if (fin + pix_inc > enddata)
+							break; // error - truncated file
+						if (x + runlen > image_width)
+							break; // error - line exceeds width
+						red = fin[2];
+						green = fin[1];
+						blue = fin[0];
+						alpha = 255;
+						fin += pix_inc;
+						for (;runlen--;x++)
+						{
+							*pixbuf++ = red;
+							*pixbuf++ = green;
+							*pixbuf++ = blue;
+							*pixbuf++ = alpha;
+						}
+					}
+					else
+					{
+						// uncompressed - all pixels different color
+						runlen++;
+						if (fin + pix_inc * runlen > enddata)
+							break; // error - truncated file
+						if (x + runlen > image_width)
+							break; // error - line exceeds width
+						for (;runlen--;x++, fin += pix_inc)
+						{
+							*pixbuf++ = fin[2];
+							*pixbuf++ = fin[1];
+							*pixbuf++ = fin[0];
+							*pixbuf++ = 255;
+						}
+					}
+				}
 			}
 		}
+		break;
+	default:
+		// unknown image_type
+		break;
 	}
 
 	return image_rgba;
@@ -571,16 +707,11 @@ unsigned char *LoadLMP (const unsigned char *f, int filesize, int matchwidth, in
 	else
 	{
 		image_buffer = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
-		Image_Copy8bitRGBA(f + 8, image_buffer, image_width * image_height, palette_complete);
+		Image_Copy8bitRGBA(f + 8, image_buffer, image_width * image_height, palette_transparent);
 	}
 	return image_buffer;
 }
 
-static unsigned char *LoadLMPRGBA (const unsigned char *f, int filesize, int matchwidth, int matchheight)
-{
-	return LoadLMP(f, filesize, matchwidth, matchheight, false);
-}
-
 
 typedef struct q2wal_s
 {
@@ -631,9 +762,13 @@ unsigned char *LoadWAL (const unsigned char *f, int filesize, int matchwidth, in
 }
 
 
-void Image_StripImageExtension (const char *in, char *out)
+static void Image_StripImageExtension (const char *in, char *out, size_t size_out)
 {
 	const char *end, *temp;
+
+	if (size_out == 0)
+		return;
+
 	end = in + strlen(in);
 	if ((end - in) >= 4)
 	{
@@ -644,74 +779,141 @@ void Image_StripImageExtension (const char *in, char *out)
 		 || strcmp(temp, ".png") == 0
 		 || strcmp(temp, ".jpg") == 0)
 			end = temp;
-		while (in < end)
+		while (in < end && size_out > 1)
+		{
 			*out++ = *in++;
+			size_out--;
+		}
 		*out++ = 0;
 	}
 	else
-		strcpy(out, in);
+		strlcpy(out, in, size_out);
 }
 
-struct imageformat_s
+typedef struct imageformat_s
 {
 	const char *formatstring;
 	unsigned char *(*loadfunc)(const unsigned char *f, int filesize, int matchwidth, int matchheight);
 }
-imageformats[] =
+imageformat_t;
+
+// GAME_TENEBRAE only
+imageformat_t imageformats_tenebrae[] =
 {
 	{"override/%s.tga", LoadTGA},
+	{"override/%s.png", PNG_LoadImage},
+	{"override/%s.jpg", JPEG_LoadImage},
+	{"override/%s.pcx", LoadPCX},
+	{NULL, NULL}
+};
+
+imageformat_t imageformats_nopath[] =
+{
+	{"override/%s.tga", LoadTGA},
+	{"override/%s.png", PNG_LoadImage},
 	{"override/%s.jpg", JPEG_LoadImage},
 	{"textures/%s.tga", LoadTGA},
+	{"textures/%s.png", PNG_LoadImage},
 	{"textures/%s.jpg", JPEG_LoadImage},
-	{"textures/%s.pcx", LoadPCX},
-	{"textures/%s.wal", LoadWAL},
 	{"%s.tga", LoadTGA},
+	{"%s.png", PNG_LoadImage},
+	{"%s.jpg", JPEG_LoadImage},
+	{"%s.pcx", LoadPCX},
+	{NULL, NULL}
+};
+
+imageformat_t imageformats_textures[] =
+{
+	{"%s.tga", LoadTGA},
+	{"%s.png", PNG_LoadImage},
+	{"%s.jpg", JPEG_LoadImage},
+	{"%s.pcx", LoadPCX},
+	{"%s.wal", LoadWAL},
+	{NULL, NULL}
+};
+
+imageformat_t imageformats_gfx[] =
+{
+	{"%s.tga", LoadTGA},
+	{"%s.png", PNG_LoadImage},
+	{"%s.jpg", JPEG_LoadImage},
+	{"%s.pcx", LoadPCX},
+	{NULL, NULL}
+};
+
+imageformat_t imageformats_other[] =
+{
+	{"%s.tga", LoadTGA},
+	{"%s.png", PNG_LoadImage},
 	{"%s.jpg", JPEG_LoadImage},
 	{"%s.pcx", LoadPCX},
-	{"%s.lmp", LoadLMPRGBA},
 	{NULL, NULL}
 };
 
 unsigned char *loadimagepixels (const char *filename, qboolean complain, int matchwidth, int matchheight)
 {
-	int i;
 	fs_offset_t filesize;
+	imageformat_t *firstformat, *format;
 	unsigned char *f, *data = NULL;
 	char basename[MAX_QPATH], name[MAX_QPATH], *c;
 	if (developer_memorydebug.integer)
 		Mem_CheckSentinelsGlobal();
 	if (developer_texturelogging.integer)
 		Log_Printf("textures.log", "%s\n", filename);
-	strlcpy(basename, filename, sizeof(basename));
-	Image_StripImageExtension(basename, basename); // strip filename extensions to allow replacement by other types
+	Image_StripImageExtension(filename, basename, sizeof(basename)); // strip filename extensions to allow replacement by other types
 	// replace *'s with #, so commandline utils don't get confused when dealing with the external files
 	for (c = basename;*c;c++)
 		if (*c == '*')
 			*c = '#';
-	for (i = 0;imageformats[i].formatstring;i++)
+	name[0] = 0;
+	if (strchr(basename, '/'))
+	{
+		int i;
+		for (i = 0;i < (int)sizeof(name)-1 && basename[i] != '/';i++)
+			name[i] = basename[i];
+		name[i] = 0;
+	}
+	if (gamemode == GAME_TENEBRAE)
+		firstformat = imageformats_tenebrae;
+	else if (!strcasecmp(name, "textures"))
+		firstformat = imageformats_textures;
+	else if (!strcasecmp(name, "gfx"))
+		firstformat = imageformats_gfx;
+	else if (!strchr(name, '/'))
+		firstformat = imageformats_nopath;
+	else
+		firstformat = imageformats_other;
+	// now try all the formats in the selected list
+	for (format = firstformat;format->formatstring;format++)
 	{
-		sprintf (name, imageformats[i].formatstring, basename);
+		sprintf (name, format->formatstring, basename);
 		f = FS_LoadFile(name, tempmempool, true, &filesize);
 		if (f)
 		{
-			data = imageformats[i].loadfunc(f, filesize, matchwidth, matchheight);
+			data = format->loadfunc(f, filesize, matchwidth, matchheight);
 			Mem_Free(f);
 			if (data)
 			{
-				Con_DPrintf("loaded image %s (%dx%d)\n", name, image_width, image_height);
+				if (developer.integer >= 10)
+					Con_Printf("loaded image %s (%dx%d)\n", name, image_width, image_height);
 				if (developer_memorydebug.integer)
 					Mem_CheckSentinelsGlobal();
 				return data;
 			}
+			else
+			{
+				if (developer.integer >= 1)
+					Con_Printf("Error loading image %s (file loaded but decode failed)\n", name);
+			}
 		}
 	}
 	if (complain)
 	{
 		Con_Printf("Couldn't load %s using ", filename);
-		for (i = 0;imageformats[i].formatstring;i++)
+		for (format = firstformat;format->formatstring;format++)
 		{
-			sprintf (name, imageformats[i].formatstring, basename);
-			Con_Printf(i == 0 ? "\"%s\"" : (imageformats[i+1].formatstring ? ", \"%s\"" : " or \"%s\".\n"), imageformats[i].formatstring);
+			sprintf (name, format->formatstring, basename);
+			Con_Printf(format == firstformat ? "\"%s\"" : (format[1].formatstring ? ", \"%s\"" : " or \"%s\".\n"), format->formatstring);
 		}
 	}
 	if (developer_memorydebug.integer)
@@ -719,37 +921,6 @@ unsigned char *loadimagepixels (const char *filename, qboolean complain, int mat
 	return NULL;
 }
 
-int image_makemask (const unsigned char *in, unsigned char *out, int size)
-{
-	int i, count;
-	count = 0;
-	for (i = 0;i < size;i++)
-	{
-		out[0] = out[1] = out[2] = 255;
-		out[3] = in[3];
-		if (in[3] != 255)
-			count++;
-		in += 4;
-		out += 4;
-	}
-	return count;
-}
-
-unsigned char* loadimagepixelsmask (const char *filename, qboolean complain, int matchwidth, int matchheight)
-{
-	unsigned char *in, *data;
-	in = data = loadimagepixels(filename, complain, matchwidth, matchheight);
-	if (!data)
-		return NULL;
-	if (image_makemask(data, data, image_width * image_height))
-		return data; // some transparency
-	else
-	{
-		Mem_Free(data);
-		return NULL; // all opaque
-	}
-}
-
 rtexture_t *loadtextureimage (rtexturepool_t *pool, const char *filename, int matchwidth, int matchheight, qboolean complain, int flags)
 {
 	unsigned char *data;
@@ -761,78 +932,6 @@ rtexture_t *loadtextureimage (rtexturepool_t *pool, const char *filename, int ma
 	return rt;
 }
 
-rtexture_t *loadtextureimagemask (rtexturepool_t *pool, const char *filename, int matchwidth, int matchheight, qboolean complain, int flags)
-{
-	unsigned char *data;
-	rtexture_t *rt;
-	if (!(data = loadimagepixelsmask (filename, complain, matchwidth, matchheight)))
-		return 0;
-	rt = R_LoadTexture2D(pool, filename, image_width, image_height, data, TEXTYPE_RGBA, flags, NULL);
-	Mem_Free(data);
-	return rt;
-}
-
-rtexture_t *image_masktex;
-rtexture_t *image_nmaptex;
-rtexture_t *loadtextureimagewithmask (rtexturepool_t *pool, const char *filename, int matchwidth, int matchheight, qboolean complain, int flags)
-{
-	unsigned char *data;
-	rtexture_t *rt;
-	image_masktex = NULL;
-	image_nmaptex = NULL;
-	if (!(data = loadimagepixels (filename, complain, matchwidth, matchheight)))
-		return 0;
-
-	rt = R_LoadTexture2D(pool, filename, image_width, image_height, data, TEXTYPE_RGBA, flags, NULL);
-
-	if (flags & TEXF_ALPHA && image_makemask(data, data, image_width * image_height))
-		image_masktex = R_LoadTexture2D(pool, va("%s_mask", filename), image_width, image_height, data, TEXTYPE_RGBA, flags, NULL);
-
-	Mem_Free(data);
-	return rt;
-}
-
-rtexture_t *loadtextureimagewithmaskandnmap (rtexturepool_t *pool, const char *filename, int matchwidth, int matchheight, qboolean complain, int flags, float bumpscale)
-{
-	unsigned char *data, *data2;
-	rtexture_t *rt;
-	image_masktex = NULL;
-	image_nmaptex = NULL;
-	if (!(data = loadimagepixels (filename, complain, matchwidth, matchheight)))
-		return 0;
-
-	data2 = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
-
-	rt = R_LoadTexture2D(pool, filename, image_width, image_height, data, TEXTYPE_RGBA, flags, NULL);
-
-	Image_HeightmapToNormalmap(data, data2, image_width, image_height, (flags & TEXF_CLAMP) != 0, bumpscale);
-	image_nmaptex = R_LoadTexture2D(pool, va("%s_nmap", filename), image_width, image_height, data2, TEXTYPE_RGBA, flags, NULL);
-
-	if (flags & TEXF_ALPHA && image_makemask(data, data2, image_width * image_height))
-		image_masktex = R_LoadTexture2D(pool, va("%s_mask", filename), image_width, image_height, data2, TEXTYPE_RGBA, flags, NULL);
-
-	Mem_Free(data2);
-
-	Mem_Free(data);
-	return rt;
-}
-
-rtexture_t *loadtextureimagebumpasnmap (rtexturepool_t *pool, const char *filename, int matchwidth, int matchheight, qboolean complain, int flags, float bumpscale)
-{
-	unsigned char *data, *data2;
-	rtexture_t *rt;
-	if (!(data = loadimagepixels (filename, complain, matchwidth, matchheight)))
-		return 0;
-	data2 = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
-
-	Image_HeightmapToNormalmap(data, data2, image_width, image_height, (flags & TEXF_CLAMP) != 0, bumpscale);
-	rt = R_LoadTexture2D(pool, filename, image_width, image_height, data2, TEXTYPE_RGBA, flags, NULL);
-
-	Mem_Free(data2);
-	Mem_Free(data);
-	return rt;
-}
-
 qboolean Image_WriteTGARGB_preflipped (const char *filename, int width, int height, const unsigned char *data, unsigned char *buffer)
 {
 	qboolean ret;
@@ -862,40 +961,6 @@ qboolean Image_WriteTGARGB_preflipped (const char *filename, int width, int heig
 	return ret;
 }
 
-void Image_WriteTGARGB (const char *filename, int width, int height, const unsigned char *data)
-{
-	int y;
-	unsigned char *buffer, *out;
-	const unsigned char *in, *end;
-
-	buffer = (unsigned char *)Mem_Alloc(tempmempool, width*height*3 + 18);
-
-	memset (buffer, 0, 18);
-	buffer[2] = 2;		// uncompressed type
-	buffer[12] = (width >> 0) & 0xFF;
-	buffer[13] = (width >> 8) & 0xFF;
-	buffer[14] = (height >> 0) & 0xFF;
-	buffer[15] = (height >> 8) & 0xFF;
-	buffer[16] = 24;	// pixel size
-
-	// swap rgb to bgr and flip upside down
-	out = buffer + 18;
-	for (y = height - 1;y >= 0;y--)
-	{
-		in = data + y * width * 3;
-		end = in + width * 3;
-		for (;in < end;in += 3)
-		{
-			*out++ = in[2];
-			*out++ = in[1];
-			*out++ = in[0];
-		}
-	}
-	FS_WriteFile (filename, buffer, width*height*3 + 18 );
-
-	Mem_Free(buffer);
-}
-
 void Image_WriteTGARGBA (const char *filename, int width, int height, const unsigned char *data)
 {
 	int y;
@@ -911,7 +976,7 @@ void Image_WriteTGARGBA (const char *filename, int width, int height, const unsi
 	buffer[14] = (height >> 0) & 0xFF;
 	buffer[15] = (height >> 8) & 0xFF;
 	buffer[16] = 32;	// pixel size
-	buffer[17] = 8; // transparent flag? (seems to be needed by gimp)
+	buffer[17] = 8; // 8 bits of alpha
 
 	// swap rgba to bgra and flip upside down
 	out = buffer + 18;
@@ -932,26 +997,6 @@ void Image_WriteTGARGBA (const char *filename, int width, int height, const unsi
 	Mem_Free(buffer);
 }
 
-qboolean Image_CheckAlpha(const unsigned char *data, int size, qboolean rgba)
-{
-	const unsigned char *end;
-	if (rgba)
-	{
-		// check alpha bytes
-		for (end = data + size * 4, data += 3;data < end;data += 4)
-			if (*data < 255)
-				return 1;
-	}
-	else
-	{
-		// color 255 is transparent
-		for (end = data + size;data < end;data++)
-			if (*data == 255)
-				return 1;
-	}
-	return 0;
-}
-
 static void Image_Resample32LerpLine (const unsigned char *in, unsigned char *out, int inwidth, int outwidth)
 {
 	int		j, xi, oldx = 0, f, fstep, endx, lerp;
@@ -1318,12 +1363,22 @@ void Image_Resample (const void *indata, int inwidth, int inheight, int indepth,
 // in can be the same as out
 void Image_MipReduce(const unsigned char *in, unsigned char *out, int *width, int *height, int *depth, int destwidth, int destheight, int destdepth, int bytesperpixel)
 {
+	const unsigned char *inrow;
 	int x, y, nextrow;
 	if (*depth != 1 || destdepth != 1)
 	{
 		Con_Printf ("Image_Resample: 3D resampling not supported\n");
+		if (*width > destwidth)
+			*width >>= 1;
+		if (*height > destheight)
+			*height >>= 1;
+		if (*depth > destdepth)
+			*depth >>= 1;
 		return;
 	}
+	// note: if given odd width/height this discards the last row/column of
+	// pixels, rather than doing a proper box-filter scale down
+	inrow = in;
 	nextrow = *width * bytesperpixel;
 	if (*width > destwidth)
 	{
@@ -1334,9 +1389,9 @@ void Image_MipReduce(const unsigned char *in, unsigned char *out, int *width, in
 			*height >>= 1;
 			if (bytesperpixel == 4)
 			{
-				for (y = 0;y < *height;y++)
+				for (y = 0;y < *height;y++, inrow += nextrow * 2)
 				{
-					for (x = 0;x < *width;x++)
+					for (in = inrow, x = 0;x < *width;x++)
 					{
 						out[0] = (unsigned char) ((in[0] + in[4] + in[nextrow  ] + in[nextrow+4]) >> 2);
 						out[1] = (unsigned char) ((in[1] + in[5] + in[nextrow+1] + in[nextrow+5]) >> 2);
@@ -1345,14 +1400,13 @@ void Image_MipReduce(const unsigned char *in, unsigned char *out, int *width, in
 						out += 4;
 						in += 8;
 					}
-					in += nextrow; // skip a line
 				}
 			}
 			else if (bytesperpixel == 3)
 			{
-				for (y = 0;y < *height;y++)
+				for (y = 0;y < *height;y++, inrow += nextrow * 2)
 				{
-					for (x = 0;x < *width;x++)
+					for (in = inrow, x = 0;x < *width;x++)
 					{
 						out[0] = (unsigned char) ((in[0] + in[3] + in[nextrow  ] + in[nextrow+3]) >> 2);
 						out[1] = (unsigned char) ((in[1] + in[4] + in[nextrow+1] + in[nextrow+4]) >> 2);
@@ -1360,7 +1414,6 @@ void Image_MipReduce(const unsigned char *in, unsigned char *out, int *width, in
 						out += 3;
 						in += 6;
 					}
-					in += nextrow; // skip a line
 				}
 			}
 			else
@@ -1371,9 +1424,9 @@ void Image_MipReduce(const unsigned char *in, unsigned char *out, int *width, in
 			// reduce width
 			if (bytesperpixel == 4)
 			{
-				for (y = 0;y < *height;y++)
+				for (y = 0;y < *height;y++, inrow += nextrow)
 				{
-					for (x = 0;x < *width;x++)
+					for (in = inrow, x = 0;x < *width;x++)
 					{
 						out[0] = (unsigned char) ((in[0] + in[4]) >> 1);
 						out[1] = (unsigned char) ((in[1] + in[5]) >> 1);
@@ -1386,9 +1439,9 @@ void Image_MipReduce(const unsigned char *in, unsigned char *out, int *width, in
 			}
 			else if (bytesperpixel == 3)
 			{
-				for (y = 0;y < *height;y++)
+				for (y = 0;y < *height;y++, inrow += nextrow)
 				{
-					for (x = 0;x < *width;x++)
+					for (in = inrow, x = 0;x < *width;x++)
 					{
 						out[0] = (unsigned char) ((in[0] + in[3]) >> 1);
 						out[1] = (unsigned char) ((in[1] + in[4]) >> 1);
@@ -1410,9 +1463,9 @@ void Image_MipReduce(const unsigned char *in, unsigned char *out, int *width, in
 			*height >>= 1;
 			if (bytesperpixel == 4)
 			{
-				for (y = 0;y < *height;y++)
+				for (y = 0;y < *height;y++, inrow += nextrow * 2)
 				{
-					for (x = 0;x < *width;x++)
+					for (in = inrow, x = 0;x < *width;x++)
 					{
 						out[0] = (unsigned char) ((in[0] + in[nextrow  ]) >> 1);
 						out[1] = (unsigned char) ((in[1] + in[nextrow+1]) >> 1);
@@ -1421,14 +1474,13 @@ void Image_MipReduce(const unsigned char *in, unsigned char *out, int *width, in
 						out += 4;
 						in += 4;
 					}
-					in += nextrow; // skip a line
 				}
 			}
 			else if (bytesperpixel == 3)
 			{
-				for (y = 0;y < *height;y++)
+				for (y = 0;y < *height;y++, inrow += nextrow * 2)
 				{
-					for (x = 0;x < *width;x++)
+					for (in = inrow, x = 0;x < *width;x++)
 					{
 						out[0] = (unsigned char) ((in[0] + in[nextrow  ]) >> 1);
 						out[1] = (unsigned char) ((in[1] + in[nextrow+1]) >> 1);
@@ -1436,7 +1488,6 @@ void Image_MipReduce(const unsigned char *in, unsigned char *out, int *width, in
 						out += 3;
 						in += 3;
 					}
-					in += nextrow; // skip a line
 				}
 			}
 			else
@@ -1449,77 +1500,54 @@ void Image_MipReduce(const unsigned char *in, unsigned char *out, int *width, in
 
 void Image_HeightmapToNormalmap(const unsigned char *inpixels, unsigned char *outpixels, int width, int height, int clamp, float bumpscale)
 {
-	int x, y;
-	const unsigned char *p0, *p1, *p2;
+	int x, y, x1, x2, y1, y2;
+	const unsigned char *b, *row[3];
+	int p[5];
 	unsigned char *out;
 	float iwidth, iheight, ibumpscale, n[3];
 	iwidth = 1.0f / width;
 	iheight = 1.0f / height;
-	ibumpscale = (255.0f * 3.0f) / bumpscale;
+	ibumpscale = (255.0f * 6.0f) / bumpscale;
 	out = outpixels;
-	for (y = 0;y < height;y++)
+	for (y = 0, y1 = height-1;y < height;y1 = y, y++)
 	{
-		for (x = 0;x < width;x++)
+		y2 = y + 1;if (y2 >= height) y2 = 0;
+		row[0] = inpixels + (y1 * width) * 4;
+		row[1] = inpixels + (y  * width) * 4;
+		row[2] = inpixels + (y2 * width) * 4;
+		for (x = 0, x1 = width-1;x < width;x1 = x, x++)
 		{
-			p0 = inpixels + (y * width + x) * 4;
-			if (x == width - 1)
-			{
-				if (clamp)
-					p1 = inpixels + (y * width + x) * 4;
-				else
-					p1 = inpixels + (y * width) * 4;
-			}
-			else
-				p1 = inpixels + (y * width + x + 1) * 4;
-			if (y == height - 1)
-			{
-				if (clamp)
-					p2 = inpixels + (y * width + x) * 4;
-				else
-					p2 = inpixels + x * 4;
-			}
-			else
-				p2 = inpixels + ((y + 1) * width + x) * 4;
-			/*
-			dv[0][0] = iwidth;
-			dv[0][1] = 0;
-			dv[0][2] = ((p0[0] + p0[1] + p0[2]) * ibumpscale) - ((p1[0] + p1[1] + p1[2]) * ibumpscale);
-			dv[1][0] = 0;
-			dv[1][1] = iheight;
-			dv[1][2] = ((p2[0] + p2[1] + p2[2]) * ibumpscale) - ((p0[0] + p0[1] + p0[2]) * ibumpscale);
-			n[0] = dv[0][1]*dv[1][2]-dv[0][2]*dv[1][1];
-			n[1] = dv[0][2]*dv[1][0]-dv[0][0]*dv[1][2];
-			n[2] = dv[0][0]*dv[1][1]-dv[0][1]*dv[1][0];
-			*/
-			n[0] = ((p0[0] + p0[1] + p0[2]) - (p1[0] + p1[1] + p1[2]));
-			n[1] = ((p2[0] + p2[1] + p2[2]) - (p0[0] + p0[1] + p0[2]));
+			x2 = x + 1;if (x2 >= width) x2 = 0;
+			// left, right
+			b = row[1] + x1 * 4;p[0] = (b[0] + b[1] + b[2]);
+			b = row[1] + x2 * 4;p[1] = (b[0] + b[1] + b[2]);
+			// above, below
+			b = row[0] + x  * 4;p[2] = (b[0] + b[1] + b[2]);
+			b = row[2] + x  * 4;p[3] = (b[0] + b[1] + b[2]);
+			// center
+			b = row[1] + x  * 4;p[4] = (b[0] + b[1] + b[2]);
+			// calculate a normal from the slopes
+			n[0] = p[0] - p[1];
+			n[1] = p[3] - p[2];
 			n[2] = ibumpscale;
 			VectorNormalize(n);
-			/*
-			// this should work for the bottom right triangle if anyone wants
-			// code for that for some reason
-			n[0] = ((p3[0] + p3[1] + p3[2]) - (p1[0] + p1[1] + p1[2]));
-			n[1] = ((p2[0] + p2[1] + p2[2]) - (p3[0] + p3[1] + p3[2]));
-			n[2] = ibumpscale;
-			VectorNormalize(n);
-			*/
-			out[0] = 128.0f + n[0] * 127.0f;
-			out[1] = 128.0f + n[1] * 127.0f;
-			out[2] = 128.0f + n[2] * 127.0f;
-			out[3] = (p0[0] + p0[1] + p0[2]) / 3;
+			// turn it into a dot3 rgb vector texture
+			out[0] = (int)(128.0f + n[0] * 127.0f);
+			out[1] = (int)(128.0f + n[1] * 127.0f);
+			out[2] = (int)(128.0f + n[2] * 127.0f);
+			out[3] = (p[4]) / 3;
 			out += 4;
 		}
 	}
 }
 
-int image_loadskin(imageskin_t *s, char *shadername)
+int image_loadskin(imageskin_t *s, const char *shadername)
 {
 	int j;
 	unsigned char *bumppixels;
 	int bumppixels_width, bumppixels_height;
 	char name[MAX_QPATH];
-	strlcpy(name, shadername, sizeof(name));
-	Image_StripImageExtension(name, name);
+	Image_StripImageExtension(shadername, name, sizeof(name));
 	memset(s, 0, sizeof(*s));
 	s->basepixels = loadimagepixels(name, false, 0, 0);
 	if (s->basepixels == NULL)
@@ -1528,8 +1556,12 @@ int image_loadskin(imageskin_t *s, char *shadername)
 	s->basepixels_height = image_height;
 
 	bumppixels = NULL;bumppixels_width = 0;bumppixels_height = 0;
-	if (Image_CheckAlpha(s->basepixels, s->basepixels_width * s->basepixels_height, true))
+	for (j = 3;j < s->basepixels_width * s->basepixels_height * 4;j += 4)
+		if (s->basepixels[j] < 255)
+			break;
+	if (j < s->basepixels_width * s->basepixels_height * 4)
 	{
+		// has transparent pixels
 		s->maskpixels = (unsigned char *)Mem_Alloc(loadmodel->mempool, s->basepixels_width * s->basepixels_height * 4);
 		s->maskpixels_width = s->basepixels_width;
 		s->maskpixels_height = s->basepixels_height;