gtkradiant/tools/quake2/qdata_heretic2/images.c

/*
Copyright (C) 1999-2007 id Software, Inc. and contributors.
For a list of contributors, see the accompanying CONTRIBUTORS file.

This file is part of GtkRadiant.

GtkRadiant is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

GtkRadiant is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GtkRadiant; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "qdata.h"

#ifdef _WIN32
 #include <windows.h>
#endif

#include <GL/gl.h>

#if 1
	extern char		*g_outputDir;
#endif // _QDATA

char		mip_prefix[1024];		// directory to dump the textures in

qboolean	colormap_issued;
byte		colormap_palette[768];

unsigned total_x = 0;
unsigned total_y = 0;
unsigned total_textures = 0;

#define MAX_IMAGE_SIZE 512

#if	0
/*
==============
RemapZero

Replaces all 0 bytes in an image with the closest palette entry.
This is because NT won't let us change index 0, so any palette
animation leaves those pixels untouched.
==============
*/
void RemapZero (byte *pixels, byte *palette, int width, int height)
{
	int		i, c;
	int		alt_zero;
	int		value, best;

	alt_zero = 0;
	best = 9999999;
	for (i=1 ; i<255 ; i++)
	{
		value = palette[i*3+0]+palette[i*3+1]+palette[i*3+2];
		if (value < best)
		{
			best = value;
			alt_zero = i;
		}
	}

	c = width*height;
	for (i=0 ; i<c ; i++)
		if (pixels[i] == 0)
			pixels[i] = alt_zero;
}

#endif


// ********************************************************************
// **  Mip Map Pre-Processing Routines
// ********************************************************************

#define intensity_value 1

static unsigned image_pal[256];

#define MAX_LAST 25

long palette_r[256], palette_g[256], palette_b[256];
long last_r[MAX_LAST],last_g[MAX_LAST],last_b[MAX_LAST], last_i[MAX_LAST], last_place;

long cached;

void PrepareConvert(unsigned *palette)
{
	int i;

	for(i=0;i<256;i++)
	{
		palette_r[i] = (palette[i] & 0x00ff0000) >> 16;
		palette_g[i] = (palette[i] & 0x0000ff00) >> 8;
		palette_b[i] = (palette[i] & 0x000000ff);
	}

	for(i=0;i<MAX_LAST;i++)
		last_r[i] = -1;

	last_place = -1;
}

int ConvertTrueColorToPal(unsigned r, unsigned g, unsigned b)
{
	int i;
	long min_dist;
	int min_index;
	long dist;
	long dr, dg, db, biggest_delta;

	for(i=0;i<MAX_LAST;i++)
		if (r == last_r[i] && g == last_g[i] && b == last_b[i])
		{
			cached++;
			return last_i[i];
		}

	min_dist = 256 * 256 + 256 * 256 + 256 * 256;
	biggest_delta = 256*256;
	min_index = 0;

	for (i=0;i<256;i++)
	{
		dr = abs(palette_r[i] - r);
		if (dr > biggest_delta)
			continue;
		dg = abs(palette_g[i] - g);
		if (dg > biggest_delta)
			continue;
		db = abs(palette_b[i] - b);
		if (db > biggest_delta)
			continue;

		dist = dr * dr + dg * dg + db * db;
		if (dist < min_dist)
		{
			min_dist = dist;
			min_index = i;
			if (min_dist == 0) break;

			dist = dr;
			if (dg > dist) dist = dg;
			if (db > dist) dist = db;
			if (dist < biggest_delta)
				biggest_delta = dist;
		}
	}

	last_place++;
	if (last_place >= MAX_LAST)
		last_place = 0;

	last_r[last_place] = r;
	last_g[last_place] = g;
	last_b[last_place] = b;
	last_i[last_place] = min_index;

	return min_index;
}


void GL_ResampleTexture8P (byte *in, int inwidth, int inheight, byte *out,  
						   int outwidth, int outheight, palette_t *palette)
{
	int		i, j;
	byte	*inrow, *inrow2;
	unsigned	frac, fracstep;
	unsigned	p1[1024], p2[1024], *p1p, *p2p;
	palette_t	*c1,*c2,*c3,*c4;
	unsigned	r,g,b;
	
	fracstep = inwidth*0x10000/outwidth;

	frac = fracstep>>2;
	for (i=0 ; i<outwidth ; i++)
	{
		p1[i] = frac>>16;
		frac += fracstep;
	}
	frac = 3*(fracstep>>2);
	for (i=0 ; i<outwidth ; i++)
	{
		p2[i] = frac>>16;
		frac += fracstep;
	}

	cached = 0;
	
	for (i=0 ; i<outheight ; i++)//, out += outwidth)
	{
		inrow = in + inwidth*(int)((i+0.25)*inheight/outheight);
		inrow2 = in + inwidth*(int)((i+0.75)*inheight/outheight);

		p1p = p1;
		p2p = p2;
		for (j=0 ; j<outwidth ; j++)
		{
			c1 = &palette[*((byte *)inrow + (*p1p))];
			c2 = &palette[*((byte *)inrow + (*p2p))];
			c3 = &palette[*((byte *)inrow2 + (*p1p++))];
			c4 = &palette[*((byte *)inrow2 + (*p2p++))];

			r = ((unsigned)c1->r + (unsigned)c2->r + (unsigned)c3->r + (unsigned)c4->r)>>2;
			g = ((unsigned)c1->g + (unsigned)c2->g + (unsigned)c3->g + (unsigned)c4->g)>>2;
			b = ((unsigned)c1->b + (unsigned)c2->b + (unsigned)c3->b + (unsigned)c4->b)>>2;

			*out++ = ConvertTrueColorToPal(r,g,b);
		}
	}
}

void GL_MipMap8P(byte *out, byte *in, int width, int height, palette_t *palette)
{
	int			i, j;
	palette_t	*c1,*c2,*c3,*c4;
	unsigned	r,g,b;

	cached = 0;
	memset(out, 0, 256 * 256);
	width <<= 1;
	height <<= 1;

	for (i = 0; i < height; i += 2, in += width)
	{
		for (j = 0; j < width; j += 2)
		{
			c1 = &palette[in[0]];
			c3 = &palette[in[width]];
			in++;
			c2 = &palette[in[0]];
			c4 = &palette[in[width]];
			in++;

			r = ((unsigned)c1->r + (unsigned)c2->r + (unsigned)c3->r + (unsigned)c4->r) >> 2;
			g = ((unsigned)c1->g + (unsigned)c2->g + (unsigned)c3->g + (unsigned)c4->g) >> 2;
			b = ((unsigned)c1->b + (unsigned)c2->b + (unsigned)c3->b + (unsigned)c4->b) >> 2;

			*out++ = ConvertTrueColorToPal(r, g, b);
		}
	}
}


miptex_t *CreateMip(byte *data, unsigned width, unsigned height, byte *palette, int *FinalSize, qboolean mip)
{
	int			scaled_width, scaled_height;
	int			i,j,r,g,b;
	byte		intensitytable[256];
	byte		scaled[256*256];
	byte		out[256*256];
	int			miplevel;
	miptex_t	*mp;
	byte		*pos;
	int			size;

	for (i=0 ; i<256 ; i++)
	{
		j = i * intensity_value;
		if (j > 255)
			j = 255;
		intensitytable[i] = j;
	}

	for (scaled_width = 1 ; scaled_width < width ; scaled_width<<=1)
		;
	if (1 && scaled_width > width && 1)
		scaled_width >>= 1;
	for (scaled_height = 1 ; scaled_height < height ; scaled_height<<=1)
		;
	if (1 && scaled_height > height && 1)
		scaled_height >>= 1;

	// don't ever bother with >256 textures
	if (scaled_width > 256)
		scaled_width = 256;
	if (scaled_height > 256)
		scaled_height = 256;

	if (scaled_width < 1)
		scaled_width = 1;
	if (scaled_height < 1)
		scaled_height = 1;

	size = sizeof(*mp) + (scaled_width*scaled_height*3);
	mp = (miptex_t *)SafeMalloc(size, "CreateMip");
	memset(mp,0,size);

	mp->version = MIP_VERSION;

	for(i=j=0;i<256;i++,j+=3)
	{
		mp->palette[i].r = r = intensitytable[palette[j]];
		mp->palette[i].g = g = intensitytable[palette[j+1]];
		mp->palette[i].b = b = intensitytable[palette[j+2]];
		image_pal[i] = 0xff000000 | (r<<16) | (g<<8) | (b);
	}

	PrepareConvert(image_pal);

	if (scaled_width == width && scaled_height == height)
	{
		memcpy (scaled, data, width*height);
	}
	else
		GL_ResampleTexture8P (data, width, height, scaled, scaled_width, scaled_height, mp->palette);

	pos = (byte *)(mp + 1);
	miplevel = 0;

	while ((scaled_width >= 1 || scaled_height >= 1) && (miplevel <= MIPLEVELS-1) && (!miplevel || mip))
	{
		if (scaled_width < 1)
			scaled_width = 1;
		if (scaled_height < 1)
			scaled_height = 1;

		if(miplevel > 0)
			GL_MipMap8P(out, (byte *)scaled, scaled_width, scaled_height, mp->palette);
		else
			memcpy(out, scaled, 256 * 256);

		mp->width[miplevel] = scaled_width;
		mp->height[miplevel] = scaled_height;
		mp->offsets[miplevel] = pos - ((byte *)(mp));
		memcpy(pos, out, scaled_width * scaled_height);
		memcpy(scaled, out, 256 * 256);
		pos += scaled_width * scaled_height;

		scaled_width >>= 1;
		scaled_height >>= 1;

		miplevel++;
	}

	*FinalSize = pos - ((byte *)(mp));

	return mp;
}


void GL_ResampleTexture (unsigned *in, int inwidth, int inheight, unsigned *out,  int outwidth, int outheight)
{
	int		i, j;
	unsigned	*inrow, *inrow2;
	unsigned	frac, fracstep;
	unsigned	p1[1024], p2[1024];
	byte		*pix1, *pix2, *pix3, *pix4;

	fracstep = inwidth*0x10000/outwidth;

	frac = fracstep>>2;
	for (i=0 ; i<outwidth ; i++)
	{
		p1[i] = 4*(frac>>16);
		frac += fracstep;
	}
	frac = 3*(fracstep>>2);
	for (i=0 ; i<outwidth ; i++)
	{
		p2[i] = 4*(frac>>16);
		frac += fracstep;
	}

	for (i=0 ; i<outheight ; i++, out += outwidth)
	{
		inrow = in + inwidth*(int)((i+0.25)*inheight/outheight);
		inrow2 = in + inwidth*(int)((i+0.75)*inheight/outheight);
		frac = fracstep >> 1;
		for (j=0 ; j<outwidth ; j++)
		{
			pix1 = (byte *)inrow + p1[j];
			pix2 = (byte *)inrow + p2[j];
			pix3 = (byte *)inrow2 + p1[j];
			pix4 = (byte *)inrow2 + p2[j];
			((byte *)(out+j))[0] = (pix1[0] + pix2[0] + pix3[0] + pix4[0])>>2;
			((byte *)(out+j))[1] = (pix1[1] + pix2[1] + pix3[1] + pix4[1])>>2;
			((byte *)(out+j))[2] = (pix1[2] + pix2[2] + pix3[2] + pix4[2])>>2;
			((byte *)(out+j))[3] = (pix1[3] + pix2[3] + pix3[3] + pix4[3])>>2;
		}
	}
}

void GL_MipMap (byte *out, byte *in, int width, int height)
{
	int		i, j;

	width <<=3;
	height <<= 1;
	for (i=0 ; i<height ; i++, in+=width)
	{
		for (j=0 ; j<width ; j+=8, out+=4, in+=8)
		{
			out[0] = (in[0] + in[4] + in[width+0] + in[width+4])>>2;
			out[1] = (in[1] + in[5] + in[width+1] + in[width+5])>>2;
			out[2] = (in[2] + in[6] + in[width+2] + in[width+6])>>2;
			out[3] = (in[3] + in[7] + in[width+3] + in[width+7])>>2;
		}
	}
}

miptex32_t *CreateMip32(unsigned *data, unsigned width, unsigned height, int *FinalSize, qboolean mip)
{
	int				scaled_width, scaled_height;
	unsigned		scaled[MAX_IMAGE_SIZE*MAX_IMAGE_SIZE];
	unsigned		out[MAX_IMAGE_SIZE*MAX_IMAGE_SIZE];
	int				miplevel;
	miptex32_t		*mp;
	byte			*pos;
	int				size;
	paletteRGBA_t	*test;

	for (scaled_width = 1 ; scaled_width < width ; scaled_width<<=1)
		;
	if (1 && scaled_width > width && 1)
		scaled_width >>= 1;
	for (scaled_height = 1 ; scaled_height < height ; scaled_height<<=1)
		;
	if (1 && scaled_height > height && 1)
		scaled_height >>= 1;

	// don't ever bother with >256 textures
	if (scaled_width > MAX_IMAGE_SIZE)
		scaled_width = MAX_IMAGE_SIZE;
	if (scaled_height > MAX_IMAGE_SIZE)
		scaled_height = MAX_IMAGE_SIZE;

	if (scaled_width < 1)
		scaled_width = 1;
	if (scaled_height < 1)
		scaled_height = 1;

	size = sizeof(*mp) + (scaled_width*scaled_height*3*4);
	mp = (miptex32_t *)SafeMalloc(size, "CreateMip");
	memset(mp,0,size);

	mp->version = MIP32_VERSION;

	size = width*height;
	test = (paletteRGBA_t *)data;
	while(size)
	{
		if (test->a != 255)
		{
			mp->flags |= LittleLong(SURF_ALPHA_TEXTURE);
			break;
		}

		size--;
		test++;
	}

	if (scaled_width == width && scaled_height == height)
	{
		memcpy (scaled, data, width*height*4);
	}
	else
		GL_ResampleTexture (data, width, height, scaled, scaled_width, scaled_height);

	pos = (byte *)(mp + 1);
	miplevel = 0;

	while ((scaled_width >= 1 || scaled_height >= 1) && (miplevel <= MIPLEVELS-1) && (!miplevel || mip))
	{
		if (scaled_width < 1)
			scaled_width = 1;
		if (scaled_height < 1)
			scaled_height = 1;

		if (miplevel > 0)
		{
			GL_MipMap((byte *)out, (byte *)scaled, scaled_width, scaled_height);
		}
		else
		{
			memcpy(out, scaled, MAX_IMAGE_SIZE * MAX_IMAGE_SIZE * 4);
		}

		mp->width[miplevel] = scaled_width;
		mp->height[miplevel] = scaled_height;
		mp->offsets[miplevel] = pos - ((byte *)(mp));
		memcpy(pos, out, scaled_width * scaled_height * 4);
		memcpy(scaled, out, MAX_IMAGE_SIZE * MAX_IMAGE_SIZE * 4);
		pos += scaled_width * scaled_height * 4;

		scaled_width >>= 1;
		scaled_height >>= 1;

		miplevel++;
	}

	*FinalSize = pos - ((byte *)(mp));

	return mp;
}

/*
==============
Cmd_Grab

$grab filename x y width height
==============
*/
void Cmd_Grab (void)
{
	int             xl,yl,w,h,y;
	byte			*cropped;
	char			savename[1024];
	char			dest[1024];

	GetScriptToken (false);

	if (token[0] == '/' || token[0] == '\\')
		sprintf (savename, "%s%s.pcx", gamedir, token+1);
	else
		sprintf (savename, "%spics/%s.pcx", gamedir, token);

	if (g_release)
	{
		if (token[0] == '/' || token[0] == '\\')
			sprintf (dest, "%s.pcx", token+1);
		else
			sprintf (dest, "pics/%s.pcx", token);

		ReleaseFile (dest);
		return;
	}

	GetScriptToken (false);
	xl = atoi (token);
	GetScriptToken (false);
	yl = atoi (token);
	GetScriptToken (false);
	w = atoi (token);
	GetScriptToken (false);
	h = atoi (token);

	if (xl<0 || yl<0 || w<0 || h<0 || xl+w>byteimagewidth || yl+h>byteimageheight)
		Error ("GrabPic: Bad size: %i, %i, %i, %i",xl,yl,w,h);

	// crop it to the proper size
	cropped = (byte *) SafeMalloc (w*h, "Cmd_Grab");
	for (y=0 ; y<h ; y++)
	{
		memcpy (cropped+y*w, byteimage+(y+yl)*byteimagewidth+xl, w);
	}

	// save off the new image
	printf ("saving %s\n", savename);
	CreatePath (savename);
	WritePCXfile (savename, cropped, w,	h, lbmpalette);

	free (cropped);
}

/*
==============
Cmd_Raw

$grab filename x y width height
==============
*/
void Cmd_Raw (void)
{
	int             xl,yl,w,h,y;
	byte			*cropped;
	char			savename[1024];
	char			dest[1024];

	GetScriptToken (false);

	sprintf (savename, "%s%s.lmp", gamedir, token);

	if (g_release)
	{
		sprintf (dest, "%s.lmp", token);
		ReleaseFile (dest);
		return;
	}

	GetScriptToken (false);
	xl = atoi (token);
	GetScriptToken (false);
	yl = atoi (token);
	GetScriptToken (false);
	w = atoi (token);
	GetScriptToken (false);
	h = atoi (token);

	if (xl<0 || yl<0 || w<0 || h<0 || xl+w>byteimagewidth || yl+h>byteimageheight)
		Error ("GrabPic: Bad size: %i, %i, %i, %i",xl,yl,w,h);

	// crop it to the proper size
	cropped = (byte *) SafeMalloc (w*h, "Cmd_Raw");
	for (y=0 ; y<h ; y++)
	{
		memcpy (cropped+y*w, byteimage+(y+yl)*byteimagewidth+xl, w);
	}

	// save off the new image
	printf ("saving %s\n", savename);
	CreatePath (savename);

	SaveFile (savename, cropped, w*h);

	free (cropped);
}

/*
=============================================================================

COLORMAP GRABBING

=============================================================================
*/

/*
===============
BestColor
===============
*/
byte BestColor (int r, int g, int b, int start, int stop)
{
	int	i;
	int	dr, dg, db;
	int	bestdistortion, distortion;
	int	bestcolor;
	byte	*pal;

//
// let any color go to 0 as a last resort
//
	bestdistortion = 256*256*4;
	bestcolor = 0;

	pal = colormap_palette + start*3;
	for (i=start ; i<= stop ; i++)
	{
		dr = r - (int)pal[0];
		dg = g - (int)pal[1];
		db = b - (int)pal[2];
		pal += 3;
		distortion = dr*dr + dg*dg + db*db;
		if (distortion < bestdistortion)
		{
			if (!distortion)
				return i;		// perfect match

			bestdistortion = distortion;
			bestcolor = i;
		}
	}

	return bestcolor;
}


/*
==============
Cmd_Colormap

$colormap filename

  the brightes colormap is first in the table (FIXME: reverse this now?)

  64 rows of 256 : lightmaps
  256 rows of 256 : translucency table
==============
*/
void Cmd_Colormap (void)
{
	int		levels, brights;
	int		l, c;
	float	frac, red, green, blue;
	float	range;
	byte	*cropped, *lump_p;
	char	savename[1024];
	char	dest[1024];

	colormap_issued = true;
	if (!g_release)
		memcpy (colormap_palette, lbmpalette, 768);

	if (!ScriptTokenAvailable ())
	{	// just setting colormap_issued
		return;
	}

	GetScriptToken (false);
	sprintf (savename, "%spics/%s.pcx", gamedir, token);

	if (g_release)
	{
		sprintf (dest, "pics/%s.pcx", token);
		ReleaseFile (dest);
		return;
	}

	range = 2;
	levels = 64;
	brights = 1;	// ignore 255 (transparent)

	cropped = (byte *) SafeMalloc((levels+256)*256, "Cmd_ColorMap");
	lump_p = cropped;

// shaded levels
	for (l=0;l<levels;l++)
	{
		frac = range - range*(float)l/(levels-1);
		for (c=0 ; c<256-brights ; c++)
		{
			red = lbmpalette[c*3];
			green = lbmpalette[c*3+1];
			blue = lbmpalette[c*3+2];

			red = (int)(red*frac+0.5);
			green = (int)(green*frac+0.5);
			blue = (int)(blue*frac+0.5);
			
//
// note: 254 instead of 255 because 255 is the transparent color, and we
// don't want anything remapping to that
// don't use color 0, because NT can't remap that (or 255)
//
			*lump_p++ = BestColor(red,green,blue, 1, 254);
		}

		// fullbrights allways stay the same
		for ( ; c<256 ; c++)
			*lump_p++ = c;
	}
	
// 66% transparancy table
	for (l=0;l<255;l++)
	{
		for (c=0 ; c<255 ; c++)
		{
			red = lbmpalette[c*3]*0.33 + lbmpalette[l*3]*0.66;
			green = lbmpalette[c*3+1]*0.33 + lbmpalette[l*3+1]*0.66;
			blue = lbmpalette[c*3+2]*0.33 + lbmpalette[l*3+2]*0.66;

			*lump_p++ = BestColor(red,green,blue, 1, 254);
		}
		*lump_p++ = 255;
	}
	for (c=0 ; c<256 ; c++)
		*lump_p++ = 255;
	
	// save off the new image
	printf ("saving %s\n", savename);
	CreatePath (savename);
	WritePCXfile (savename, cropped, 256, levels+256, lbmpalette);

	free (cropped);
}

/*
=============================================================================

MIPTEX GRABBING

=============================================================================
*/

byte	pixdata[256];

int		d_red, d_green, d_blue;

byte	palmap[32][32][32];
qboolean	palmap_built;

/*
=============
FindColor
=============
*/
int FindColor (int r, int g, int b)
{
	int		bestcolor;

	if (r > 255)
		r = 255;
	if (r < 0)
		r = 0;
	if (g > 255)
		g = 255;
	if (g < 0)
		g = 0;
	if (b > 255)
		b = 255;
	if (b < 0)
		b = 0;
#ifndef TABLECOLORS
	bestcolor = BestColor (r, g, b, 0, 254);
#else
	bestcolor = palmap[r>>3][g>>3][b>>3];
#endif

	return bestcolor;
}


void BuildPalmap (void)
{
#ifdef TABLECOLORS
	int		r, g, b;
	int		bestcolor;

	if (palmap_built)
		return;
	palmap_built = true;

	for (r=4 ; r<256 ; r+=8)
	{
		for (g=4 ; g<256 ; g+=8)
		{
			for (b=4 ; b<256 ; b+=8)
			{
				bestcolor = BestColor (r, g, b, 1, 254);
				palmap[r>>3][g>>3][b>>3] = bestcolor;
			}
		}
	}
#endif

	if (!colormap_issued)
		Error ("You must issue a $colormap command first");

}

/*
=============
AveragePixels
=============
*/
byte AveragePixels (int count)
{
	int		r,g,b;
	int		i;
	int		vis;
	int		pix;
	int		bestcolor;
	byte	*pal;
	int		fullbright;
	
	vis = 0;
	r = g = b = 0;
	fullbright = 0;
	for (i=0 ; i<count ; i++)
	{
		pix = pixdata[i];
		
		r += lbmpalette[pix*3];
		g += lbmpalette[pix*3+1];
		b += lbmpalette[pix*3+2];
		vis++;
	}
		
	r /= vis;
	g /= vis;
	b /= vis;

	// error diffusion
	r += d_red;
	g += d_green;
	b += d_blue;
	
//
// find the best color
//
	bestcolor = FindColor (r, g, b);

	// error diffusion
	pal = colormap_palette + bestcolor*3;
	d_red = r - (int)pal[0];
	d_green = g - (int)pal[1];
	d_blue = b - (int)pal[2];

	return bestcolor;
}


typedef enum
{
	pt_contents,
	pt_flags,
	pt_animvalue,
	pt_altnamevalue,
	pt_damagenamevalue,
	pt_flagvalue,
	pt_materialvalue,
	pt_scale,
	pt_mip,
	pt_detail,
	pt_gl,
	pt_nomip,
	pt_detailer,
} parmtype_t;

typedef struct
{
	char	*name;
	int		flags;
	parmtype_t	type;
} mipparm_t;

mipparm_t	mipparms[] =
{
	// utility content attributes
	{"pushpull",CONTENTS_PUSHPULL, pt_contents},
	{"water",	CONTENTS_WATER, pt_contents},
	{"slime",	CONTENTS_SLIME, pt_contents},		// mildly damaging
	{"lava",	CONTENTS_LAVA, pt_contents},		// very damaging
	{"window",	CONTENTS_WINDOW, pt_contents},	// solid, but doesn't eat internal textures
	{"mist",	CONTENTS_MIST, pt_contents},	// non-solid window
	{"origin",	CONTENTS_ORIGIN, pt_contents},	// center of rotating brushes
	{"playerclip",	CONTENTS_PLAYERCLIP, pt_contents},
	{"monsterclip",	CONTENTS_MONSTERCLIP, pt_contents},

	// utility surface attributes
	{"hint",	SURF_HINT, pt_flags},
	{"skip",	SURF_SKIP, pt_flags},
	{"light",	SURF_LIGHT, pt_flagvalue},		// value is the light quantity

	{"animspeed",SURF_ANIMSPEED, pt_flagvalue},		// value will hold the anim speed in fps

	// texture chaining
	{"anim",	0,			pt_animvalue},		// animname is the next animation
	{"alt",		0,			pt_altnamevalue},	// altname is the alternate texture
	{"damage",	0,			pt_damagenamevalue},	// damagename is the damage texture
	{"scale",	0,			pt_scale},		// next two values are for scale
	{"mip",		0,			pt_mip},		
	{"detail",	0,			pt_detail},		

	{"GL_ZERO",					GL_ZERO,				pt_gl},
	{"GL_ONE",					GL_ONE,					pt_gl},
	{"GL_SRC_COLOR",			GL_SRC_COLOR,			pt_gl},
	{"GL_ONE_MINUS_SRC_COLOR",	GL_ONE_MINUS_SRC_COLOR,	pt_gl},
	{"GL_DST_COLOR",			GL_DST_COLOR,			pt_gl},
	{"GL_ONE_MINUS_DST_COLOR",	GL_ONE_MINUS_DST_COLOR,	pt_gl},
	{"GL_SRC_ALPHA",			GL_SRC_ALPHA,			pt_gl},
	{"GL_ONE_MINUS_SRC_ALPHA",	GL_ONE_MINUS_SRC_ALPHA,	pt_gl},
	{"GL_DST_ALPHA",			GL_DST_ALPHA,			pt_gl},
	{"GL_ONE_MINUS_DST_ALPHA",	GL_ONE_MINUS_DST_ALPHA,	pt_gl},
	{"GL_SRC_ALPHA_SATURATE",	GL_SRC_ALPHA_SATURATE,	pt_gl},

	// server attributes
	{"slick",	SURF_SLICK, pt_flags},

	// drawing attributes
	{"sky",		SURF_SKY, pt_flags},
	{"warping",	SURF_WARP, pt_flags},		// only valid with 64x64 textures
	{"trans33",	SURF_TRANS33, pt_flags},	// translucent should allso set fullbright
	{"trans66",	SURF_TRANS66, pt_flags},
	{"flowing",	SURF_FLOWING, pt_flags},	// flow direction towards angle 0
	{"nodraw",	SURF_NODRAW, pt_flags},	// for clip textures and trigger textures
	{"alpha",	SURF_ALPHA_TEXTURE, pt_flags},
	{"undulate",	SURF_UNDULATE, pt_flags},		// rock surface up and down...
	{"skyreflect",	SURF_SKYREFLECT, pt_flags},		// liquid will somewhat reflect the sky - not quite finished....

	{"material", SURF_MATERIAL, pt_materialvalue},
	{"metal",	SURF_TYPE_METAL, pt_flags},
	{"stone",	SURF_TYPE_STONE, pt_flags},
	{"wood",	SURF_TYPE_WOOD, pt_flags},

	{"m_nomip", 0, pt_nomip},
	{"m_detail", 0, pt_detailer},

	{NULL, 0, pt_contents}
};

/*
==============
Cmd_Mip

$mip filename x y width height <OPTIONS>
must be multiples of sixteen
SURF_WINDOW
==============
*/

void Cmd_Mip (void)
{
	int             xl,yl,xh,yh,w,h;
	byte            *dest, *source;
	int				flags, value, contents;
	mipparm_t		*mp;
	char			lumpname[128];
	char			altname[128];
	char			animname[128];
	char			damagename[128];
	byte			buffer[MAX_IMAGE_SIZE*MAX_IMAGE_SIZE];
	unsigned		bufferl[MAX_IMAGE_SIZE*MAX_IMAGE_SIZE];
	materialtype_t	*mat;
	char			filename[1024];
	unsigned        *destl, *sourcel;
	int             linedelta, x, y;
	int				size;
	miptex_t		*qtex;
	miptex32_t		*qtex32;
	float			scale_x, scale_y;
	int				mip_scale;
	// detail texturing
	char			dt_name[128];
	float			dt_scale_x, dt_scale_y;
	float			dt_u, dt_v;
	float			dt_alpha;
	int				dt_src_blend_mode, dt_dst_blend_mode;
	int				flags2;


	GetScriptToken (false);
	strcpy (lumpname, token);
	
	GetScriptToken (false);
	xl = atoi (token);
	GetScriptToken (false);
	yl = atoi (token);
	GetScriptToken (false);
	w = atoi (token);
	GetScriptToken (false);
	h = atoi (token);

	total_x += w;
	total_y += h;
	total_textures++;

	if ( (w & 15) || (h & 15) )
		Error ("line %i: miptex sizes must be multiples of 16", scriptline);

	flags = 0;
	flags2 = 0;
	contents = 0;
	value = 0;
	mip_scale = 0;

	altname[0] = animname[0] = damagename[0] = 0;

	scale_x = scale_y = 0.5;

	// detail texturing
	dt_name[0] = 0;
	dt_scale_x = dt_scale_y = 0.0;
	dt_u = dt_v = 0.0;
	dt_alpha = 0.0;
	dt_src_blend_mode = dt_dst_blend_mode = 0;

	// get optional flags and values
	while (ScriptTokenAvailable ())
	{
		GetScriptToken (false);
	
		for (mp=mipparms ; mp->name ; mp++)
		{
			if (!strcmp(mp->name, token))
			{
				switch (mp->type)
				{
					case pt_animvalue:
						GetScriptToken (false);	// specify the next animation frame
						strcpy (animname, token);
						break;
					case pt_altnamevalue:
						GetScriptToken (false);	// specify the alternate texture
						strcpy (altname, token);
						break;
					case pt_damagenamevalue:
						GetScriptToken (false);	// specify the damage texture
						strcpy (damagename, token);
						break;
					case pt_flags:
						flags |= mp->flags;
						break;
					case pt_contents:
						contents |= mp->flags;
						break;
					case pt_flagvalue:
						flags |= mp->flags;
						GetScriptToken (false);	// specify the light value
						value = atoi(token);
						break;
					case pt_materialvalue:
						GetScriptToken(false);
						for (mat=materialtypes ; mat->name ; mat++)
						{
							if (!strcmp(mat->name, token))
							{
								// assumes SURF_MATERIAL is in top 8 bits
								flags = (flags & 0x0FFFFFF) | (mat->value << 24);
								break;
							}
						}
						break;
					case pt_scale:
						GetScriptToken (false);	// specify the x scale
						scale_x = atof(token);
						GetScriptToken (false);	// specify the y scale
						scale_y = atof(token);
						break;

					case pt_mip:
						mip_scale = 1;
						break;

					case pt_detailer:
						flags2 |= MIP32_DETAILER_FLAG2;
						break;

					case pt_nomip:
						flags2 |= MIP32_NOMIP_FLAG2;
						break;

					case pt_detail:
						GetScriptToken(false);
						strcpy(dt_name, token);
						GetScriptToken(false);
						dt_scale_x = atof(token);
						GetScriptToken(false);
						dt_scale_y = atof(token);
						GetScriptToken(false);
						dt_u = atof(token);
						GetScriptToken(false);
						dt_v = atof(token);
						GetScriptToken(false);
						dt_alpha = atof(token);
						GetScriptToken(false);
						for (mp=mipparms ; mp->name ; mp++)
						{
							if (!strcmp(mp->name, token))
							{
								if (mp->type == pt_gl)
								{
									dt_src_blend_mode = mp->flags;
									break;
								}
							}
						}
						if (!mp->name)
						{
							Error ("line %i: invalid gl blend mode %s", scriptline, token);
						}
						GetScriptToken (false);
						for (mp=mipparms ; mp->name ; mp++)
						{
							if (!strcmp(mp->name, token))
							{
								if (mp->type == pt_gl)
								{
									dt_dst_blend_mode = mp->flags;
									break;
								}
							}
						}
						if (!mp->name)
						{
							Error ("line %i: invalid gl blend mode %s", scriptline, token);
						}
						break;
				}
				break;
			}
		}
		if (!mp->name)
			Error ("line %i: unknown parm %s", scriptline, token);
	}

	if (g_release)
		return;	// textures are only released by $maps

	xh = xl+w;
	yh = yl+h;
	if (xh*yh > MAX_IMAGE_SIZE*MAX_IMAGE_SIZE)
	{
		Error("line %i image %s: image is too big!", scriptline, lumpname);
	}
		
	if (TrueColorImage)
	{
		if (xl >= longimagewidth || xh > longimagewidth ||
			yl >= longimageheight || yh > longimageheight)
		{
			Error ("line %i image %s: bad clip dimmensions (%d,%d) (%d,%d) > image (%d,%d)", scriptline, lumpname, xl,yl,w,h,longimagewidth,longimageheight);
		}

		sourcel = longimage + (yl*longimagewidth) + xl;
		destl = bufferl;
		linedelta = (longimagewidth - w);

		for (y=yl ; y<yh ; y++)
		{
			for (x=xl ; x<xh ; x++)
			{
				*destl++ = *sourcel++;	// RGBA
			}
			sourcel += linedelta;
		}

		qtex32 = CreateMip32(bufferl, w, h, &size, true);

		qtex32->flags |= LittleLong(flags);
		qtex32->flags2 |= LittleLong(flags2);
		qtex32->contents = LittleLong(contents);
		qtex32->value = LittleLong(value);
		qtex32->scale_x = scale_x;
		qtex32->scale_y = scale_y;
		qtex32->mip_scale = mip_scale;
		sprintf (qtex32->name, "%s/%s", mip_prefix, lumpname);
		if (animname[0])
		{
			sprintf (qtex32->animname, "%s/%s", mip_prefix, animname);
		}
		if (altname[0])
		{
			sprintf (qtex32->altname, "%s/%s", mip_prefix, altname);
		}
		if (damagename[0])
		{
			sprintf (qtex32->damagename, "%s/%s", mip_prefix, damagename);
		}
		if (dt_name[0] & ((flags2 & MIP32_DETAILER_FLAG2) == 0)) 
		{
			sprintf (qtex32->dt_name, "%s/%s", mip_prefix, dt_name);
			qtex32->dt_scale_x = dt_scale_x;
			qtex32->dt_scale_y = dt_scale_y;
			qtex32->dt_u = dt_u;
			qtex32->dt_v = dt_v;
			qtex32->dt_alpha = dt_alpha;
			qtex32->dt_src_blend_mode = dt_src_blend_mode;
			qtex32->dt_dst_blend_mode = dt_dst_blend_mode;
		}
		
	//
	// write it out
	//
		sprintf (filename, "%stextures/%s/%s.m32", g_outputDir, mip_prefix, lumpname);
		if(qtex32->flags & (SURF_ALPHA_TEXTURE))
			printf ("writing %s with ALPHA\n", filename);
		else
			printf ("writing %s\n", filename);
		SaveFile (filename, (byte *)qtex32, size);

		free (qtex32);
	}
	else
	{
		if (xl >= byteimagewidth || xh > byteimagewidth ||
			yl >= byteimageheight || yh > byteimageheight)
		{
			Error ("line %i: bad clip dimmensions (%d,%d) (%d,%d) > image (%d,%d)", scriptline, xl,yl,w,h,byteimagewidth,byteimageheight);
		}

		source = byteimage + yl*byteimagewidth + xl;
		dest = buffer;
		linedelta = byteimagewidth - w;

		for (y=yl ; y<yh ; y++)
		{
			for (x=xl ; x<xh ; x++)
			{
				*dest++ = *source++;
			}
			source += linedelta;
		}

		qtex = CreateMip(buffer, w, h, lbmpalette, &size, true);

		qtex->flags = LittleLong(flags);
		qtex->contents = LittleLong(contents);
		qtex->value = LittleLong(value);
		sprintf (qtex->name, "%s/%s", mip_prefix, lumpname);
		if (animname[0])
			sprintf (qtex->animname, "%s/%s", mip_prefix, animname);
		
	//
	// write it out
	//
		sprintf (filename, "%stextures/%s/%s.m8", g_outputDir, mip_prefix, lumpname);
		printf ("writing %s\n", filename);
		SaveFile (filename, (byte *)qtex, size);

		free (qtex);
	}
}

/*
===============
Cmd_Mippal
===============
*/
void Cmd_Mippal (void)
{
	colormap_issued = true;
	if (g_release)
		return;

	memcpy (colormap_palette, lbmpalette, 768);

	BuildPalmap();
}


/*
===============
Cmd_Mipdir
===============
*/
void Cmd_Mipdir (void)
{
	char	filename[1024];

	GetScriptToken (false);
	strcpy (mip_prefix, token);
	// create the directory if needed
	sprintf (filename, "%stextures", g_outputDir);
	Q_mkdir (filename); 
	sprintf (filename, "%stextures/%s", g_outputDir, mip_prefix);
	Q_mkdir (filename); 
}


/*
=============================================================================

ENVIRONMENT MAP GRABBING

Creates six pcx files from tga files without any palette edge seams
also copies the tga files for GL rendering.
=============================================================================
*/

// 3dstudio environment map suffixes
char	*suf[6] = {"rt", "ft", "lf", "bk", "up", "dn"};

/*
=================
Cmd_Environment
=================
*/
void Cmd_Environment (void)
{
	char	name[1024];
	int		i, x, y;
	byte	image[256*256];
	byte	*tga;

	GetScriptToken (false);

	if (g_release)
	{
		for (i=0 ; i<6 ; i++)
		{
			sprintf (name, "env/%s%s.pcx", token, suf[i]);
			ReleaseFile (name);
			sprintf (name, "env/%s%s.tga", token, suf[i]);
			ReleaseFile (name);
		}
		return;
	}
	// get the palette
	BuildPalmap ();

	sprintf (name, "%senv/", gamedir);
	CreatePath (name);

	// convert the images
	for (i=0 ; i<6 ; i++)
	{
		sprintf (name, "%senv/%s%s.tga", gamedir, token, suf[i]);
		printf ("loading %s...\n", name);
		LoadTGA (name, &tga, NULL, NULL);

		for (y=0 ; y<256 ; y++)
		{
			for (x=0 ; x<256 ; x++)
			{
				image[y*256+x] = FindColor (tga[(y*256+x)*4+0],tga[(y*256+x)*4+1],tga[(y*256+x)*4+2]);
			}
		}
		free (tga);
		sprintf (name, "%senv/%s%s.pcx", gamedir, token, suf[i]);
		if (FileTime (name) != -1)
			printf ("%s already exists, not overwriting.\n", name);
		else
			WritePCXfile (name, image, 256, 256, colormap_palette);
	}
}