1

utils/xwad/goldsrc_bspfile.h

@@ -0,0 +1,310 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+#ifndef BSPFILE_H
+#define BSPFILE_H
+
+// upper design bounds
+
+#define	MAX_MAP_HULLS		4
+
+#define	MAX_MAP_MODELS		400
+#define	MAX_MAP_BRUSHES		4096
+#define	MAX_MAP_ENTITIES	1024
+#define	MAX_MAP_ENTSTRING	(128*1024)
+
+#define	MAX_MAP_PLANES		32767
+#define	MAX_MAP_NODES		32767		// because negative shorts are contents
+#define	MAX_MAP_CLIPNODES	32767		//
+#define	MAX_MAP_LEAFS		8192
+#define	MAX_MAP_VERTS		65535
+#define	MAX_MAP_FACES		65535
+#define	MAX_MAP_MARKSURFACES 65535
+#define	MAX_MAP_TEXINFO		8192
+#define	MAX_MAP_EDGES		256000
+#define	MAX_MAP_SURFEDGES	512000
+#define	MAX_MAP_TEXTURES	512
+#define	MAX_MAP_MIPTEX		0x400000
+#define	MAX_MAP_LIGHTING	0x100000
+#define	MAX_MAP_VISIBILITY	0x100000
+
+#define	MAX_MAP_PORTALS		65536
+
+// key / value pair sizes
+
+#define	MAX_KEY		32
+#define	MAX_VALUE	1024
+
+//=============================================================================
+
+
+#define BSPVERSION	30
+#define	TOOLVERSION	2
+
+typedef struct
+{
+	int		fileofs, filelen;
+} lump_t;
+
+#define	LUMP_ENTITIES	0
+#define	LUMP_PLANES		1
+#define	LUMP_TEXTURES	2
+#define	LUMP_VERTEXES	3
+#define	LUMP_VISIBILITY	4
+#define	LUMP_NODES		5
+#define	LUMP_TEXINFO	6
+#define	LUMP_FACES		7
+#define	LUMP_LIGHTING	8
+#define	LUMP_CLIPNODES	9
+#define	LUMP_LEAFS		10
+#define	LUMP_MARKSURFACES 11
+#define	LUMP_EDGES		12
+#define	LUMP_SURFEDGES	13
+#define	LUMP_MODELS		14
+
+#define	HEADER_LUMPS	15
+
+typedef struct
+{
+	float		mins[3], maxs[3];
+	float		origin[3];
+	int			headnode[MAX_MAP_HULLS];
+	int			visleafs;		// not including the solid leaf 0
+	int			firstface, numfaces;
+} dmodel_t;
+
+typedef struct
+{
+	int			version;	
+	lump_t		lumps[HEADER_LUMPS];
+} dheader_t;
+
+typedef struct
+{
+	int			nummiptex;
+	int			dataofs[4];		// [nummiptex]
+} dmiptexlump_t;
+
+#define	MIPLEVELS	4
+typedef struct miptex_s
+{
+	char		name[16];
+	unsigned	width, height;
+	unsigned	offsets[MIPLEVELS];		// four mip maps stored
+} miptex_t;
+
+
+typedef struct
+{
+	float	point[3];
+} dvertex_t;
+
+
+// 0-2 are axial planes
+#define	PLANE_X			0
+#define	PLANE_Y			1
+#define	PLANE_Z			2
+
+// 3-5 are non-axial planes snapped to the nearest
+#define	PLANE_ANYX		3
+#define	PLANE_ANYY		4
+#define	PLANE_ANYZ		5
+
+typedef struct
+{
+	float	normal[3];
+	float	dist;
+	int		type;		// PLANE_X - PLANE_ANYZ ?remove? trivial to regenerate
+} dplane_t;
+
+
+/*** -1..-6 now in const.h ***/
+#define	CONTENTS_ORIGIN		-7		// removed at csg time
+#define	CONTENTS_CLIP		-8		// changed to contents_solid
+#define	CONTENTS_CURRENT_0		-9
+#define	CONTENTS_CURRENT_90		-10
+#define	CONTENTS_CURRENT_180	-11
+#define	CONTENTS_CURRENT_270	-12
+#define	CONTENTS_CURRENT_UP		-13
+#define	CONTENTS_CURRENT_DOWN	-14
+
+#define CONTENTS_TRANSLUCENT	-15
+
+
+// !!! if this is changed, it must be changed in asm_i386.h too !!!
+typedef struct
+{
+	int			planenum;
+	short		children[2];	// negative numbers are -(leafs+1), not nodes
+	short		mins[3];		// for sphere culling
+	short		maxs[3];
+	unsigned short	firstface;
+	unsigned short	numfaces;	// counting both sides
+} dnode_t;
+
+typedef struct
+{
+	int			planenum;
+	short		children[2];	// negative numbers are contents
+} dclipnode_t;
+
+
+typedef struct texinfo_s
+{
+	float		vecs[2][4];		// [s/t][xyz offset]
+	int			miptex;
+	int			flags;
+} texinfo_t;
+#define	TEX_SPECIAL		1		// sky or slime, no lightmap or 256 subdivision
+
+// note that edge 0 is never used, because negative edge nums are used for
+// counterclockwise use of the edge in a face
+typedef struct
+{
+	unsigned short	v[2];		// vertex numbers
+} dedge_t;
+
+#define	MAXLIGHTMAPS	4
+typedef struct
+{
+	short		planenum;
+	short		side;
+
+	int			firstedge;		// we must support > 64k edges
+	short		numedges;	
+	short		texinfo;
+
+// lighting info
+	byte		styles[MAXLIGHTMAPS];
+	int			lightofs;		// start of [numstyles*surfsize] samples
+} dface_t;
+
+
+
+#define	AMBIENT_WATER	0
+#define	AMBIENT_SKY		1
+#define	AMBIENT_SLIME	2
+#define	AMBIENT_LAVA	3
+
+#define	NUM_AMBIENTS			4		// automatic ambient sounds
+
+// leaf 0 is the generic CONTENTS_SOLID leaf, used for all solid areas
+// all other leafs need visibility info
+typedef struct
+{
+	int			contents;
+	int			visofs;				// -1 = no visibility info
+
+	short		mins[3];			// for frustum culling
+	short		maxs[3];
+
+	unsigned short		firstmarksurface;
+	unsigned short		nummarksurfaces;
+
+	byte		ambient_level[NUM_AMBIENTS];
+} dleaf_t;
+
+
+//============================================================================
+
+#ifndef QUAKE_GAME
+
+#define	ANGLE_UP	-1
+#define	ANGLE_DOWN	-2
+
+
+// the utilities get to be lazy and just use large static arrays
+
+extern	int			nummodels;
+extern	dmodel_t	dmodels[MAX_MAP_MODELS];
+
+extern	int			visdatasize;
+extern	byte		dvisdata[MAX_MAP_VISIBILITY];
+
+extern	int			lightdatasize;
+extern	byte		dlightdata[MAX_MAP_LIGHTING];
+
+extern	int			texdatasize;
+extern	byte		dtexdata[MAX_MAP_MIPTEX]; // (dmiptexlump_t)
+
+extern	int			entdatasize;
+extern	char		dentdata[MAX_MAP_ENTSTRING];
+
+extern	int			numleafs;
+extern	dleaf_t		dleafs[MAX_MAP_LEAFS];
+
+extern	int			numplanes;
+extern	dplane_t	dplanes[MAX_MAP_PLANES];
+
+extern	int			numvertexes;
+extern	dvertex_t	dvertexes[MAX_MAP_VERTS];
+
+extern	int			numnodes;
+extern	dnode_t		dnodes[MAX_MAP_NODES];
+
+extern	int			numtexinfo;
+extern	texinfo_t	texinfo[MAX_MAP_TEXINFO];
+
+extern	int			numfaces;
+extern	dface_t		dfaces[MAX_MAP_FACES];
+
+extern	int			numclipnodes;
+extern	dclipnode_t	dclipnodes[MAX_MAP_CLIPNODES];
+
+extern	int			numedges;
+extern	dedge_t		dedges[MAX_MAP_EDGES];
+
+extern	int			nummarksurfaces;
+extern	unsigned short	dmarksurfaces[MAX_MAP_MARKSURFACES];
+
+extern	int			numsurfedges;
+extern	int			dsurfedges[MAX_MAP_SURFEDGES];
+
+
+void DecompressVis (byte *in, byte *decompressed);
+int CompressVis (byte *vis, byte *dest);
+
+void	LoadBSPFile (char *filename);
+void	WriteBSPFile (char *filename);
+void	PrintBSPFileSizes (void);
+
+//===============
+
+
+typedef struct epair_s
+{
+	struct epair_s	*next;
+	char	*key;
+	char	*value;
+} epair_t;
+
+typedef struct
+{
+	vec3_t		origin;
+	int			firstbrush;
+	int			numbrushes;
+	epair_t		*epairs;
+} entity_t;
+
+extern	int			num_entities;
+extern	entity_t	entities[MAX_MAP_ENTITIES];
+
+void	ParseEntities (void);
+void	UnparseEntities (void);
+
+void 	SetKeyValue (entity_t *ent, char *key, char *value);
+char 	*ValueForKey (entity_t *ent, char *key);
+// will return "" if not present
+
+vec_t	FloatForKey (entity_t *ent, char *key);
+void 	GetVectorForKey (entity_t *ent, char *key, vec3_t vec);
+
+epair_t *ParseEpair (void);
+
+#endif
+
+#endif

utils/xwad/goldsrc_standin.cpp

@@ -0,0 +1,322 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include <windows.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include "goldsrc_standin.h"
+
+
+extern int errno;
+
+
+static unsigned short g_InitialColor = 0xFFFF;
+static unsigned short g_LastColor = 0xFFFF;
+static unsigned short g_BadColor = 0xFFFF;
+static WORD g_BackgroundFlags = 0xFFFF;
+static bool g_bGotInitialColors = false;
+
+static void GetInitialColors( )
+{
+	if ( g_bGotInitialColors )
+		return;
+
+	g_bGotInitialColors = true;
+
+	// Get the old background attributes.
+	CONSOLE_SCREEN_BUFFER_INFO oldInfo;
+	GetConsoleScreenBufferInfo( GetStdHandle( STD_OUTPUT_HANDLE ), &oldInfo );
+	g_InitialColor = g_LastColor = oldInfo.wAttributes & (FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE|FOREGROUND_INTENSITY);
+	g_BackgroundFlags = oldInfo.wAttributes & (BACKGROUND_RED|BACKGROUND_GREEN|BACKGROUND_BLUE|BACKGROUND_INTENSITY);
+
+	g_BadColor = 0;
+	if (g_BackgroundFlags & BACKGROUND_RED)
+		g_BadColor |= FOREGROUND_RED;
+	if (g_BackgroundFlags & BACKGROUND_GREEN)
+		g_BadColor |= FOREGROUND_GREEN;
+	if (g_BackgroundFlags & BACKGROUND_BLUE)
+		g_BadColor |= FOREGROUND_BLUE;
+	if (g_BackgroundFlags & BACKGROUND_INTENSITY)
+		g_BadColor |= FOREGROUND_INTENSITY;
+}
+
+static WORD SetConsoleTextColor( int red, int green, int blue, int intensity )
+{
+	GetInitialColors();
+
+	WORD ret = g_LastColor;
+	
+	g_LastColor = 0;
+	if( red )	g_LastColor |= FOREGROUND_RED;
+	if( green ) g_LastColor |= FOREGROUND_GREEN;
+	if( blue )  g_LastColor |= FOREGROUND_BLUE;
+	if( intensity ) g_LastColor |= FOREGROUND_INTENSITY;
+
+	// Just use the initial color if there's a match...
+	if (g_LastColor == g_BadColor)
+		g_LastColor = g_InitialColor;
+
+	SetConsoleTextAttribute( GetStdHandle( STD_OUTPUT_HANDLE ), g_LastColor | g_BackgroundFlags );
+	return ret;
+}
+
+
+static void RestoreConsoleTextColor( WORD color )
+{
+	SetConsoleTextAttribute( GetStdHandle( STD_OUTPUT_HANDLE ), color | g_BackgroundFlags );
+	g_LastColor = color;
+}
+
+
+void Msg( const char *pMsg, ... )
+{
+	va_list marker;
+	va_start( marker, pMsg );
+	vprintf( pMsg, marker );
+	va_end( marker );
+}
+
+
+void Warning( const char *pMsg, ... )
+{
+	WORD old = SetConsoleTextColor( 1, 1, 0, 1 );
+	
+	va_list marker;
+	va_start( marker, pMsg );
+	vprintf( pMsg, marker );
+	va_end( marker );
+
+	RestoreConsoleTextColor( old );
+}
+
+
+void Error (const char *error, ...)
+{
+	WORD old = SetConsoleTextColor( 1, 0, 0, 1 );
+
+	va_list argptr;
+
+	printf ("\n************ ERROR ************\n");
+
+	va_start (argptr,error);
+	vprintf (error,argptr);
+	va_end (argptr);
+	printf ("\n");
+
+	extern void PrintExitStuff();
+	PrintExitStuff();
+
+	RestoreConsoleTextColor( old );
+
+	TerminateProcess( GetCurrentProcess(), 100 );
+}
+
+
+/*
+================
+filelength
+================
+*/
+int filelength (FILE *f)
+{
+	int		pos;
+	int		end;
+
+	pos = ftell (f);
+	fseek (f, 0, SEEK_END);
+	end = ftell (f);
+	fseek (f, pos, SEEK_SET);
+
+	return end;
+}
+
+
+FILE *SafeOpenWrite (char *filename)
+{
+	FILE	*f;
+
+	f = fopen(filename, "wb");
+
+	if (!f)
+		Error ("Error opening %s: %s",filename,strerror(errno));
+
+	return f;
+}
+
+FILE *SafeOpenRead (char *filename)
+{
+	FILE	*f;
+
+	f = fopen(filename, "rb");
+
+	if (!f)
+		Error ("Error opening %s: %s",filename,strerror(errno));
+
+	return f;
+}
+
+
+void SafeRead (FILE *f, void *buffer, int count)
+{
+	if ( fread (buffer, 1, count, f) != (size_t)count)
+		Error ("File read failure");
+}
+
+
+void SafeWrite (FILE *f, void *buffer, int count)
+{
+	if (fwrite (buffer, 1, count, f) != (size_t)count)
+		Error ("File read failure");
+}
+
+
+
+/*
+==============
+LoadFile
+==============
+*/
+int    LoadFile (char *filename, void **bufferptr)
+{
+	FILE	*f;
+	int    length;
+	void    *buffer;
+
+	f = SafeOpenRead (filename);
+	length = filelength (f);
+	buffer = malloc (length+1);
+	((char *)buffer)[length] = 0;
+	SafeRead (f, buffer, length);
+	fclose (f);
+
+	*bufferptr = buffer;
+	return length;
+}
+
+
+void    SaveFile (char *filename, void *buffer, int count)
+{
+	FILE	*f;
+
+	f = SafeOpenWrite (filename);
+	SafeWrite (f, buffer, count);
+	fclose (f);
+}
+
+
+#ifdef __BIG_ENDIAN__
+
+short   LittleShort (short l)
+{
+	byte    b1,b2;
+
+	b1 = l&255;
+	b2 = (l>>8)&255;
+
+	return (b1<<8) + b2;
+}
+
+short   BigShort (short l)
+{
+	return l;
+}
+
+
+int    LittleLong (int l)
+{
+	byte    b1,b2,b3,b4;
+
+	b1 = l&255;
+	b2 = (l>>8)&255;
+	b3 = (l>>16)&255;
+	b4 = (l>>24)&255;
+
+	return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
+}
+
+int    BigLong (int l)
+{
+	return l;
+}
+
+
+float	LittleFloat (float l)
+{
+	union {byte b[4]; float f;} in, out;
+	
+	in.f = l;
+	out.b[0] = in.b[3];
+	out.b[1] = in.b[2];
+	out.b[2] = in.b[1];
+	out.b[3] = in.b[0];
+	
+	return out.f;
+}
+
+float	BigFloat (float l)
+{
+	return l;
+}
+
+
+#else
+
+
+short   BigShort (short l)
+{
+	byte    b1,b2;
+
+	b1 = l&255;
+	b2 = (l>>8)&255;
+
+	return (b1<<8) + b2;
+}
+
+short   LittleShort (short l)
+{
+	return l;
+}
+
+
+int    BigLong (int l)
+{
+	byte    b1,b2,b3,b4;
+
+	b1 = l&255;
+	b2 = (l>>8)&255;
+	b3 = (l>>16)&255;
+	b4 = (l>>24)&255;
+
+	return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
+}
+
+int    LittleLong (int l)
+{
+	return l;
+}
+
+float	BigFloat (float l)
+{
+	union {byte b[4]; float f;} in, out;
+	
+	in.f = l;
+	out.b[0] = in.b[3];
+	out.b[1] = in.b[2];
+	out.b[2] = in.b[1];
+	out.b[3] = in.b[0];
+	
+	return out.f;
+}
+
+float	LittleFloat (float l)
+{
+	return l;
+}
+
+
+#endif

utils/xwad/goldsrc_standin.h

@@ -0,0 +1,42 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: This file provides some of the goldsrc functionality for xwad.
+//
+//=============================================================================//
+
+#ifndef GOLDSRC_STANDIN_H
+#define GOLDSRC_STANDIN_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+typedef float vec_t;
+typedef float vec3_t[3];
+
+typedef unsigned char byte;
+typedef int qboolean;
+
+
+void Msg( PRINTF_FORMAT_STRING const char *pMsg, ... );
+void Warning( PRINTF_FORMAT_STRING const char *pMsg, ... );
+void Error( PRINTF_FORMAT_STRING const char *pMsg, ... );
+
+int		LoadFile (char *filename, void **bufferptr);
+void	SaveFile (char *filename, void *buffer, int count);
+
+short	BigShort (short l);
+short	LittleShort (short l);
+int		BigLong (int l);
+int		LittleLong (int l);
+float	BigFloat (float l);
+float	LittleFloat (float l);
+
+
+FILE	*SafeOpenWrite (char *filename);
+FILE	*SafeOpenRead (char *filename);
+void	SafeRead (FILE *f, void *buffer, int count);
+void	SafeWrite (FILE *f, void *buffer, int count);
+
+
+#endif // GOLDSRC_STANDIN_H

utils/xwad/lbmlib.cpp

@@ -0,0 +1,741 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+// lbmlib.c
+
+#include <WINDOWS.H>
+#include <STDIO.H>
+#include "lbmlib.h"
+#include "goldsrc_standin.h"
+
+
+
+/*
+============================================================================
+
+						LBM STUFF
+
+============================================================================
+*/
+
+
+#define FORMID ('F'+('O'<<8)+((int)'R'<<16)+((int)'M'<<24))
+#define ILBMID ('I'+('L'<<8)+((int)'B'<<16)+((int)'M'<<24))
+#define PBMID  ('P'+('B'<<8)+((int)'M'<<16)+((int)' '<<24))
+#define BMHDID ('B'+('M'<<8)+((int)'H'<<16)+((int)'D'<<24))
+#define BODYID ('B'+('O'<<8)+((int)'D'<<16)+((int)'Y'<<24))
+#define CMAPID ('C'+('M'<<8)+((int)'A'<<16)+((int)'P'<<24))
+
+
+bmhd_t  bmhd;
+
+int    Align (int l)
+{
+	if (l&1)
+		return l+1;
+	return l;
+}
+
+
+
+/*
+================
+=
+= LBMRLEdecompress
+=
+= Source must be evenly aligned!
+=
+================
+*/
+
+byte  *LBMRLEDecompress (byte *source,byte *unpacked, int bpwidth)
+{
+	int     count;
+	byte    b,rept;
+
+	count = 0;
+
+	do
+	{
+		rept = *source++;
+
+		if (rept > 0x80)
+		{
+			rept = (rept^0xff)+2;
+			b = *source++;
+			memset(unpacked,b,rept);
+			unpacked += rept;
+		}
+		else if (rept < 0x80)
+		{
+			rept++;
+			memcpy(unpacked,source,rept);
+			unpacked += rept;
+			source += rept;
+		}
+		else
+			rept = 0;               // rept of 0x80 is NOP
+
+		count += rept;
+
+	} while (count<bpwidth);
+
+	if (count>bpwidth)
+		Error ("Decompression exceeded width!\n");
+
+
+	return source;
+}
+
+
+#define BPLANESIZE      128
+byte    bitplanes[9][BPLANESIZE];       // max size 1024 by 9 bit planes
+
+
+/*
+=================
+=
+= MungeBitPlanes8
+=
+= This destroys the bit plane data!
+=
+=================
+*/
+
+void MungeBitPlanes8 (int width, byte *dest)
+{
+	*dest=width;	// shut up the compiler warning
+	Error ("MungeBitPlanes8 not rewritten!");
+#if 0
+asm     les     di,[dest]
+asm     mov     si,-1
+asm     mov     cx,[width]
+mungebyte:
+asm     inc     si
+asm     mov     dx,8
+mungebit:
+asm     shl     [BYTE PTR bitplanes + BPLANESIZE*7 +si],1
+asm     rcl     al,1
+asm     shl     [BYTE PTR bitplanes + BPLANESIZE*6 +si],1
+asm     rcl     al,1
+asm     shl     [BYTE PTR bitplanes + BPLANESIZE*5 +si],1
+asm     rcl     al,1
+asm     shl     [BYTE PTR bitplanes + BPLANESIZE*4 +si],1
+asm     rcl     al,1
+asm     shl     [BYTE PTR bitplanes + BPLANESIZE*3 +si],1
+asm     rcl     al,1
+asm     shl     [BYTE PTR bitplanes + BPLANESIZE*2 +si],1
+asm     rcl     al,1
+asm     shl     [BYTE PTR bitplanes + BPLANESIZE*1 +si],1
+asm     rcl     al,1
+asm     shl     [BYTE PTR bitplanes + BPLANESIZE*0 +si],1
+asm     rcl     al,1
+asm     stosb
+asm     dec     cx
+asm     jz      done
+asm     dec     dx
+asm     jnz     mungebit
+asm     jmp     mungebyte
+
+done:
+#endif
+}
+
+
+void MungeBitPlanes4 (int width, byte *dest)
+{
+	*dest=width;	// shut up the compiler warning
+	Error ("MungeBitPlanes4 not rewritten!");
+#if 0
+
+asm     les     di,[dest]
+asm     mov     si,-1
+asm     mov     cx,[width]
+mungebyte:
+asm     inc     si
+asm     mov     dx,8
+mungebit:
+asm     xor     al,al
+asm     shl     [BYTE PTR bitplanes + BPLANESIZE*3 +si],1
+asm     rcl     al,1
+asm     shl     [BYTE PTR bitplanes + BPLANESIZE*2 +si],1
+asm     rcl     al,1
+asm     shl     [BYTE PTR bitplanes + BPLANESIZE*1 +si],1
+asm     rcl     al,1
+asm     shl     [BYTE PTR bitplanes + BPLANESIZE*0 +si],1
+asm     rcl     al,1
+asm     stosb
+asm     dec     cx
+asm     jz      done
+asm     dec     dx
+asm     jnz     mungebit
+asm     jmp     mungebyte
+
+done:
+#endif
+}
+
+
+void MungeBitPlanes2 (int width, byte *dest)
+{
+	*dest=width;	// shut up the compiler warning
+	Error ("MungeBitPlanes2 not rewritten!");
+#if 0
+asm     les     di,[dest]
+asm     mov     si,-1
+asm     mov     cx,[width]
+mungebyte:
+asm     inc     si
+asm     mov     dx,8
+mungebit:
+asm     xor     al,al
+asm     shl     [BYTE PTR bitplanes + BPLANESIZE*1 +si],1
+asm     rcl     al,1
+asm     shl     [BYTE PTR bitplanes + BPLANESIZE*0 +si],1
+asm     rcl     al,1
+asm     stosb
+asm     dec     cx
+asm     jz      done
+asm     dec     dx
+asm     jnz     mungebit
+asm     jmp     mungebyte
+
+done:
+#endif
+}
+
+
+void MungeBitPlanes1 (int width, byte *dest)
+{
+	*dest=width;	// shut up the compiler warning
+	Error ("MungeBitPlanes1 not rewritten!");
+#if 0
+asm     les     di,[dest]
+asm     mov     si,-1
+asm     mov     cx,[width]
+mungebyte:
+asm     inc     si
+asm     mov     dx,8
+mungebit:
+asm     xor     al,al
+asm     shl     [BYTE PTR bitplanes + BPLANESIZE*0 +si],1
+asm     rcl     al,1
+asm     stosb
+asm     dec     cx
+asm     jz      done
+asm     dec     dx
+asm     jnz     mungebit
+asm     jmp     mungebyte
+
+done:
+#endif
+}
+
+int LoadBMP (const char* szFile, BYTE** ppbBits, BYTE** ppbPalette)
+{
+	int i, rc = 0;
+	FILE *pfile = NULL;
+	BITMAPFILEHEADER bmfh;
+	BITMAPINFOHEADER bmih;
+	RGBQUAD rgrgbPalette[256];
+	ULONG cbBmpBits;
+	BYTE* pbBmpBits;
+	byte  *pb, *pbPal = NULL;
+	ULONG cbPalBytes;
+	ULONG biTrueWidth;
+
+	// Bogus parameter check
+	if (!(ppbPalette != NULL && ppbBits != NULL))
+		{ fprintf(stderr, "invalid BMP file\n"); rc = -1000; goto GetOut; }
+
+	// File exists?
+	if ((pfile = fopen(szFile, "rb")) == NULL)
+		{ fprintf(stderr, "unable to open BMP file\n"); rc = -1; goto GetOut; }
+	
+	// Read file header
+	if (fread(&bmfh, sizeof bmfh, 1/*count*/, pfile) != 1)
+		{ rc = -2; goto GetOut; }
+
+	// Bogus file header check
+	if (!(bmfh.bfReserved1 == 0 && bmfh.bfReserved2 == 0))
+		{ rc = -2000; goto GetOut; }
+
+	// Read info header
+	if (fread(&bmih, sizeof bmih, 1/*count*/, pfile) != 1)
+		{ rc = -3; goto GetOut; }
+
+	// Bogus info header check
+	if (!(bmih.biSize == sizeof bmih && bmih.biPlanes == 1))
+		{ fprintf(stderr, "invalid BMP file header\n");  rc = -3000; goto GetOut; }
+
+	// Bogus bit depth?  Only 8-bit supported.
+	if (bmih.biBitCount != 8)
+		{ fprintf(stderr, "BMP file not 8 bit\n");  rc = -4; goto GetOut; }
+	
+	// Bogus compression?  Only non-compressed supported.
+	if (bmih.biCompression != BI_RGB)
+		{ fprintf(stderr, "invalid BMP compression type\n"); rc = -5; goto GetOut; }
+
+	// Figure out how many entires are actually in the table
+	if (bmih.biClrUsed == 0)
+		{
+		bmih.biClrUsed = 256;
+		cbPalBytes = (1 << bmih.biBitCount) * sizeof( RGBQUAD );
+		}
+	else 
+		{
+		cbPalBytes = bmih.biClrUsed * sizeof( RGBQUAD );
+		}
+
+	// Read palette (bmih.biClrUsed entries)
+	if (fread(rgrgbPalette, cbPalBytes, 1/*count*/, pfile) != 1)
+		{ rc = -6; goto GetOut; }
+
+	// convert to a packed 768 byte palette
+	pbPal = (unsigned char*)malloc(768);
+	if (pbPal == NULL)
+		{ rc = -7; goto GetOut; }
+
+	pb = pbPal;
+
+	// Copy over used entries
+	for (i = 0; i < (int)bmih.biClrUsed; i++)
+	{
+		*pb++ = rgrgbPalette[i].rgbRed;
+		*pb++ = rgrgbPalette[i].rgbGreen;
+		*pb++ = rgrgbPalette[i].rgbBlue;
+	}
+
+	// Fill in unused entires will 0,0,0
+	for (i = bmih.biClrUsed; i < 256; i++) 
+	{
+		*pb++ = 0;
+		*pb++ = 0;
+		*pb++ = 0;
+	}
+
+	// Read bitmap bits (remainder of file)
+	cbBmpBits = bmfh.bfSize - ftell(pfile);
+	pb = (unsigned char*)malloc(cbBmpBits);
+	if (fread(pb, cbBmpBits, 1/*count*/, pfile) != 1)
+		{ rc = -7; goto GetOut; }
+
+	pbBmpBits = (unsigned char*)malloc(cbBmpBits);
+
+	// data is actually stored with the width being rounded up to a multiple of 4
+	biTrueWidth = (bmih.biWidth + 3) & ~3;
+	
+	// reverse the order of the data.
+	pb += (bmih.biHeight - 1) * biTrueWidth;
+	for(i = 0; i < bmih.biHeight; i++)
+	{
+		memmove(&pbBmpBits[biTrueWidth * i], pb, biTrueWidth);
+		pb -= biTrueWidth;
+	}
+
+	pb += biTrueWidth;
+	free(pb);
+
+	bmhd.w = (WORD)bmih.biWidth;
+	bmhd.h = (WORD)bmih.biHeight;
+	// Set output parameters
+	*ppbPalette = pbPal;
+	*ppbBits = pbBmpBits;
+
+GetOut:
+	if (pfile) 
+		fclose(pfile);
+
+	return rc;
+}
+
+
+int WriteBMPfile (char *szFile, byte *pbBits, int width, int height, byte *pbPalette)
+{
+	int i, rc = 0;
+	FILE *pfile = NULL;
+	BITMAPFILEHEADER bmfh;
+	BITMAPINFOHEADER bmih;
+	RGBQUAD rgrgbPalette[256];
+	ULONG cbBmpBits;
+	BYTE* pbBmpBits;
+	byte  *pb, *pbPal = NULL;
+	ULONG cbPalBytes;
+	ULONG biTrueWidth;
+
+	// Bogus parameter check
+	if (!(pbPalette != NULL && pbBits != NULL))
+		{ rc = -1000; goto GetOut; }
+
+	// File exists?
+	if ((pfile = fopen(szFile, "wb")) == NULL)
+		{ rc = -1; goto GetOut; }
+
+	biTrueWidth = ((width + 3) & ~3);
+	cbBmpBits = biTrueWidth * height;
+	cbPalBytes = 256 * sizeof( RGBQUAD );
+
+	// Bogus file header check
+	bmfh.bfType = MAKEWORD( 'B', 'M' );
+	bmfh.bfSize = sizeof bmfh + sizeof bmih + cbBmpBits + cbPalBytes;
+	bmfh.bfReserved1 = 0;
+	bmfh.bfReserved2 = 0;
+	bmfh.bfOffBits = sizeof bmfh + sizeof bmih + cbPalBytes;
+
+	// Write file header
+	if (fwrite(&bmfh, sizeof bmfh, 1/*count*/, pfile) != 1)
+		{ rc = -2; goto GetOut; }
+
+	// Size of structure
+	bmih.biSize = sizeof bmih;
+	// Width
+	bmih.biWidth = biTrueWidth;
+	// Height
+	bmih.biHeight = height;
+	// Only 1 plane 
+	bmih.biPlanes = 1;
+	// Only 8-bit supported.
+	bmih.biBitCount = 8;
+	// Only non-compressed supported.
+	bmih.biCompression = BI_RGB;
+	bmih.biSizeImage = 0;
+
+	// huh?
+	bmih.biXPelsPerMeter = 0;
+	bmih.biYPelsPerMeter = 0;
+
+	// Always full palette
+	bmih.biClrUsed = 256;
+	bmih.biClrImportant = 0;
+	
+	// Write info header
+	if (fwrite(&bmih, sizeof bmih, 1/*count*/, pfile) != 1)
+		{ rc = -3; goto GetOut; }
+	
+
+	// convert to expanded palette
+	pb = pbPalette;
+
+	// Copy over used entries
+	for (i = 0; i < (int)bmih.biClrUsed; i++)
+	{
+		rgrgbPalette[i].rgbRed   = *pb++;
+		rgrgbPalette[i].rgbGreen = *pb++;
+		rgrgbPalette[i].rgbBlue  = *pb++;
+        rgrgbPalette[i].rgbReserved = 0;
+	}
+
+	// Write palette (bmih.biClrUsed entries)
+	cbPalBytes = bmih.biClrUsed * sizeof( RGBQUAD );
+	if (fwrite(rgrgbPalette, cbPalBytes, 1/*count*/, pfile) != 1)
+		{ rc = -6; goto GetOut; }
+
+
+	pbBmpBits = (unsigned char*)malloc(cbBmpBits);
+
+	pb = pbBits;
+	// reverse the order of the data.
+	pb += (height - 1) * width;
+	for(i = 0; i < bmih.biHeight; i++)
+	{
+		memmove(&pbBmpBits[biTrueWidth * i], pb, width);
+		pb -= width;
+	}
+
+	// Write bitmap bits (remainder of file)
+	if (fwrite(pbBmpBits, cbBmpBits, 1/*count*/, pfile) != 1)
+		{ rc = -7; goto GetOut; }
+
+	free(pbBmpBits);
+
+GetOut:
+	if (pfile) 
+		fclose(pfile);
+
+	return rc;
+}
+
+/*
+=================
+=
+= LoadLBM
+=
+=================
+*/
+
+void LoadLBM (char *filename, byte **picture, byte **palette)
+{
+	byte    *LBMbuffer, *picbuffer, *cmapbuffer;
+	int             y,p,planes;
+	byte    *LBM_P, *LBMEND_P;
+	byte    *pic_p;
+	byte    *body_p;
+	unsigned        rowsize;
+
+	int    formtype,formlength;
+	int    chunktype,chunklength;
+	void    (*mungecall) (int, byte *);
+
+// qiet compiler warnings
+	picbuffer = NULL;
+	cmapbuffer = NULL;
+	mungecall = NULL;
+
+//
+// load the LBM
+//
+	LoadFile (filename, (void **)&LBMbuffer);
+
+//
+// parse the LBM header
+//
+	LBM_P = LBMbuffer;
+	if ( *(int *)LBMbuffer != LittleLong(FORMID) )
+	   Error ("No FORM ID at start of file!\n");
+
+	LBM_P += 4;
+	formlength = BigLong( *(int *)LBM_P );
+	LBM_P += 4;
+	LBMEND_P = LBM_P + Align(formlength);
+
+	formtype = LittleLong(*(int *)LBM_P);
+
+	if (formtype != ILBMID && formtype != PBMID)
+		Error ("Unrecognized form type: %c%c%c%c\n", formtype&0xff
+		,(formtype>>8)&0xff,(formtype>>16)&0xff,(formtype>>24)&0xff);
+
+	LBM_P += 4;
+
+//
+// parse chunks
+//
+
+	while (LBM_P < LBMEND_P)
+	{
+		chunktype = LBM_P[0] + (LBM_P[1]<<8) + (LBM_P[2]<<16) + (LBM_P[3]<<24);
+		LBM_P += 4;
+		chunklength = LBM_P[3] + (LBM_P[2]<<8) + (LBM_P[1]<<16) + (LBM_P[0]<<24);
+		LBM_P += 4;
+
+		switch ( chunktype )
+		{
+		case BMHDID:
+			memcpy (&bmhd,LBM_P,sizeof(bmhd));
+			bmhd.w = BigShort(bmhd.w);
+			bmhd.h = BigShort(bmhd.h);
+			bmhd.x = BigShort(bmhd.x);
+			bmhd.y = BigShort(bmhd.y);
+			bmhd.pageWidth = BigShort(bmhd.pageWidth);
+			bmhd.pageHeight = BigShort(bmhd.pageHeight);
+			break;
+
+		case CMAPID:
+			cmapbuffer = (unsigned char*)malloc (768);
+			memset (cmapbuffer, 0, 768);
+			memcpy (cmapbuffer, LBM_P, chunklength);
+			break;
+
+		case BODYID:
+			body_p = LBM_P;
+
+			pic_p = picbuffer = (unsigned char*)malloc (bmhd.w*bmhd.h);
+			if (formtype == PBMID)
+			{
+			//
+			// unpack PBM
+			//
+				for (y=0 ; y<bmhd.h ; y++, pic_p += bmhd.w)
+				{
+					if (bmhd.compression == cm_rle1)
+						body_p = LBMRLEDecompress ((byte *)body_p
+						, pic_p , bmhd.w);
+					else if (bmhd.compression == cm_none)
+					{
+						memcpy (pic_p,body_p,bmhd.w);
+						body_p += Align(bmhd.w);
+					}
+				}
+
+			}
+			else
+			{
+			//
+			// unpack ILBM
+			//
+				planes = bmhd.nPlanes;
+				if (bmhd.masking == ms_mask)
+					planes++;
+				rowsize = (bmhd.w+15)/16 * 2;
+				switch (bmhd.nPlanes)
+				{
+				case 1:
+					mungecall = MungeBitPlanes1;
+					break;
+				case 2:
+					mungecall = MungeBitPlanes2;
+					break;
+				case 4:
+					mungecall = MungeBitPlanes4;
+					break;
+				case 8:
+					mungecall = MungeBitPlanes8;
+					break;
+				default:
+					Error ("Can't munge %i bit planes!\n",bmhd.nPlanes);
+				}
+
+				for (y=0 ; y<bmhd.h ; y++, pic_p += bmhd.w)
+				{
+					for (p=0 ; p<planes ; p++)
+						if (bmhd.compression == cm_rle1)
+							body_p = LBMRLEDecompress ((byte *)body_p
+							, bitplanes[p] , rowsize);
+						else if (bmhd.compression == cm_none)
+						{
+							memcpy (bitplanes[p],body_p,rowsize);
+							body_p += rowsize;
+						}
+
+					mungecall (bmhd.w , pic_p);
+				}
+			}
+			break;
+		}
+
+		LBM_P += Align(chunklength);
+	}
+
+	free (LBMbuffer);
+
+	*picture = picbuffer;
+	*palette = cmapbuffer;
+}
+
+
+/*
+============================================================================
+
+							WRITE LBM
+
+============================================================================
+*/
+
+/*
+==============
+=
+= WriteLBMfile
+=
+==============
+*/
+
+void WriteLBMfile (char *filename, byte *data, int width, int height, byte *palette)
+{
+	byte    *lbm, *lbmptr;
+	int    *formlength, *bmhdlength, *cmaplength, *bodylength;
+	int    length;
+	bmhd_t  basebmhd;
+
+	lbm = lbmptr = (unsigned char*)malloc (width*height+1000);
+
+//
+// start FORM
+//
+	*lbmptr++ = 'F';
+	*lbmptr++ = 'O';
+	*lbmptr++ = 'R';
+	*lbmptr++ = 'M';
+
+	formlength = (int*)lbmptr;
+	lbmptr+=4;                      // leave space for length
+
+	*lbmptr++ = 'P';
+	*lbmptr++ = 'B';
+	*lbmptr++ = 'M';
+	*lbmptr++ = ' ';
+
+//
+// write BMHD
+//
+	*lbmptr++ = 'B';
+	*lbmptr++ = 'M';
+	*lbmptr++ = 'H';
+	*lbmptr++ = 'D';
+
+	bmhdlength = (int *)lbmptr;
+	lbmptr+=4;                      // leave space for length
+
+	memset (&basebmhd,0,sizeof(basebmhd));
+	basebmhd.w = BigShort((short)width);
+	basebmhd.h = BigShort((short)height);
+	basebmhd.nPlanes = (BYTE)BigShort(8);
+	basebmhd.xAspect = (BYTE)BigShort(5);
+	basebmhd.yAspect = (BYTE)BigShort(6);
+	basebmhd.pageWidth = BigShort((short)width);
+	basebmhd.pageHeight = BigShort((short)height);
+
+	memcpy (lbmptr,&basebmhd,sizeof(basebmhd));
+	lbmptr += sizeof(basebmhd);
+
+	length = lbmptr-(byte *)bmhdlength-4;
+	*bmhdlength = BigLong(length);
+	if (length&1)
+		*lbmptr++ = 0;          // pad chunk to even offset
+
+//
+// write CMAP
+//
+	*lbmptr++ = 'C';
+	*lbmptr++ = 'M';
+	*lbmptr++ = 'A';
+	*lbmptr++ = 'P';
+
+	cmaplength = (int *)lbmptr;
+	lbmptr+=4;                      // leave space for length
+
+	memcpy (lbmptr,palette,768);
+	lbmptr += 768;
+
+	length = lbmptr-(byte *)cmaplength-4;
+	*cmaplength = BigLong(length);
+	if (length&1)
+		*lbmptr++ = 0;          // pad chunk to even offset
+
+//
+// write BODY
+//
+	*lbmptr++ = 'B';
+	*lbmptr++ = 'O';
+	*lbmptr++ = 'D';
+	*lbmptr++ = 'Y';
+
+	bodylength = (int *)lbmptr;
+	lbmptr+=4;                      // leave space for length
+
+	memcpy (lbmptr,data,width*height);
+	lbmptr += width*height;
+
+	length = lbmptr-(byte *)bodylength-4;
+	*bodylength = BigLong(length);
+	if (length&1)
+		*lbmptr++ = 0;          // pad chunk to even offset
+
+//
+// done
+//
+	length = lbmptr-(byte *)formlength-4;
+	*formlength = BigLong(length);
+	if (length&1)
+		*lbmptr++ = 0;          // pad chunk to even offset
+
+//
+// write output file
+//
+	SaveFile (filename, lbm, lbmptr-lbm);
+	free (lbm);
+}
+

utils/xwad/lbmlib.h

@@ -0,0 +1,55 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+// lbmlib.h
+
+typedef unsigned char	UBYTE;
+
+#ifndef _WINDOWS_
+typedef short			WORD;
+#endif
+
+typedef unsigned short	UWORD;
+typedef long			LONG;
+
+typedef enum
+{
+	ms_none,
+	ms_mask,
+	ms_transcolor,
+	ms_lasso
+} mask_t;
+
+typedef enum
+{
+	cm_none,
+	cm_rle1
+} compress_t;
+
+typedef struct
+{
+	UWORD		w,h;
+	WORD		x,y;
+	UBYTE		nPlanes;
+	UBYTE		masking;
+	UBYTE		compression;
+	UBYTE		pad1;
+	UWORD		transparentColor;
+	UBYTE		xAspect,yAspect;
+	WORD		pageWidth,pageHeight;
+} bmhd_t;
+
+extern	bmhd_t	bmhd;						// will be in native byte order
+
+
+void LoadLBM (char *filename, byte **picture, byte **palette);
+int	LoadBMP (const char* szFile, byte** ppbBits, byte** ppbPalette);
+void WriteLBMfile (char *filename, byte *data, int width, int height
+	, byte *palette);
+int WriteBMPfile (char *szFile, byte *pbBits, int width, int height, byte *pbPalette);
+

utils/xwad/wadlib.cpp

@@ -0,0 +1,336 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+// wad2lib.c
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+//#include <sys/file.h>
+#include <stdarg.h>
+
+#ifdef NeXT
+#include <libc.h>
+#endif
+#include "goldsrc_standin.h"
+#include "wadlib.h"
+
+/*
+============================================================================
+
+							WAD READING
+
+============================================================================
+*/
+
+
+lumpinfo_t		*lumpinfo;		// location of each lump on disk
+int				numlumps;
+
+wadinfo_t		header;
+FILE			*wadhandle;
+
+
+/*
+====================
+W_OpenWad
+====================
+*/
+void W_OpenWad (const char *filename)
+{
+	lumpinfo_t		*lump_p;
+	int	i;
+	int				length;
+
+//
+// open the file and add to directory
+//	
+	wadhandle = SafeOpenRead ((char*)filename);
+	SafeRead (wadhandle, &header, sizeof(header));
+
+	if (strncmp(header.identification,"WAD2",4) &&
+		strncmp(header.identification, "WAD3", 4))
+		Error ("Wad file %s doesn't have WAD2/WAD3 id\n",filename);
+		
+	header.numlumps = LittleLong(header.numlumps);
+	header.infotableofs = LittleLong(header.infotableofs);
+
+	numlumps = header.numlumps;
+
+	length = numlumps*sizeof(lumpinfo_t);
+	lumpinfo = (lumpinfo_t*)malloc (length);
+	lump_p = lumpinfo;
+	
+	fseek (wadhandle, header.infotableofs, SEEK_SET);
+	SafeRead (wadhandle, lumpinfo, length);
+
+//
+// Fill in lumpinfo
+//
+	
+	for (i=0 ; i<numlumps ; i++,lump_p++)
+	{
+		lump_p->filepos = LittleLong(lump_p->filepos);
+		lump_p->size = LittleLong(lump_p->size);
+	}
+}
+
+
+void CleanupName (char *in, char *out)
+{
+	int		i;
+	
+	for (i=0 ; i<sizeof( ((lumpinfo_t *)0)->name ) ; i++ )
+	{
+		if (!in[i])
+			break;
+			
+		out[i] = toupper(in[i]);
+	}
+	
+	for ( ; i<sizeof( ((lumpinfo_t *)0)->name ); i++ )
+		out[i] = 0;
+}
+
+
+/*
+====================
+W_CheckNumForName
+
+Returns -1 if name not found
+====================
+*/
+int	W_CheckNumForName (char *name)
+{
+	char	cleanname[16];
+	int		v1,v2, v3, v4;
+	int		i;
+	lumpinfo_t	*lump_p;
+	
+	CleanupName (name, cleanname);
+	
+// make the name into four integers for easy compares
+
+	v1 = *(int *)cleanname;
+	v2 = *(int *)&cleanname[4];
+	v3 = *(int *)&cleanname[8];
+	v4 = *(int *)&cleanname[12];
+
+// find it
+
+	lump_p = lumpinfo;
+	for (i=0 ; i<numlumps ; i++, lump_p++)
+	{
+		if ( *(int *)lump_p->name == v1
+		&& *(int *)&lump_p->name[4] == v2
+		&& *(int *)&lump_p->name[8] == v3
+		&& *(int *)&lump_p->name[12] == v4)
+			return i;
+	}
+
+	return -1;
+}
+
+
+/*
+====================
+W_GetNumForName
+
+Calls W_CheckNumForName, but bombs out if not found
+====================
+*/
+int	W_GetNumForName (char *name)
+{
+	int	i;
+
+	i = W_CheckNumForName (name);
+	if (i != -1)
+		return i;
+
+	Error ("W_GetNumForName: %s not found!",name);
+	return -1;
+}
+
+
+/*
+====================
+W_LumpLength
+
+Returns the buffer size needed to load the given lump
+====================
+*/
+int W_LumpLength (int lump)
+{
+	if (lump >= numlumps)
+		Error ("W_LumpLength: %i >= numlumps",lump);
+	return lumpinfo[lump].size;
+}
+
+
+/*
+====================
+W_ReadLumpNum
+
+Loads the lump into the given buffer, which must be >= W_LumpLength()
+====================
+*/
+void W_ReadLumpNum (int lump, void *dest)
+{
+	lumpinfo_t	*l;
+	
+	if (lump >= numlumps)
+		Error ("W_ReadLump: %i >= numlumps",lump);
+	l = lumpinfo+lump;
+	
+	fseek (wadhandle, l->filepos, SEEK_SET);
+	SafeRead (wadhandle, dest, l->size);
+}
+
+
+
+/*
+====================
+W_LoadLumpNum
+====================
+*/
+void	*W_LoadLumpNum (int lump)
+{
+	void	*buf;
+	
+	if ((unsigned)lump >= (unsigned)numlumps)
+		Error ("W_CacheLumpNum: %i >= numlumps",lump);
+		
+	buf = malloc (W_LumpLength (lump));
+	W_ReadLumpNum (lump, buf);
+	
+	return buf;
+}
+
+
+/*
+====================
+W_LoadLumpName
+====================
+*/
+void	*W_LoadLumpName (char *name)
+{
+	return W_LoadLumpNum (W_GetNumForName(name));
+}
+
+
+/*
+===============================================================================
+
+						WAD CREATION
+
+===============================================================================
+*/
+
+FILE		*outwad;
+
+lumpinfo_t	outinfo[4096];
+int			outlumps;
+
+short	(*wadshort) (short l);
+int		(*wadlong) (int l);
+
+/*
+===============
+NewWad
+===============
+*/
+
+void NewWad (char *pathname, qboolean bigendien)
+{
+	outwad = SafeOpenWrite (pathname);
+	fseek (outwad, sizeof(wadinfo_t), SEEK_SET);
+	memset (outinfo, 0, sizeof(outinfo));
+	
+	if (bigendien)
+	{
+		wadshort = BigShort;
+		wadlong = BigLong;
+	}
+	else
+	{
+		wadshort = LittleShort;
+		wadlong = LittleLong;
+	}
+	
+	outlumps = 0;
+}
+
+
+/*
+===============
+AddLump
+===============
+*/
+
+void	AddLump (char *name, void *buffer, int length, int type, int compress)
+{
+	lumpinfo_t	*info;
+	int			ofs;
+	
+	info = &outinfo[outlumps];
+	outlumps++;
+
+	memset (info,0,sizeof(info));
+	
+	strcpy (info->name, name);
+	strupr (info->name);
+	
+	ofs = ftell(outwad);
+	info->filepos = wadlong(ofs);
+	info->size = info->disksize = wadlong(length);
+	info->type = type;
+	info->compression = compress;
+	
+// FIXME: do compression
+
+	SafeWrite (outwad, buffer, length);
+}
+
+
+/*
+===============
+WriteWad
+===============
+*/
+
+void WriteWad (int wad3)
+{
+	wadinfo_t	header;
+	int			ofs;
+	
+// write the lumpingo
+	ofs = ftell(outwad);
+
+	SafeWrite (outwad, outinfo, outlumps*sizeof(lumpinfo_t) );
+		
+// write the header
+
+// a program will be able to tell the ednieness of a wad by the id
+	header.identification[0] = 'W';
+	header.identification[1] = 'A';
+	header.identification[2] = 'D';
+	header.identification[3] = wad3 ? '3' : '2';
+	
+	header.numlumps = wadlong(outlumps);
+	header.infotableofs = wadlong(ofs);
+		
+	fseek (outwad, 0, SEEK_SET);
+	SafeWrite (outwad, &header, sizeof(header));
+	fclose (outwad);
+}
+
+

utils/xwad/wadlib.h

@@ -0,0 +1,61 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+// wadlib.h
+
+//
+// wad reading
+//
+
+#define	CMP_NONE		0
+#define	CMP_LZSS		1
+
+#define	TYP_NONE		0
+#define	TYP_LABEL		1
+#define	TYP_LUMPY		64				// 64 + grab command number
+
+typedef struct
+{
+	char		identification[4];		// should be WAD2 or 2DAW
+	int			numlumps;
+	int			infotableofs;
+} wadinfo_t;
+
+
+typedef struct
+{
+	int			filepos;
+	int			disksize;
+	int			size;					// uncompressed
+	char		type;
+	char		compression;
+	char		pad1, pad2;
+	char		name[16];				// must be null terminated
+} lumpinfo_t;
+
+extern	lumpinfo_t		*lumpinfo;		// location of each lump on disk
+extern	int				numlumps;
+extern	wadinfo_t		header;
+
+void	W_OpenWad (const char *filename);
+int		W_CheckNumForName (char *name);
+int		W_GetNumForName (char *name);
+int		W_LumpLength (int lump);
+void	W_ReadLumpNum (int lump, void *dest);
+void	*W_LoadLumpNum (int lump);
+void	*W_LoadLumpName (char *name);
+
+void CleanupName (char *in, char *out);
+
+//
+// wad creation
+//
+void	NewWad (char *pathname, qboolean bigendien);
+void	AddLump (char *name, void *buffer, int length, int type, int compress);
+void	WriteWad (int wad3);
+

utils/xwad/xwad.vcproj

@@ -0,0 +1,185 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="xwad"
+	ProjectGUID="{B850012C-98A2-42F7-B023-9F65C448D938}"
+	SccProjectName=""
+	SccAuxPath=""
+	SccLocalPath=""
+	SccProvider="">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory=".\Debug"
+			IntermediateDirectory=".\Debug"
+			ConfigurationType="1"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="5"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderFile=".\Debug/xwad.pch"
+				AssemblerListingLocation=".\Debug/"
+				ObjectFile=".\Debug/"
+				ProgramDataBaseFileName=".\Debug/"
+				WarningLevel="3"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"
+				CommandLine="if exist ..\..\..\game\bin\&quot;$(TargetName)&quot;.exe attrib -r ..\..\..\game\bin\&quot;$(TargetName)&quot;.exe
+copy &quot;$(TargetPath)&quot; ..\..\..\game\bin\&quot;$(TargetName)&quot;.exe
+if exist ..\..\..\game\bin\&quot;$(TargetName)&quot;.pdb attrib -r ..\..\..\game\bin\&quot;$(TargetName)&quot;.pdb
+copy &quot;$(TargetPath)&quot; ..\..\..\game\bin\&quot;$(TargetName)&quot;.pdb"
+				Outputs="..\..\..\game\bin\xwad.exe;..\..\..\game\bin\xwad.pdb"/>
+			<Tool
+				Name="VCLinkerTool"
+				OutputFile=".\Debug/xwad.exe"
+				LinkIncremental="2"
+				SuppressStartupBanner="TRUE"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\Debug/xwad.pdb"
+				SubSystem="1"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"
+				TypeLibraryName=".\Debug/xwad.tlb"
+				HeaderFileName=""/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_DEBUG"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory=".\Release"
+			IntermediateDirectory=".\Release"
+			ConfigurationType="1"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				InlineFunctionExpansion="1"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				StringPooling="TRUE"
+				RuntimeLibrary="4"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderFile=".\Release/xwad.pch"
+				AssemblerListingLocation=".\Release/"
+				ObjectFile=".\Release/"
+				ProgramDataBaseFileName=".\Release/"
+				WarningLevel="3"
+				SuppressStartupBanner="TRUE"/>
+			<Tool
+				Name="VCCustomBuildTool"
+				CommandLine="if exist ..\..\..\game\bin\&quot;$(TargetName)&quot;.exe attrib -r ..\..\..\game\bin\&quot;$(TargetName)&quot;.exe
+copy &quot;$(TargetPath)&quot; ..\..\..\game\bin\&quot;$(TargetName)&quot;.exe
+if exist ..\..\..\game\bin\&quot;$(TargetName)&quot;.pdb attrib -r ..\..\..\game\bin\&quot;$(TargetName)&quot;.pdb
+copy &quot;$(TargetPath)&quot; ..\..\..\game\bin\&quot;$(TargetName)&quot;.pdb"
+				Outputs="..\..\..\game\bin\xwad.exe;..\..\..\game\bin\xwad.pdb"/>
+			<Tool
+				Name="VCLinkerTool"
+				OutputFile=".\Release/xwad.exe"
+				LinkIncremental="1"
+				SuppressStartupBanner="TRUE"
+				ProgramDatabaseFile=".\Release/xwad.pdb"
+				SubSystem="1"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"
+				TypeLibraryName=".\Release/xwad.tlb"
+				HeaderFileName=""/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDEBUG"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat">
+			<File
+				RelativePath="goldsrc_bspfile.h">
+			</File>
+			<File
+				RelativePath="goldsrc_standin.cpp">
+			</File>
+			<File
+				RelativePath="goldsrc_standin.h">
+			</File>
+			<File
+				RelativePath="lbmlib.cpp">
+			</File>
+			<File
+				RelativePath="lbmlib.h">
+			</File>
+			<File
+				RelativePath="wadlib.cpp">
+			</File>
+			<File
+				RelativePath="wadlib.h">
+			</File>
+			<File
+				RelativePath="xwad.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl">
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe">
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>