X-Git-Url: http://git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=image.c;h=ed498ed6562ce832080410a4fc25a9378aeb4727;hp=5cca3c3cc1475815315cca9c289049fdf7d6735e;hb=06f16b7a460c06040d2dafeb02f00d734211a753;hpb=8d376b57de94bafd3bae224088b469649c853028

diff --git a/image.c b/image.c
index 5cca3c3c..ed498ed6 100644
--- a/image.c
+++ b/image.c
@@ -4,13 +4,24 @@
 #include "jpeg.h"
 #include "image_png.h"
 #include "r_shadow.h"
+#include "wad.h"
 
 int		image_width;
 int		image_height;
 
+static unsigned char *Image_GetEmbeddedPicBGRA(const char *name);
+
+static void Image_CopyAlphaFromBlueBGRA(unsigned char *outpixels, const unsigned char *inpixels, int w, int h)
+{
+	int i, n;
+	n = w * h;
+	for(i = 0; i < n; ++i)
+		outpixels[4*i+3] = inpixels[4*i]; // blue channel
+}
+
 #if 1
-// written by LordHavoc in a readable way, optimized by Vic, further optimized by LordHavoc (the non-special index case), readable version preserved below this
-void Image_CopyMux(unsigned char *outpixels, const unsigned char *inpixels, int inputwidth, int inputheight, qboolean inputflipx, qboolean inputflipy, qboolean inputflipdiagonal, int numoutputcomponents, int numinputcomponents, int *outputinputcomponentindices)
+// written by LadyHavoc in a readable way, optimized by Vic, further optimized by LadyHavoc (the non-special index case), readable version preserved below this
+void Image_CopyMux(unsigned char *outpixels, const unsigned char *inpixels, int inputwidth, int inputheight, qbool inputflipx, qbool inputflipy, qbool inputflipdiagonal, int numoutputcomponents, int numinputcomponents, int *outputinputcomponentindices)
 {
 	int index, c, x, y;
 	const unsigned char *in, *line;
@@ -26,14 +37,14 @@ void Image_CopyMux(unsigned char *outpixels, const unsigned char *inpixels, int
 		if (inputflipdiagonal)
 		{
 			for (x = 0, line = inpixels + col_ofs; x < inputwidth; x++, line += col_inc)
-				for (y = 0, in = line + row_ofs; y < inputheight; y++, in += row_inc, outpixels += numinputcomponents)
+				for (y = 0, in = line + row_ofs; y < inputheight; y++, in += row_inc, outpixels += numoutputcomponents)
 					for (c = 0; c < numoutputcomponents; c++)
 						outpixels[c] = ((index = outputinputcomponentindices[c]) & 0x80000000) ? index : in[index];
 		}
 		else
 		{
 			for (y = 0, line = inpixels + row_ofs; y < inputheight; y++, line += row_inc)
-				for (x = 0, in = line + col_ofs; x < inputwidth; x++, in += col_inc, outpixels += numinputcomponents)
+				for (x = 0, in = line + col_ofs; x < inputwidth; x++, in += col_inc, outpixels += numoutputcomponents)
 					for (c = 0; c < numoutputcomponents; c++)
 						outpixels[c] = ((index = outputinputcomponentindices[c]) & 0x80000000) ? index : in[index];
 		}
@@ -44,14 +55,14 @@ void Image_CopyMux(unsigned char *outpixels, const unsigned char *inpixels, int
 		if (inputflipdiagonal)
 		{
 			for (x = 0, line = inpixels + col_ofs; x < inputwidth; x++, line += col_inc)
-				for (y = 0, in = line + row_ofs; y < inputheight; y++, in += row_inc, outpixels += numinputcomponents)
+				for (y = 0, in = line + row_ofs; y < inputheight; y++, in += row_inc, outpixels += numoutputcomponents)
 					for (c = 0; c < numoutputcomponents; c++)
 						outpixels[c] = in[outputinputcomponentindices[c]];
 		}
 		else
 		{
 			for (y = 0, line = inpixels + row_ofs; y < inputheight; y++, line += row_inc)
-				for (x = 0, in = line + col_ofs; x < inputwidth; x++, in += col_inc, outpixels += numinputcomponents)
+				for (x = 0, in = line + col_ofs; x < inputwidth; x++, in += col_inc, outpixels += numoutputcomponents)
 					for (c = 0; c < numoutputcomponents; c++)
 						outpixels[c] = in[outputinputcomponentindices[c]];
 		}
@@ -59,7 +70,7 @@ void Image_CopyMux(unsigned char *outpixels, const unsigned char *inpixels, int
 }
 #else
 // intentionally readable version
-void Image_CopyMux(unsigned char *outpixels, const unsigned char *inpixels, int inputwidth, int inputheight, qboolean inputflipx, qboolean inputflipy, qboolean inputflipdiagonal, int numoutputcomponents, int numinputcomponents, int *outputinputcomponentindices)
+void Image_CopyMux(unsigned char *outpixels, const unsigned char *inpixels, int inputwidth, int inputheight, qbool inputflipx, qbool inputflipy, qbool inputflipdiagonal, int numoutputcomponents, int numinputcomponents, int *outputinputcomponentindices)
 {
 	int index, c, x, y;
 	const unsigned char *in, *inrow, *incolumn;
@@ -181,7 +192,7 @@ typedef struct pcx_s
 LoadPCX
 ============
 */
-unsigned char* LoadPCX_BGRA (const unsigned char *f, int filesize)
+static unsigned char* LoadPCX_BGRA (const unsigned char *f, int filesize, int *miplevel)
 {
 	pcx_t pcx;
 	unsigned char *a, *b, *image_buffer, *pbuf;
@@ -199,7 +210,7 @@ unsigned char* LoadPCX_BGRA (const unsigned char *f, int filesize)
 	memcpy(&pcx, fin, sizeof(pcx));
 	fin += sizeof(pcx);
 
-	// LordHavoc: big-endian support ported from QF newtree
+	// LadyHavoc: big-endian support ported from QF newtree
 	pcx.xmax = LittleShort (pcx.xmax);
 	pcx.xmin = LittleShort (pcx.xmin);
 	pcx.ymax = LittleShort (pcx.ymax);
@@ -211,7 +222,7 @@ unsigned char* LoadPCX_BGRA (const unsigned char *f, int filesize)
 
 	image_width = pcx.xmax + 1 - pcx.xmin;
 	image_height = pcx.ymax + 1 - pcx.ymin;
-	if (pcx.manufacturer != 0x0a || pcx.version != 5 || pcx.encoding != 1 || pcx.bits_per_pixel != 8 || image_width > 4096 || image_height > 4096 || image_width <= 0 || image_height <= 0)
+	if (pcx.manufacturer != 0x0a || pcx.version != 5 || pcx.encoding != 1 || pcx.bits_per_pixel != 8 || image_width > 32768 || image_height > 32768 || image_width <= 0 || image_height <= 0)
 	{
 		Con_Print("Bad pcx file\n");
 		return NULL;
@@ -248,7 +259,6 @@ unsigned char* LoadPCX_BGRA (const unsigned char *f, int filesize)
 			else
 				a[x++] = dataByte;
 		}
-		fin += pcx.bytes_per_line - image_width; // the number of bytes per line is always forced to an even number
 		while(x < image_width)
 			a[x++] = 0;
 	}
@@ -268,6 +278,98 @@ unsigned char* LoadPCX_BGRA (const unsigned char *f, int filesize)
 	return image_buffer;
 }
 
+/*
+============
+LoadPCX
+============
+*/
+qbool LoadPCX_QWSkin(const unsigned char *f, int filesize, unsigned char *pixels, int outwidth, int outheight)
+{
+	pcx_t pcx;
+	unsigned char *a;
+	const unsigned char *fin, *enddata;
+	int x, y, x2, dataByte, pcxwidth, pcxheight;
+
+	if (filesize < (int)sizeof(pcx) + 768)
+		return false;
+
+	image_width = outwidth;
+	image_height = outheight;
+	fin = f;
+
+	memcpy(&pcx, fin, sizeof(pcx));
+	fin += sizeof(pcx);
+
+	// LadyHavoc: big-endian support ported from QF newtree
+	pcx.xmax = LittleShort (pcx.xmax);
+	pcx.xmin = LittleShort (pcx.xmin);
+	pcx.ymax = LittleShort (pcx.ymax);
+	pcx.ymin = LittleShort (pcx.ymin);
+	pcx.hres = LittleShort (pcx.hres);
+	pcx.vres = LittleShort (pcx.vres);
+	pcx.bytes_per_line = LittleShort (pcx.bytes_per_line);
+	pcx.palette_type = LittleShort (pcx.palette_type);
+
+	pcxwidth = pcx.xmax + 1 - pcx.xmin;
+	pcxheight = pcx.ymax + 1 - pcx.ymin;
+	if (pcx.manufacturer != 0x0a || pcx.version != 5 || pcx.encoding != 1 || pcx.bits_per_pixel != 8 || pcxwidth > 4096 || pcxheight > 4096 || pcxwidth <= 0 || pcxheight <= 0)
+		return false;
+
+	enddata = f + filesize - 768;
+
+	for (y = 0;y < outheight && fin < enddata;y++)
+	{
+		a = pixels + y * outwidth;
+		// pad the output with blank lines if needed
+		if (y >= pcxheight)
+		{
+			memset(a, 0, outwidth);
+			continue;
+		}
+		for (x = 0;x < pcxwidth;)
+		{
+			if (fin >= enddata)
+				return false;
+			dataByte = *fin++;
+			if(dataByte >= 0xC0)
+			{
+				x2 = x + (dataByte & 0x3F);
+				if (fin >= enddata)
+					return false;
+				if (x2 > pcxwidth)
+					return false;
+				dataByte = *fin++;
+				for (;x < x2;x++)
+					if (x < outwidth)
+						a[x] = dataByte;
+			}
+			else
+			{
+				if (x < outwidth) // truncate to destination width
+					a[x] = dataByte;
+				x++;
+			}
+		}
+		while(x < outwidth)
+			a[x++] = 0;
+	}
+
+	return true;
+}
+
+/*
+============
+LoadPCX
+============
+*/
+qbool LoadPCX_PaletteOnly(const unsigned char *f, int filesize, unsigned char *palette768b)
+{
+	if (filesize < 768)
+		return false;
+	memcpy(palette768b, f + filesize - 768, 768);
+	return true;
+}
+
 /*
 =========================================================
 
@@ -286,7 +388,7 @@ typedef struct _TargaHeader
 }
 TargaHeader;
 
-void PrintTargaHeader(TargaHeader *t)
+static void PrintTargaHeader(TargaHeader *t)
 {
 	Con_Printf("TargaHeader:\nuint8 id_length = %i;\nuint8 colormap_type = %i;\nuint8 image_type = %i;\nuint16 colormap_index = %i;\nuint16 colormap_length = %i;\nuint8 colormap_size = %i;\nuint16 x_origin = %i;\nuint16 y_origin = %i;\nuint16 width = %i;\nuint16 height = %i;\nuint8 pixel_size = %i;\nuint8 attributes = %i;\n", t->id_length, t->colormap_type, t->image_type, t->colormap_index, t->colormap_length, t->colormap_size, t->x_origin, t->y_origin, t->width, t->height, t->pixel_size, t->attributes);
 }
@@ -296,7 +398,7 @@ void PrintTargaHeader(TargaHeader *t)
 LoadTGA
 =============
 */
-unsigned char *LoadTGA_BGRA (const unsigned char *f, int filesize)
+unsigned char *LoadTGA_BGRA (const unsigned char *f, int filesize, int *miplevel)
 {
 	int x, y, pix_inc, row_inci, runlen, alphabits;
 	unsigned char *image_buffer;
@@ -330,13 +432,15 @@ unsigned char *LoadTGA_BGRA (const unsigned char *f, int filesize)
 	targa_header.pixel_size = f[16];
 	targa_header.attributes = f[17];
 
-	if (image_width > 4096 || image_height > 4096 || image_width <= 0 || image_height <= 0)
+	if (image_width > 32768 || image_height > 32768 || image_width <= 0 || image_height <= 0)
 	{
 		Con_Print("LoadTGA: invalid size\n");
 		PrintTargaHeader(&targa_header);
 		return NULL;
 	}
 
+	memset(palettei, 0, sizeof(palettei));
+
 	// advance to end of header
 	fin = f + 18;
 
@@ -451,8 +555,6 @@ unsigned char *LoadTGA_BGRA (const unsigned char *f, int filesize)
 		row_inci = 0;
 	}
 
-	x = 0;
-	y = 0;
 	pix_inc = 1;
 	if ((targa_header.image_type & ~8) == 2)
 		pix_inc = (targa_header.pixel_size + 7) / 8;
@@ -523,6 +625,13 @@ unsigned char *LoadTGA_BGRA (const unsigned char *f, int filesize)
 						*pixbufi++ = palettei[*fin++];
 				}
 			}
+
+			if (x != image_width)
+			{
+				// pixbufi is useless now
+				Con_Printf("LoadTGA: corrupt file\n");
+				break;
+			}
 		}
 		break;
 	case 10:
@@ -571,6 +680,13 @@ unsigned char *LoadTGA_BGRA (const unsigned char *f, int filesize)
 						}
 					}
 				}
+
+				if (x != image_width)
+				{
+					// pixbufi is useless now
+					Con_Printf("LoadTGA: corrupt file\n");
+					break;
+				}
 			}
 		}
 		else
@@ -617,6 +733,13 @@ unsigned char *LoadTGA_BGRA (const unsigned char *f, int filesize)
 						}
 					}
 				}
+
+				if (x != image_width)
+				{
+					// pixbufi is useless now
+					Con_Printf("LoadTGA: corrupt file\n");
+					break;
+				}
 			}
 		}
 		break;
@@ -639,7 +762,7 @@ typedef struct q2wal_s
 	int			value;
 } q2wal_t;
 
-unsigned char *LoadWAL_BGRA (const unsigned char *f, int filesize)
+static unsigned char *LoadWAL_BGRA (const unsigned char *f, int filesize, int *miplevel)
 {
 	unsigned char *image_buffer;
 	const q2wal_t *inwal = (const q2wal_t *)f;
@@ -652,13 +775,13 @@ unsigned char *LoadWAL_BGRA (const unsigned char *f, int filesize)
 
 	image_width = LittleLong(inwal->width);
 	image_height = LittleLong(inwal->height);
-	if (image_width > 4096 || image_height > 4096 || image_width <= 0 || image_height <= 0)
+	if (image_width > 32768 || image_height > 32768 || image_width <= 0 || image_height <= 0)
 	{
 		Con_Printf("LoadWAL: invalid size %ix%i\n", image_width, image_height);
 		return NULL;
 	}
 
-	if (filesize < (int) sizeof(q2wal_t) + (int) LittleLong(inwal->offsets[0]) + image_width * image_height)
+	if (filesize < (int) LittleLong(inwal->offsets[0]) + image_width * image_height)
 	{
 		Con_Print("LoadWAL: invalid WAL file\n");
 		return NULL;
@@ -670,10 +793,122 @@ unsigned char *LoadWAL_BGRA (const unsigned char *f, int filesize)
 		Con_Printf("LoadWAL: not enough memory for %i by %i image\n", image_width, image_height);
 		return NULL;
 	}
-	Image_Copy8bitBGRA(f + LittleLong(inwal->offsets[0]), image_buffer, image_width * image_height, palette_bgra_complete);
+	Image_Copy8bitBGRA(f + LittleLong(inwal->offsets[0]), image_buffer, image_width * image_height, q2palette_bgra_complete);
+	return image_buffer;
+}
+
+qbool LoadWAL_GetMetadata(const unsigned char *f, int filesize, int *retwidth, int *retheight, int *retflags, int *retvalue, int *retcontents, char *retanimname32c)
+{
+	const q2wal_t *inwal = (const q2wal_t *)f;
+
+	if (filesize < (int) sizeof(q2wal_t))
+	{
+		Con_Print("LoadWAL: invalid WAL file\n");
+		if (retwidth)
+			*retwidth = 16;
+		if (retheight)
+			*retheight = 16;
+		if (retflags)
+			*retflags = 0;
+		if (retvalue)
+			*retvalue = 0;
+		if (retcontents)
+			*retcontents = 0;
+		if (retanimname32c)
+			memset(retanimname32c, 0, 32);
+		return false;
+	}
+
+	if (retwidth)
+		*retwidth = LittleLong(inwal->width);
+	if (retheight)
+		*retheight = LittleLong(inwal->height);
+	if (retflags)
+		*retflags = LittleLong(inwal->flags);
+	if (retvalue)
+		*retvalue = LittleLong(inwal->value);
+	if (retcontents)
+		*retcontents = LittleLong(inwal->contents);
+	if (retanimname32c)
+	{
+		memcpy(retanimname32c, inwal->animname, 32);
+		retanimname32c[31] = 0;
+	}
+	return true;
+}
+
+// gfx/* wad lumps and gfx/*.lmp files are simply width and height and paletted pixels, with color 255 as transparent
+static unsigned char* LoadLMP_BGRA(const unsigned char *f, int filesize, int *miplevel)
+{
+	unsigned char *image_buffer;
+	int i;
+
+	if (filesize < 9)
+	{
+		Con_Print("Bad lmp file\n");
+		return NULL;
+	}
+
+	image_width = f[0] + f[1] * 0x100 + f[2] * 0x10000 + f[3] * 0x1000000;
+	image_height = f[4] + f[5] * 0x100 + f[6] * 0x10000 + f[7] * 0x1000000;
+
+	if (image_width > 32768 || image_height > 32768 || image_width <= 0 || image_height <= 0 || image_width * image_height > filesize - 8)
+	{
+		Con_Print("Bad lmp file\n");
+		return NULL;
+	}
+
+	image_buffer = (unsigned char *)Mem_Alloc(tempmempool, image_width*image_height * 4);
+	if (!image_buffer)
+	{
+		Con_Printf("LoadLMP: not enough memory for %i by %i image\n", image_width, image_height);
+		return NULL;
+	}
+
+	for (i = 0; i < image_width * image_height; i++)
+	{
+		const unsigned char *p = (const unsigned char *)palette_bgra_transparent + 4 * f[8 + i];
+		image_buffer[i * 4 + 0] = p[0];
+		image_buffer[i * 4 + 1] = p[1];
+		image_buffer[i * 4 + 2] = p[2];
+		image_buffer[i * 4 + 3] = p[3];
+	}
+
 	return image_buffer;
 }
 
+// gfx/conchars is a raw 128x128 image with 0 as transparent color rather than 255
+static unsigned char *LoadConChars_BGRA(const unsigned char *f, int filesize, int *miplevel)
+{
+	unsigned char *image_buffer;
+	int i;
+
+	image_width = 128;
+	image_height = 128;
+	if (image_width * image_height > filesize)
+	{
+		Con_Print("Bad lmp file\n");
+		return NULL;
+	}
+
+	image_buffer = (unsigned char *)Mem_Alloc(tempmempool, image_width*image_height * 4);
+	if (!image_buffer)
+	{
+		Con_Printf("LoadConChars: not enough memory for %i by %i image\n", image_width, image_height);
+		return NULL;
+	}
+
+	for (i = 0; i < image_width * image_height; i++)
+	{
+		const unsigned char *p = (const unsigned char *)palette_bgra_font + 4 * f[i];
+		image_buffer[i * 4 + 0] = p[0];
+		image_buffer[i * 4 + 1] = p[1];
+		image_buffer[i * 4 + 2] = p[2];
+		image_buffer[i * 4 + 3] = p[3];
+	}
+
+	return image_buffer;
+}
 
 void Image_StripImageExtension (const char *in, char *out, size_t size_out)
 {
@@ -683,16 +918,51 @@ void Image_StripImageExtension (const char *in, char *out, size_t size_out)
 		return;
 
 	ext = FS_FileExtension(in);
-	if (ext && (!strcmp(ext, "tga") || !strcmp(ext, "pcx") || !strcmp(ext, "lmp") || !strcmp(ext, "png") || !strcmp(ext, "jpg")))
+	if (ext && (!strcmp(ext, "tga") || !strcmp(ext, "pcx") || !strcmp(ext, "lmp") || !strcmp(ext, "png") || !strcmp(ext, "jpg") || !strcmp(ext, "wal")))
 		FS_StripExtension(in, out, size_out);
 	else
 		strlcpy(out, in, size_out);
 }
 
+static unsigned char image_linearfromsrgb[256];
+static unsigned char image_srgbfromlinear_lightmap[256];
+
+void Image_MakeLinearColorsFromsRGB(unsigned char *pout, const unsigned char *pin, int numpixels)
+{
+	int i;
+	// this math from http://www.opengl.org/registry/specs/EXT/texture_sRGB.txt
+	if (!image_linearfromsrgb[255])
+		for (i = 0;i < 256;i++)
+			image_linearfromsrgb[i] = (unsigned char)floor(Image_LinearFloatFromsRGB(i) * 255.0f + 0.5f);
+	for (i = 0;i < numpixels;i++)
+	{
+		pout[i*4+0] = image_linearfromsrgb[pin[i*4+0]];
+		pout[i*4+1] = image_linearfromsrgb[pin[i*4+1]];
+		pout[i*4+2] = image_linearfromsrgb[pin[i*4+2]];
+		pout[i*4+3] = pin[i*4+3];
+	}
+}
+
+void Image_MakesRGBColorsFromLinear_Lightmap(unsigned char *pout, const unsigned char *pin, int numpixels)
+{
+	int i;
+	// this math from http://www.opengl.org/registry/specs/EXT/texture_sRGB.txt
+	if (!image_srgbfromlinear_lightmap[255])
+		for (i = 0;i < 256;i++)
+			image_srgbfromlinear_lightmap[i] = (unsigned char)floor(bound(0.0f, Image_sRGBFloatFromLinear_Lightmap(i), 1.0f) * 255.0f + 0.5f);
+	for (i = 0;i < numpixels;i++)
+	{
+		pout[i*4+0] = image_srgbfromlinear_lightmap[pin[i*4+0]];
+		pout[i*4+1] = image_srgbfromlinear_lightmap[pin[i*4+1]];
+		pout[i*4+2] = image_srgbfromlinear_lightmap[pin[i*4+2]];
+		pout[i*4+3] = pin[i*4+3];
+	}
+}
+
 typedef struct imageformat_s
 {
 	const char *formatstring;
-	unsigned char *(*loadfunc)(const unsigned char *f, int filesize);
+	unsigned char *(*loadfunc)(const unsigned char *f, int filesize, int *miplevel);
 }
 imageformat_t;
 
@@ -755,6 +1025,7 @@ imageformat_t imageformats_gfx[] =
 	{"%s.png", PNG_LoadImage_BGRA},
 	{"%s.jpg", JPEG_LoadImage_BGRA},
 	{"%s.pcx", LoadPCX_BGRA},
+	{"%s.lmp", LoadLMP_BGRA},
 	{NULL, NULL}
 };
 
@@ -764,18 +1035,21 @@ imageformat_t imageformats_other[] =
 	{"%s.png", PNG_LoadImage_BGRA},
 	{"%s.jpg", JPEG_LoadImage_BGRA},
 	{"%s.pcx", LoadPCX_BGRA},
+	{"%s.lmp", LoadLMP_BGRA},
 	{NULL, NULL}
 };
 
 int fixtransparentpixels(unsigned char *data, int w, int h);
-unsigned char *loadimagepixelsbgra (const char *filename, qboolean complain, qboolean allowFixtrans)
+unsigned char *loadimagepixelsbgra (const char *filename, qbool complain, qbool allowFixtrans, qbool convertsRGB, int *miplevel)
 {
 	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();
+	int mymiplevel;
+	unsigned char *f, *data = NULL, *data2 = NULL;
+	char basename[MAX_QPATH], name[MAX_QPATH], name2[MAX_QPATH], path[MAX_QPATH], afterpath[MAX_QPATH], *c;
+	char vabuf[1024];
+	//if (developer_memorydebug.integer)
+	//	Mem_CheckSentinelsGlobal();
 	if (developer_texturelogging.integer)
 		Log_Printf("textures.log", "%s\n", filename);
 	Image_StripImageExtension(filename, basename, sizeof(basename)); // strip filename extensions to allow replacement by other types
@@ -783,41 +1057,72 @@ unsigned char *loadimagepixelsbgra (const char *filename, qboolean complain, qbo
 	for (c = basename;*c;c++)
 		if (*c == '*')
 			*c = '#';
+	path[0] = 0;
 	name[0] = 0;
+	strlcpy(afterpath, basename, sizeof(afterpath));
 	if (strchr(basename, '/'))
 	{
 		int i;
-		for (i = 0;i < (int)sizeof(name)-1 && basename[i] != '/';i++)
-			name[i] = basename[i];
-		name[i] = 0;
+		for (i = 0;i < (int)sizeof(path)-1 && basename[i] != '/' && basename[i];i++)
+			path[i] = basename[i];
+		path[i] = 0;
+		strlcpy(afterpath, basename + i + 1, sizeof(afterpath));
 	}
 	if (gamemode == GAME_TENEBRAE)
 		firstformat = imageformats_tenebrae;
 	else if (gamemode == GAME_DELUXEQUAKE)
 		firstformat = imageformats_dq;
-	else if (!strcasecmp(name, "textures"))
+	else if (!strcasecmp(path, "textures"))
 		firstformat = imageformats_textures;
-	else if (!strcasecmp(name, "gfx"))
+	else if (!strcasecmp(path, "gfx") || !strcasecmp(path, "locale")) // locale/ is used in GAME_BLOODOMNICIDE
 		firstformat = imageformats_gfx;
-	else if (!strchr(basename, '/'))
+	else if (!path[0])
 		firstformat = imageformats_nopath;
 	else
 		firstformat = imageformats_other;
 	// now try all the formats in the selected list
 	for (format = firstformat;format->formatstring;format++)
 	{
-		sprintf (name, format->formatstring, basename);
-		f = FS_LoadFile(name, tempmempool, true, &filesize);
-		if (f)
+		dpsnprintf (name, sizeof(name), format->formatstring, basename);
+
+		FS_SanitizePath(name);
+
+		if(FS_FileExists(name) && (f = FS_LoadFile(name, tempmempool, true, &filesize)) != NULL)
 		{
-			data = format->loadfunc(f, filesize);
+			mymiplevel = miplevel ? *miplevel : 0;
+			image_width = 0;
+			image_height = 0;
+			data = format->loadfunc(f, (int)filesize, &mymiplevel);
 			Mem_Free(f);
 			if (data)
 			{
-				if (developer.integer >= 10)
-					Con_Printf("loaded image %s (%dx%d)\n", name, image_width, image_height);
-				if (developer_memorydebug.integer)
-					Mem_CheckSentinelsGlobal();
+				if(format->loadfunc == JPEG_LoadImage_BGRA) // jpeg can't do alpha, so let's simulate it by loading another jpeg
+				{
+					dpsnprintf (name2, sizeof(name2), format->formatstring, va(vabuf, sizeof(vabuf), "%s_alpha", basename));
+					f = FS_LoadFile(name2, tempmempool, true, &filesize);
+					if(f)
+					{
+						int mymiplevel2 = miplevel ? *miplevel : 0;
+						int image_width_save = image_width;
+						int image_height_save = image_height;
+						data2 = format->loadfunc(f, (int)filesize, &mymiplevel2);
+						if(data2 && mymiplevel == mymiplevel2 && image_width == image_width_save && image_height == image_height_save)
+							Image_CopyAlphaFromBlueBGRA(data, data2, image_width, image_height);
+						else
+							Con_Printf("loadimagepixelsrgba: corrupt or invalid alpha image %s_alpha\n", basename);
+						image_width = image_width_save;
+						image_height = image_height_save;
+						if(data2)
+							Mem_Free(data2);
+						Mem_Free(f);
+					}
+				}
+				if (developer_loading.integer)
+					Con_DPrintf("loaded image %s (%dx%d)\n", name, image_width, image_height);
+				if(miplevel)
+					*miplevel = mymiplevel;
+				//if (developer_memorydebug.integer)
+				//	Mem_CheckSentinelsGlobal();
 				if(allowFixtrans && r_fixtrans_auto.integer)
 				{
 					int n = fixtransparentpixels(data, image_width, image_height);
@@ -834,33 +1139,117 @@ unsigned char *loadimagepixelsbgra (const char *filename, qboolean complain, qbo
 						}
 					}
 				}
+				if (convertsRGB)
+					Image_MakeLinearColorsFromsRGB(data, data, image_width * image_height);
 				return data;
 			}
 			else
 				Con_DPrintf("Error loading image %s (file loaded but decode failed)\n", name);
 		}
 	}
+	if (!strcasecmp(path, "gfx"))
+	{
+		unsigned char *lmpdata;
+		if ((lmpdata = W_GetLumpName(afterpath, &filesize)))
+		{
+			if (developer_loading.integer)
+				Con_Printf("loading gfx.wad lump \"%s\"\n", afterpath);
+
+			mymiplevel = miplevel ? *miplevel : 0;
+			if (!strcmp(afterpath, "conchars"))
+			{
+				// conchars is a raw image and with color 0 as transparent instead of 255
+				data = LoadConChars_BGRA(lmpdata, filesize, &mymiplevel);
+			}
+			else
+				data = LoadLMP_BGRA(lmpdata, filesize, &mymiplevel);
+			// no cleanup after looking up a wad lump - the whole gfx.wad is loaded at once
+			if (data)
+				return data;
+			Con_DPrintf("Error loading image %s (file loaded but decode failed)\n", name);
+		}
+	}
+
+	// check if the image name exists as an embedded pic
+	if ((data = Image_GetEmbeddedPicBGRA(basename)))
+		return data;
+
 	if (complain)
 	{
 		Con_Printf("Couldn't load %s using ", filename);
 		for (format = firstformat;format->formatstring;format++)
 		{
-			sprintf (name, format->formatstring, basename);
+			dpsnprintf (name, sizeof(name), format->formatstring, basename);
 			Con_Printf(format == firstformat ? "\"%s\"" : (format[1].formatstring ? ", \"%s\"" : " or \"%s\".\n"), format->formatstring);
 		}
 	}
-	if (developer_memorydebug.integer)
-		Mem_CheckSentinelsGlobal();
+
+	// texture loading can take a while, so make sure we're sending keepalives
+	CL_KeepaliveMessage(false);
+
+	//if (developer_memorydebug.integer)
+	//	Mem_CheckSentinelsGlobal();
+
 	return NULL;
 }
 
-rtexture_t *loadtextureimage (rtexturepool_t *pool, const char *filename, qboolean complain, int flags, qboolean allowFixtrans)
+qbool Image_GetStockPicSize(const char *filename, int *returnwidth, int *returnheight)
+{
+	unsigned char *data;
+	fs_offset_t filesize;
+	char lmppath[MAX_QPATH];
+	if (!strcasecmp(filename, "gfx/conchars"))
+	{
+		*returnwidth = 128;
+		*returnheight = 128;
+		return true;
+	}
+
+	dpsnprintf(lmppath, sizeof(lmppath), "%s.lmp", filename);
+	data = FS_LoadFile(lmppath, tempmempool, true, &filesize);
+	if (data)
+	{
+		if (filesize > 8)
+		{
+			int w = data[0] + data[1] * 0x100 + data[2] * 0x10000 + data[3] * 0x1000000;
+			int h = data[4] + data[5] * 0x100 + data[6] * 0x10000 + data[7] * 0x1000000;
+			if (w >= 1 && w <= 32768 && h >= 1 && h <= 32768)
+			{
+				*returnwidth = w;
+				*returnheight = h;
+				Mem_Free(data);
+				return true;
+			}
+		}
+		Mem_Free(data);
+	}
+	if (!strncasecmp(filename, "gfx/", 4))
+	{
+		data = W_GetLumpName(filename + 4, &filesize);
+		if (data && filesize > 8)
+		{
+			int w = data[0] + data[1] * 0x100 + data[2] * 0x10000 + data[3] * 0x1000000;
+			int h = data[4] + data[5] * 0x100 + data[6] * 0x10000 + data[7] * 0x1000000;
+			if (w >= 1 && w <= 32768 && h >= 1 && h <= 32768)
+			{
+				*returnwidth = w;
+				*returnheight = h;
+				return true;
+			}
+		}
+	}
+	return false;
+}
+
+extern cvar_t gl_picmip;
+rtexture_t *loadtextureimage (rtexturepool_t *pool, const char *filename, qbool complain, int flags, qbool allowFixtrans, qbool sRGB)
 {
 	unsigned char *data;
 	rtexture_t *rt;
-	if (!(data = loadimagepixelsbgra (filename, complain, allowFixtrans)))
+	int miplevel = R_PicmipForFlags(flags);
+	if (!(data = loadimagepixelsbgra (filename, complain, allowFixtrans, false, &miplevel)))
 		return 0;
-	rt = R_LoadTexture2D(pool, filename, image_width, image_height, data, TEXTYPE_BGRA, flags, NULL);
+	rt = R_LoadTexture2D(pool, filename, image_width, image_height, data, sRGB ? TEXTYPE_SRGB_BGRA : TEXTYPE_BGRA, flags, miplevel, NULL);
 	Mem_Free(data);
 	return rt;
 }
@@ -873,7 +1262,7 @@ int fixtransparentpixels(unsigned char *data, int w, int h)
 	int const FIXTRANS_HAS_U = 8;
 	int const FIXTRANS_HAS_D = 16;
 	int const FIXTRANS_FIXED = 32;
-	unsigned char *fixMask = Mem_Alloc(tempmempool, w * h);
+	unsigned char *fixMask = (unsigned char *) Mem_Alloc(tempmempool, w * h);
 	int fixPixels = 0;
 	int changedPixels = 0;
 	int x, y;
@@ -984,20 +1373,20 @@ int fixtransparentpixels(unsigned char *data, int w, int h)
 	return changedPixels;
 }
 
-void Image_FixTransparentPixels_f(void)
+void Image_FixTransparentPixels_f(cmd_state_t *cmd)
 {
 	const char *filename, *filename_pattern;
 	fssearch_t *search;
 	int i, n;
 	char outfilename[MAX_QPATH], buf[MAX_QPATH];
 	unsigned char *data;
-	if(Cmd_Argc() != 2)
+	if(Cmd_Argc(cmd) != 2)
 	{
-		Con_Printf("Usage: %s imagefile\n", Cmd_Argv(0));
+		Con_Printf("Usage: %s imagefile\n", Cmd_Argv(cmd, 0));
 		return;
 	}
-	filename_pattern = Cmd_Argv(1);
-	search = FS_Search(filename_pattern, true, true);
+	filename_pattern = Cmd_Argv(cmd, 1);
+	search = FS_Search(filename_pattern, true, true, NULL);
 	if(!search)
 		return;
 	for(i = 0; i < search->numfilenames; ++i)
@@ -1006,7 +1395,7 @@ void Image_FixTransparentPixels_f(void)
 		Con_Printf("Processing %s... ", filename);
 		Image_StripImageExtension(filename, buf, sizeof(buf));
 		dpsnprintf(outfilename, sizeof(outfilename), "fixtrans/%s.tga", buf);
-		if(!(data = loadimagepixelsbgra(filename, true, false)))
+		if(!(data = loadimagepixelsbgra(filename, true, false, false, NULL)))
 			return;
 		if((n = fixtransparentpixels(data, image_width, image_height)))
 		{
@@ -1017,11 +1406,15 @@ void Image_FixTransparentPixels_f(void)
 			Con_Printf("unchanged.\n");
 		Mem_Free(data);
 	}
+	FS_FreeSearch(search);
 }
 
-qboolean Image_WriteTGABGR_preflipped (const char *filename, int width, int height, const unsigned char *data, unsigned char *buffer)
+qbool Image_WriteTGABGR_preflipped (const char *filename, int width, int height, const unsigned char *data)
 {
-	qboolean ret;
+	qbool ret;
+	unsigned char buffer[18];
+	const void *buffers[2];
+	fs_offset_t sizes[2];
 
 	memset (buffer, 0, 18);
 	buffer[2] = 2;		// uncompressed type
@@ -1031,18 +1424,21 @@ qboolean Image_WriteTGABGR_preflipped (const char *filename, int width, int heig
 	buffer[15] = (height >> 8) & 0xFF;
 	buffer[16] = 24;	// pixel size
 
-	// swap rgb to bgr
-	memcpy(buffer + 18, data, width*height*3);
-	ret = FS_WriteFile (filename, buffer, width*height*3 + 18 );
+	buffers[0] = buffer;
+	sizes[0] = 18;
+	buffers[1] = data;
+	sizes[1] = width*height*3;
+	ret = FS_WriteFileInBlocks(filename, buffers, sizes, 2);
 
 	return ret;
 }
 
-void Image_WriteTGABGRA (const char *filename, int width, int height, const unsigned char *data)
+qbool Image_WriteTGABGRA (const char *filename, int width, int height, const unsigned char *data)
 {
 	int y;
 	unsigned char *buffer, *out;
 	const unsigned char *in, *end;
+	qbool ret;
 
 	buffer = (unsigned char *)Mem_Alloc(tempmempool, width*height*4 + 18);
 
@@ -1091,9 +1487,11 @@ void Image_WriteTGABGRA (const char *filename, int width, int height, const unsi
 			}
 		}
 	}
-	FS_WriteFile (filename, buffer, out - buffer);
+	ret = FS_WriteFile (filename, buffer, out - buffer);
 
 	Mem_Free(buffer);
+
+	return ret;
 }
 
 static void Image_Resample32LerpLine (const unsigned char *in, unsigned char *out, int inwidth, int outwidth)
@@ -1128,7 +1526,7 @@ static void Image_Resample32LerpLine (const unsigned char *in, unsigned char *ou
 }
 
 #define LERPBYTE(i) r = resamplerow1[i];out[i] = (unsigned char) ((((resamplerow2[i] - r) * lerp) >> 16) + r)
-void Image_Resample32Lerp(const void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight)
+static void Image_Resample32Lerp(const void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight)
 {
 	int i, j, r, yi, oldy, f, fstep, lerp, endy = (inheight-1), inwidth4 = inwidth*4, outwidth4 = outwidth*4;
 	unsigned char *out;
@@ -1232,7 +1630,7 @@ void Image_Resample32Lerp(const void *indata, int inwidth, int inheight, void *o
 	resamplerow2 = NULL;
 }
 
-void Image_Resample32Nolerp(const void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight)
+static void Image_Resample32Nolerp(const void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight)
 {
 	int i, j;
 	unsigned frac, fracstep;
@@ -1374,9 +1772,7 @@ void Image_HeightmapToNormalmap_BGRA(const unsigned char *inpixels, unsigned cha
 	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;
+	float ibumpscale, n[3];
 	ibumpscale = (255.0f * 6.0f) / bumpscale;
 	out = outpixels;
 	for (y = 0, y1 = height-1;y < height;y1 = y, y++)
@@ -1410,3 +1806,300 @@ void Image_HeightmapToNormalmap_BGRA(const unsigned char *inpixels, unsigned cha
 		}
 	}
 }
+
+
+#include "lhfont.h"
+
+static unsigned char *Image_GenerateConChars(void)
+{
+	int i;
+	unsigned char *data;
+	double random;
+
+	image_width = 256;
+	image_height = 256;
+
+	data = LoadTGA_BGRA(concharimage, sizeof(concharimage), NULL);
+	// Gold numbers
+	for (i = 0; i < 8192; i++)
+	{
+		random = lhrandom(0.0, 1.0);
+		data[i * 4 + 3] = data[i * 4 + 0];
+		data[i * 4 + 2] = 83 + (unsigned char)(random * 64);
+		data[i * 4 + 1] = 71 + (unsigned char)(random * 32);
+		data[i * 4 + 0] = 23 + (unsigned char)(random * 16);
+	}
+	// White chars
+	for (i = 8192; i < 32768; i++)
+	{
+		random = lhrandom(0.0, 1.0);
+		data[i * 4 + 3] = data[i * 4 + 0];
+		data[i * 4 + 2] = 95 + (unsigned char)(random * 64);
+		data[i * 4 + 1] = 95 + (unsigned char)(random * 64);
+		data[i * 4 + 0] = 95 + (unsigned char)(random * 64);
+	}
+	// Gold numbers
+	for (i = 32768; i < 40960; i++)
+	{
+		random = lhrandom(0.0, 1.0);
+		data[i * 4 + 3] = data[i * 4 + 0];
+		data[i * 4 + 2] = 83 + (unsigned char)(random * 64);
+		data[i * 4 + 1] = 71 + (unsigned char)(random * 32);
+		data[i * 4 + 0] = 23 + (unsigned char)(random * 16);
+	}
+	// Red chars
+	for (i = 40960; i < 65536; i++)
+	{
+		random = lhrandom(0.0, 1.0);
+		data[i * 4 + 3] = data[i * 4 + 0];
+		data[i * 4 + 2] = 96 + (unsigned char)(random * 64);
+		data[i * 4 + 1] = 43 + (unsigned char)(random * 32);
+		data[i * 4 + 0] = 27 + (unsigned char)(random * 32);
+	}
+
+#if 0
+	Image_WriteTGABGRA("gfx/generated_conchars.tga", 256, 256, data);
+#endif
+
+	return data;
+}
+
+static unsigned char *Image_GenerateDitherPattern(void)
+{
+	int x, y;
+	unsigned char *data = (unsigned char *)Mem_Alloc(tempmempool, 8 * 8 * 4);
+	image_width = 8;
+	image_height = 8;
+	for (y = 0; y < 8; y++)
+	{
+		for (x = 0; x < 8; x++)
+		{
+			data[(y * 8 + x) * 4 + 0] = ((x^y) & 4) ? 255 : 0;
+			data[(y * 8 + x) * 4 + 1] = ((x^y) & 4) ? 255 : 0;
+			data[(y * 8 + x) * 4 + 2] = ((x^y) & 4) ? 255 : 0;
+			data[(y * 8 + x) * 4 + 3] = 255;
+		}
+	}
+	return data;
+}
+
+// also used in R_SkinFrame code
+unsigned char *Image_GenerateNoTexture(void)
+{
+	int x, y;
+	unsigned char *data = (unsigned char *)Mem_Alloc(tempmempool, 16 * 16 * 4);
+	image_width = 16;
+	image_height = 16;
+	// this makes a light grey/dark grey checkerboard texture
+	for (y = 0; y < 16; y++)
+	{
+		for (x = 0; x < 16; x++)
+		{
+			data[(y * 16 + x) * 4 + 0] =
+			data[(y * 16 + x) * 4 + 1] =
+			data[(y * 16 + x) * 4 + 2] = (y < 8) ^ (x < 8) ? 128 : 64;
+			data[(y * 16 + x) * 4 + 3] = 255;
+		}
+	}
+	return data;
+}
+
+static unsigned char *Image_GenerateWhite(void)
+{
+	unsigned char *data = (unsigned char *)Mem_Alloc(tempmempool, 1 * 1 * 4);
+	image_width = 1;
+	image_height = 1;
+	data[0] = data[1] = data[2] = data[3] = 255;
+	return data;
+}
+
+typedef struct embeddedpic_s
+{
+const char *name;
+int width;
+int height;
+const char *pixels;
+}
+embeddedpic_t;
+
+static const embeddedpic_t embeddedpics[] =
+{
+	{
+		"gfx/prydoncursor001", 16, 16,
+		"477777774......."
+		"77.....6........"
+		"7.....6........."
+		"7....6.........."
+		"7.....6........."
+		"7..6...6........"
+		"7.6.6...6......."
+		"76...6...6......"
+		"4.....6.6......."
+		".......6........"
+		"................"
+		"................"
+		"................"
+		"................"
+		"................"
+		"................"
+	},
+	{
+		"ui/mousepointer", 16, 16,
+		"477777774......."
+		"77.....6........"
+		"7.....6........."
+		"7....6.........."
+		"7.....6........."
+		"7..6...6........"
+		"7.6.6...6......."
+		"76...6...6......"
+		"4.....6.6......."
+		".......6........"
+		"................"
+		"................"
+		"................"
+		"................"
+		"................"
+		"................"
+	},
+	{
+		"gfx/crosshair1", 16, 16,
+		"................"
+		"................"
+		"................"
+		"...33......33..."
+		"...355....553..."
+		"....577..775...."
+		".....77..77....."
+		"................"
+		"................"
+		".....77..77....."
+		"....577..775...."
+		"...355....553..."
+		"...33......33..."
+		"................"
+		"................"
+		"................"
+	},
+	{
+		"gfx/crosshair2", 16, 16,
+		"................"
+		"................"
+		"................"
+		"...3........3..."
+		"....5......5...."
+		".....7....7....."
+		"......7..7......"
+		"................"
+		"................"
+		"......7..7......"
+		".....7....7....."
+		"....5......5...."
+		"...3........3..."
+		"................"
+		"................"
+		"................"
+	},
+	{
+		"gfx/crosshair3", 16, 16,
+		"................"
+		".......77......."
+		".......77......."
+		"................"
+		"................"
+		".......44......."
+		".......44......."
+		".77..44..44..77."
+		".77..44..44..77."
+		".......44......."
+		".......44......."
+		"................"
+		"................"
+		".......77......."
+		".......77......."
+		"................"
+	},
+	{
+		"gfx/crosshair4", 16, 16,
+		"................"
+		"................"
+		"................"
+		"................"
+		"................"
+		"................"
+		"................"
+		"................"
+		"........7777777."
+		"........752....."
+		"........72......"
+		"........7......."
+		"........7......."
+		"........7......."
+		"........7......."
+		"................"
+	},
+	{
+		"gfx/crosshair5", 8, 8,
+		"........"
+		"........"
+		"....7..."
+		"........"
+		"..7.7.7."
+		"........"
+		"....7..."
+		"........"
+	},
+	{
+		"gfx/crosshair6", 2, 2,
+		"77"
+		"77"
+	},
+	{
+		"gfx/crosshair7", 16, 16,
+		"................"
+		".3............3."
+		"..5...2332...5.."
+		"...7.3....3.7..."
+		"....7......7...."
+		"...3.7....7.3..."
+		"..2...7..7...2.."
+		"..3..........3.."
+		"..3..........3.."
+		"..2...7..7...2.."
+		"...3.7....7.3..."
+		"....7......7...."
+		"...7.3....3.7..."
+		"..5...2332...5.."
+		".3............3."
+		"................"
+	},
+	{ NULL, 0, 0, NULL }
+};
+
+unsigned char *Image_GetEmbeddedPicBGRA(const char *name)
+{
+	const embeddedpic_t *p;
+	for (p = embeddedpics; p->name; p++)
+	{
+		if (!strcmp(name, p->name))
+		{
+			int i;
+			unsigned char *data = (unsigned char *)Mem_Alloc(tempmempool, p->width * p->height * 4);
+			image_width = p->width;
+			image_height = p->height;
+			for (i = 0; i < p->width * p->height; i++)
+			{
+				const unsigned char *c = (const unsigned char *)palette_bgra_embeddedpic + 4 * p->pixels[i];
+				Vector4Copy(c, data + 4 * i);
+			}
+			return data;
+		}
+	}
+	if (!strcmp(name, "white") || !strcmp(name, "#white") || !strcmp(name, "*white") || !strcmp(name, "$whiteimage"))
+		return Image_GenerateWhite();
+	if (!strcmp(name, "gfx/conchars"))
+		return Image_GenerateConChars();
+	if (!strcmp(name, "gfx/colorcontrol/ditherpattern"))
+		return Image_GenerateDitherPattern();
+	return NULL;
+}