From f511e292786a0cc755dd6a48f590d44e99c875d9 Mon Sep 17 00:00:00 2001
From: Christoph Oelckers <coelckers@zdoom.fake>
Date: Sun, 9 Jan 2011 12:07:19 +0000
Subject: [PATCH] - sync 3D floor branch with trunk.

SVN r3094 (3dfloors2)
---
 src/CMakeLists.txt                          |    1 +
 src/asm_ia32/a.asm                          |  263 +++-
 src/asm_ia32/tmap.asm                       |   42 +-
 src/c_cmds.cpp                              |   48 +-
 src/c_cvars.cpp                             |   18 +-
 src/c_dispatch.h                            |    1 +
 src/compatibility.cpp                       |    7 -
 src/d_iwad.cpp                              |    1 -
 src/d_net.cpp                               |   32 +-
 src/d_player.h                              |    1 +
 src/d_protocol.h                            |    1 +
 src/g_game.cpp                              |   26 +-
 src/g_hexen/a_flechette.cpp                 |   51 +-
 src/g_shared/a_artifacts.cpp                |    2 -
 src/g_shared/sbarinfo.cpp                   |    2 +-
 src/g_shared/sbarinfo_commands.cpp          |   57 +-
 src/gi.h                                    |    1 -
 src/intermission/intermission_parse.cpp     |    3 +-
 src/m_fixed.h                               |   32 +
 src/memarena.cpp                            |  376 ++++++
 src/memarena.h                              |   83 ++
 src/menu/playermenu.cpp                     |    2 +-
 src/namedef.h                               |    1 +
 src/p_acs.cpp                               |    3 +
 src/p_ceiling.cpp                           |  523 +++----
 src/p_doors.cpp                             |  119 +-
 src/p_glnodes.cpp                           |    1 +
 src/p_mobj.cpp                              |    1 -
 src/p_setup.cpp                             |   26 +-
 src/p_spec.cpp                              |   78 --
 src/p_spec.h                                |    7 +-
 src/p_user.cpp                              |    3 +-
 src/r_blend.h                               |    4 +
 src/r_data.cpp                              |  304 ++++-
 src/r_data.h                                |    2 +
 src/r_defs.h                                |   95 +-
 src/r_draw.cpp                              |  140 +-
 src/r_draw.h                                |    7 +-
 src/r_drawt.cpp                             |   60 +-
 src/r_main.cpp                              |   27 +-
 src/r_main.h                                |    3 +-
 src/r_plane.cpp                             |    2 +-
 src/r_things.cpp                            | 1345 +++++++++++++++++--
 src/r_things.h                              |    8 +
 src/resourcefiles/file_wad.cpp              |    1 +
 src/resourcefiles/resourcefile.cpp          |    3 +-
 src/sdl/crashcatcher.c                      |  419 +++---
 src/sdl/i_main.cpp                          |   17 +-
 src/sdl/i_system.cpp                        |   51 +
 src/sound/fmodsound.cpp                     |    2 +-
 src/tables.h                                |    2 +-
 src/textures/buildtexture.cpp               |    2 +
 src/thingdef/thingdef_properties.cpp        |    9 +
 src/v_video.cpp                             |   56 +-
 src/v_video.h                               |    5 +-
 src/version.h                               |    4 +-
 src/w_wad.h                                 |    1 +
 src/win32/fb_d3d9.cpp                       |    8 +
 wadsrc/static/actors/hexen/clericplayer.txt |    1 +
 wadsrc/static/actors/hexen/mageplayer.txt   |    1 +
 wadsrc/static/actors/shared/player.txt      |    1 +
 wadsrc/static/iwadinfo.txt                  |    1 -
 wadsrc/static/menudef.txt                   |    9 +-
 wadsrc/static/sbarinfo/hexen.txt            |   91 +-
 zdoom.vcproj                                |    8 +
 65 files changed, 3577 insertions(+), 924 deletions(-)
 create mode 100644 src/memarena.cpp
 create mode 100644 src/memarena.h

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 3bfa9d136e..940e375eed 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -658,6 +658,7 @@ add_executable( zdoom WIN32
 	m_misc.cpp
 	m_png.cpp
 	m_random.cpp
+	memarena.cpp
 	md5.cpp
 	name.cpp
 	nodebuild.cpp
diff --git a/src/asm_ia32/a.asm b/src/asm_ia32/a.asm
index d68fba116f..eaf7474550 100644
--- a/src/asm_ia32/a.asm
+++ b/src/asm_ia32/a.asm
@@ -28,6 +28,9 @@
 %define setupmvlineasm		_setupmvlineasm
 %define mvlineasm1		_mvlineasm1
 %define mvlineasm4		_mvlineasm4
+
+%define R_SetupDrawSlab	_R_SetupDrawSlab
+%define R_DrawSlab		_R_DrawSlab
 %endif
 
 EXTERN ylookup ; near
@@ -44,9 +47,6 @@ EXTERN dc_dest
 EXTERN dc_source
 EXTERN dc_texturefrac
 
-mvlineasm4_counter:
-	dd 0
-
 	SECTION .text
 
 ALIGN 16
@@ -59,8 +59,45 @@ setvlinebpl_:
 	mov [fixchain2ma+2], eax
 	mov [fixchain2mb+2], eax
 	selfmod fixchain1a, fixchain2mb+6
+
+setdrawslabbpl:
+	mov dword [voxbpl1+2], eax
+	mov dword [voxbpl2+2], eax
+	mov dword [voxbpl3+2], eax
+	mov dword [voxbpl4+2], eax
+	mov dword [voxbpl5+2], eax
+	mov dword [voxbpl6+2], eax
+	mov dword [voxbpl7+2], eax
+	mov dword [voxbpl8+2], eax
+	selfmod voxbpl1, voxpl8+6
 	ret
 
+	SECTION .data
+	
+lastslabcolormap:
+	dd 4
+	
+	SECTION .text
+
+GLOBAL R_SetupDrawSlab
+GLOBAL @R_SetupDrawSlab@4
+R_SetupDrawSlab:
+	mov ecx, [esp+4]
+@R_SetupDrawSlab@4:
+	cmp [lastslabcolormap], ecx
+	je .done
+	mov [lastslabcolormap], ecx
+	mov dword [voxpal1+2], ecx
+	mov dword [voxpal2+2], ecx
+	mov dword [voxpal3+2], ecx
+	mov dword [voxpal4+2], ecx
+	mov dword [voxpal5+2], ecx
+	mov dword [voxpal6+2], ecx
+	mov dword [voxpal7+2], ecx
+	mov dword [voxpal8+2], ecx
+.done ret
+
+
 ; pass it log2(texheight)
 
 ALIGN 16
@@ -549,6 +586,226 @@ mvcase0:	jmp beginmvlineasm4
 
 align 16
 
+
+;*************************************************************************
+;***************************** Voxel Slabs *******************************
+;*************************************************************************
+
+GLOBAL R_DrawSlab
+R_DrawSlab:
+	push ebx
+	push ebp
+	push esi
+	push edi
+	
+	mov eax, [esp+5*4+0]
+	mov ebx, [esp+5*4+4]
+	mov ecx, [esp+5*4+8]
+	mov edx, [esp+5*4+12]
+	mov esi, [esp+5*4+16]
+	mov edi, [esp+5*4+20]
+	
+	cmp eax, 2
+	je voxbegdraw2
+	ja voxskip2
+	xor eax, eax
+voxbegdraw1:
+	mov ebp, ebx
+	shr ebp, 16
+	add ebx, edx
+	dec ecx
+	mov al, byte [esi+ebp]
+voxpal1: mov al, byte [eax+88888888h]
+	mov byte [edi], al
+voxbpl1: lea edi, [edi+88888888h]
+	jnz voxbegdraw1
+	jmp voxskipslab5
+
+voxbegdraw2:
+	mov ebp, ebx
+	shr ebp, 16
+	add ebx, edx
+	xor eax, eax
+	dec ecx
+	mov al, byte [esi+ebp]
+voxpal2: mov al, byte [eax+88888888h]
+	mov ah, al
+	mov word [edi], ax
+voxbpl2: lea edi, [edi+88888888h]
+	jnz voxbegdraw2
+	jmp voxskipslab5
+
+voxskip2:
+	cmp eax, 4
+	jne voxskip4
+	xor eax, eax
+voxbegdraw4:
+	mov ebp, ebx
+	add ebx, edx
+	shr ebp, 16
+	xor eax, eax
+	mov al, byte [esi+ebp]
+voxpal3: mov al, byte [eax+88888888h]
+	mov ah, al
+	shl eax, 8
+	mov al, ah
+	shl eax, 8
+	mov al, ah
+	mov dword [edi], eax
+voxbpl3: add edi, 88888888h
+	dec ecx
+	jnz voxbegdraw4
+	jmp voxskipslab5
+
+voxskip4:
+	add eax, edi
+
+	test edi, 1
+	jz voxskipslab1
+	cmp edi, eax
+	je voxskipslab1
+
+	push eax
+	push ebx
+	push ecx
+	push edi
+voxbegslab1:
+	mov ebp, ebx
+	add ebx, edx
+	shr ebp, 16
+	xor eax, eax
+	mov al, byte [esi+ebp]
+voxpal4: mov al, byte [eax+88888888h]
+	mov byte [edi], al
+voxbpl4: add edi, 88888888h
+	dec ecx
+	jnz voxbegslab1
+	pop edi
+	pop ecx
+	pop ebx
+	pop eax
+	inc edi
+
+voxskipslab1:
+	push eax
+	test edi, 2
+	jz voxskipslab2
+	dec eax
+	cmp edi, eax
+	jge voxskipslab2
+
+	push ebx
+	push ecx
+	push edi
+voxbegslab2:
+	mov ebp, ebx
+	add ebx, edx
+	shr ebp, 16
+	xor eax, eax
+	mov al, byte [esi+ebp]
+voxpal5: mov al, byte [eax+88888888h]
+	mov ah, al
+	mov word [edi], ax
+voxbpl5: add edi, 88888888h
+	dec ecx
+	jnz voxbegslab2
+	pop edi
+	pop ecx
+	pop ebx
+	add edi, 2
+
+voxskipslab2:
+	mov eax, [esp]
+
+	sub eax, 3
+	cmp edi, eax
+	jge voxskipslab3
+
+voxprebegslab3:
+	push ebx
+	push ecx
+	push edi
+voxbegslab3:
+	mov ebp, ebx
+	add ebx, edx
+	shr ebp, 16
+	xor eax, eax
+	mov al, byte [esi+ebp]
+voxpal6: mov al, byte [eax+88888888h]
+	mov ah, al
+	shl eax, 8
+	mov al, ah
+	shl eax, 8
+	mov al, ah
+	mov dword [edi], eax
+voxbpl6: add edi, 88888888h
+	dec ecx
+	jnz voxbegslab3
+	pop edi
+	pop ecx
+	pop ebx
+	add edi, 4
+
+	mov eax, [esp]
+
+	sub eax, 3
+	cmp edi, eax
+	jl voxprebegslab3
+
+voxskipslab3:
+	mov eax, [esp]
+
+	dec eax
+	cmp edi, eax
+	jge voxskipslab4
+
+	push ebx
+	push ecx
+	push edi
+voxbegslab4:
+	mov ebp, ebx
+	add ebx, edx
+	shr ebp, 16
+	xor eax, eax
+	mov al, byte [esi+ebp]
+voxpal7: mov al, byte [eax+88888888h]
+	mov ah, al
+	mov word [edi], ax
+voxbpl7: add edi, 88888888h
+	dec ecx
+	jnz voxbegslab4
+	pop edi
+	pop ecx
+	pop ebx
+	add edi, 2
+
+voxskipslab4:
+	pop eax
+
+	cmp edi, eax
+	je voxskipslab5
+
+voxbegslab5:
+	mov ebp, ebx
+	add ebx, edx
+	shr ebp, 16
+	xor eax, eax
+	mov al, byte [esi+ebp]
+voxpal8: mov al, byte [eax+88888888h]
+	mov byte [edi], al
+voxbpl8: add edi, 88888888h
+	dec ecx
+	jnz voxbegslab5
+
+voxskipslab5:
+	pop edi
+	pop esi
+	pop ebp
+	pop ebx
+	ret
+
+align 16
+
 %ifdef M_TARGET_MACHO
 GLOBAL _rtext_a_end
 _rtext_a_end:
diff --git a/src/asm_ia32/tmap.asm b/src/asm_ia32/tmap.asm
index cbcd9f4f15..00e6333548 100644
--- a/src/asm_ia32/tmap.asm
+++ b/src/asm_ia32/tmap.asm
@@ -342,13 +342,13 @@ dsy3:	shr	ebp,26
 	mov	edx,[ds_ystep]
 	 mov	ecx,[ds_xfrac]
 dsy4:	shr	ecx,26
-dsm8:	 and	edx,0xffffffc0
+dsm8:	 and	edx,strict dword 0xffffffc0
 	or	ebp,edx
 	 mov	[esp+4],ebp
 	mov	ebp,[ds_yfrac]
 	 mov	edx,[ds_xfrac]
 dsy2:	shl	edx,6
-dsm9:	 and	ebp,0xffffffc0
+dsm9:	 and	ebp,strict dword 0xffffffc0
 	or	ecx,ebp
 	 shr	esi,1
 	jnc	dseven1
@@ -485,13 +485,13 @@ dmsy3:	shr	ebp,26
 	mov	edx,[ds_ystep]
 	 mov	ecx,[ds_xfrac]
 dmsy4:	shr	ecx,26
-dmsm8:	 and	edx,0xffffffc0
+dmsm8:	 and	edx,strict dword 0xffffffc0
 	or	ebp,edx
 	 mov	[esp+4],ebp
 	mov	ebp,[ds_yfrac]
 	 mov	edx,[ds_xfrac]
 dmsy2:	shl	edx,6
-dmsm9:	 and	ebp,0xffffffc0
+dmsm9:	 and	ebp,strict dword 0xffffffc0
 	or	ecx,ebp
 	 shr	esi,1
 	jnc	dmseven1
@@ -850,8 +850,8 @@ GLOBAL	R_DrawColumnHorizP_ASM
 	align 16
 
 @R_DrawColumnHorizP_ASM@0:
-R_DrawColumnHorizP_ASM:
 _R_DrawColumnHorizP_ASM:
+R_DrawColumnHorizP_ASM:
 
 ; count = dc_yh - dc_yl;
 
@@ -870,8 +870,10 @@ _R_DrawColumnHorizP_ASM:
 	inc	eax			; make 0 count mean 0 pixels
 	 and	edx,3
 	push	eax
-	 mov	esi,[dc_ctspan+edx*4]
-	lea	eax,[dc_temp+ecx*4+edx] ; eax = top of column in buffer
+	 mov	eax,[dc_temp]
+	mov	esi,[dc_ctspan+edx*4]
+	 add	eax,edx
+	lea	eax,[eax+ecx*4] ; eax = top of column in buffer
 	 mov	ebp,[dc_yh]
 	mov	[esi],ecx
 	 mov	[esi+4],ebp
@@ -1102,8 +1104,9 @@ _rt_copy1col_asm:
 	lea	esi,[eax*4]
 	inc	ebx			; ebx = count
 	mov	eax,edx
-	lea	ecx,[dc_temp+ecx+esi]	; ecx = source
+	add ecx,esi
 	mov	edi,[ylookup+esi]
+	add ecx,[dc_temp]	; ecx = source
 	mov	esi,[dc_pitch]		; esi = pitch
 	add	eax,edi			; eax = dest
 	add	eax,[dc_destorg]
@@ -1169,10 +1172,11 @@ _rt_copy4cols_asm:
 	inc	ebx			; ebx = count
 	mov	eax,ecx
 	mov	esi,[ylookup+edx*4]
-	lea	ecx,[dc_temp+edx*4]	; ecx = source
-	mov	edx,[dc_pitch]		; edx = pitch
+	mov ecx,[dc_temp]
 	add	eax,esi			; eax = dest
 	add	eax,[dc_destorg]
+	lea	ecx,[ecx+edx*4]	; ecx = source
+	mov	edx,[dc_pitch]		; edx = pitch
 
 	shr	ebx,1
 	jnc	.even
@@ -1241,7 +1245,8 @@ _rt_map1col_asm:
 	mov	esi,[dc_colormap]		; esi = colormap
 	inc	ebx				; ebx = count
 	mov	eax,edx
-	lea	ebp,[dc_temp+ecx+edi]		; ebp = source
+	lea	ebp,[ecx+edi]		; ebp = source
+	add ebp,[dc_temp]
 	mov	ecx,[ylookup+edi]
 	mov	edi,[dc_pitch]			; edi = pitch
 	add	eax,ecx				; eax = dest
@@ -1320,7 +1325,8 @@ _rt_map4cols_asm1:
 	mov	eax,ecx
 	inc	ebx			; ebx = count
 	mov	edi,[ylookup+edx]
-	lea	ebp,[dc_temp+edx]	; ebp = source
+	mov	ebp,[dc_temp]
+	add ebp,edx		; ebp = source
 	add	eax,edi			; eax = dest
 	mov	edi,[dc_pitch]		; edi = pitch
 	add	eax,[dc_destorg]
@@ -1414,7 +1420,8 @@ _rt_map4cols_asm2:
 	mov	eax,ecx
 	inc	ebx			; ebx = count
 	mov	edi,[ylookup+edx]
-	lea	ebp,[dc_temp+edx]	; ebp = source
+	mov ebp,[dc_temp]
+	add ebp,edx		; ebp = source
 	add	eax,edi			; eax = dest
 	mov	edi,[dc_pitch]		; edi = pitch
 	add	eax,[dc_destorg]
@@ -1493,10 +1500,11 @@ _rt_shaded4cols_asm:
 		add		eax,[dc_destorg]				; eax = destination
 		push	ebx
 		push	esi
+		mov		esi,[dc_temp]
 		inc		ebp								; ebp = count
 		add		eax,[esp+16]
 		push	edi
-		lea		esi,[dc_temp+ecx*4]				; esi = source
+		lea		esi,[esi+ecx*4]				; esi = source
 
 		align	16
 
@@ -1580,10 +1588,11 @@ _rt_add4cols_asm:
 		add		eax,[dc_destorg]
 		push	ebx
 		push	esi
+		mov		esi,[dc_temp]
 		push	ebp
 		inc		edi
 		add		eax,[esp+20]
-		lea		esi,[dc_temp+ecx*4]
+		lea		esi,[esi+ecx*4]
 		
 		align 16
 a4loop:
@@ -1659,10 +1668,11 @@ _rt_addclamp4cols_asm:
 		add		eax,[dc_destorg]
 		push	ebx
 		push	esi
+		mov		esi,[dc_temp]
 		push	ebp
 		inc		edi
 		add		eax,[esp+20]
-		lea		esi,[dc_temp+ecx*4]
+		lea		esi,[esi+ecx*4]
 		push	edi
 		
 		align	16
diff --git a/src/c_cmds.cpp b/src/c_cmds.cpp
index 0831c805f2..b3e43f92f5 100644
--- a/src/c_cmds.cpp
+++ b/src/c_cmds.cpp
@@ -453,7 +453,7 @@ CCMD (puke)
 
 	if (argc < 2 || argc > 5)
 	{
-		Printf (" puke <script> [arg1] [arg2] [arg3]\n");
+		Printf ("Usage: puke <script> [arg1] [arg2] [arg3]\n");
 	}
 	else
 	{
@@ -489,6 +489,52 @@ CCMD (puke)
 	}
 }
 
+CCMD (special)
+{
+	int argc = argv.argc();
+
+	if (argc < 2 || argc > 7)
+	{
+		Printf("Usage: special <special-name> [arg1] [arg2] [arg3] [arg4] [arg5]\n");
+	}
+	else
+	{
+		int specnum;
+
+		if (argv[1][0] >= '0' && argv[1][0] <= '9')
+		{
+			specnum = atoi(argv[1]);
+			if (specnum < 0 || specnum > 255)
+			{
+				Printf("Bad special number\n");
+				return;
+			}
+		}
+		else
+		{
+			int min_args;
+			specnum = P_FindLineSpecial(argv[1], &min_args);
+			if (specnum == 0 || min_args < 0)
+			{
+				Printf("Unknown special\n");
+				return;
+			}
+			if (argc < 2 + min_args)
+			{
+				Printf("%s needs at least %d argument%s\n", argv[1], min_args, min_args == 1 ? "" : "s");
+				return;
+			}
+		}
+		Net_WriteByte(DEM_RUNSPECIAL);
+		Net_WriteByte(specnum);
+		Net_WriteByte(argc - 2);
+		for (int i = 2; i < argc; ++i)
+		{
+			Net_WriteLong(atoi(argv[i]));
+		}
+	}
+}
+
 CCMD (error)
 {
 	if (argv.argc() > 1)
diff --git a/src/c_cvars.cpp b/src/c_cvars.cpp
index 3afdb7c8cb..51413c37df 100644
--- a/src/c_cvars.cpp
+++ b/src/c_cvars.cpp
@@ -221,7 +221,16 @@ int FBaseCVar::ToInt (UCVarValue value, ECVarType type)
 #else
 	case CVAR_Float:		res = (int)value.Float; break;
 #endif
-	case CVAR_String:		res = strtol (value.String, NULL, 0); break;
+	case CVAR_String:		
+		{
+			if (stricmp (value.String, "true") == 0)
+				res = 1;
+			else if (stricmp (value.String, "false") == 0)
+				res = 0;
+			else
+				res = strtol (value.String, NULL, 0); 
+			break;
+		}
 	case CVAR_GUID:			res = 0; break;
 	default:				res = 0; break;
 	}
@@ -444,7 +453,12 @@ UCVarValue FBaseCVar::FromString (const char *value, ECVarType type)
 		break;
 
 	case CVAR_Int:
-		ret.Int = strtol (value, NULL, 0);
+		if (stricmp (value, "true") == 0)
+			ret.Int = 1;
+		else if (stricmp (value, "false") == 0)
+			ret.Int = 0;
+		else
+			ret.Int = strtol (value, NULL, 0);
 		break;
 
 	case CVAR_Float:
diff --git a/src/c_dispatch.h b/src/c_dispatch.h
index ac8685855e..5aa3f98702 100644
--- a/src/c_dispatch.h
+++ b/src/c_dispatch.h
@@ -166,5 +166,6 @@ void ResetButtonStates ();		// Same as above, but also clear bDown
 
 extern unsigned int MakeKey (const char *s);
 extern unsigned int MakeKey (const char *s, size_t len);
+extern unsigned int SuperFastHash (const char *data, size_t len);
 
 #endif //__C_DISPATCH_H__
diff --git a/src/compatibility.cpp b/src/compatibility.cpp
index cd74f5e344..718bfecee8 100644
--- a/src/compatibility.cpp
+++ b/src/compatibility.cpp
@@ -90,7 +90,6 @@ static FCompatOption Options[] =
 	{ "resetplayerspeed",		0, BCOMPATF_RESETPLAYERSPEED },
 	{ "vileghosts",				0, BCOMPATF_VILEGHOSTS },
 	{ "ignoreteleporttags",		0, BCOMPATF_BADTELEPORTERS },
-	{ "oldportals",				0, BCOMPATF_BADPORTALS },
 
 	// list copied from g_mapinfo.cpp
 	{ "shorttex",				COMPATF_SHORTTEX, 0 },
@@ -284,12 +283,6 @@ void CheckCompatibility(MapData *map)
 		ib_compatflags = 0;
 		ii_compatparams = -1;
 	}
-	else if (Wads.GetLumpFile(map->lumpnum) == 1 && (gameinfo.flags & GI_COMPATPORTAL))
-	{
-		ii_compatflags = 0;
-		ib_compatflags = BCOMPATF_BADPORTALS;
-		ii_compatparams = -1;
-	}
 	else
 	{
 		map->GetChecksum(md5.Bytes);
diff --git a/src/d_iwad.cpp b/src/d_iwad.cpp
index 0c7cc3bf24..0999a77eac 100644
--- a/src/d_iwad.cpp
+++ b/src/d_iwad.cpp
@@ -174,7 +174,6 @@ void FIWadManager::ParseIWadInfo(const char *fn, const char *data, int datasize)
 						else if(sc.Compare("Extended")) iwad->flags |= GI_MENUHACK_EXTENDED;
 						else if(sc.Compare("Shorttex")) iwad->flags |= GI_COMPATSHORTTEX;
 						else if(sc.Compare("Stairs")) iwad->flags |= GI_COMPATSTAIRS;
-						else if(sc.Compare("Portals")) iwad->flags |= GI_COMPATPORTAL;
 						else sc.ScriptError(NULL);
 					}
 					while (sc.CheckString(","));
diff --git a/src/d_net.cpp b/src/d_net.cpp
index e088997198..d13570a33f 100644
--- a/src/d_net.cpp
+++ b/src/d_net.cpp
@@ -57,6 +57,7 @@
 #include "g_level.h"
 #include "d_event.h"
 #include "m_argv.h"
+#include "p_lnspec.h"
 
 int P_StartScript (AActor *who, line_t *where, int script, char *map, bool backSide,
 					int arg0, int arg1, int arg2, int always, bool wantResultCode, bool net);
@@ -2316,13 +2317,38 @@ void Net_DoCommand (int type, BYTE **stream, int player)
 			
 			for (i = 0; i < argn; ++i)
 			{
-				arg[i] = ReadLong (stream);
+				int argval = ReadLong(stream);
+				if (i < countof(arg))
+				{
+					arg[i] = argval;
+				}
 			}
 			P_StartScript (players[player].mo, NULL, snum, level.mapname, false,
 				arg[0], arg[1], arg[2], type == DEM_RUNSCRIPT2, false, true);
 		}
 		break;
 
+	case DEM_RUNSPECIAL:
+		{
+			int snum = ReadByte(stream);
+			int argn = ReadByte(stream);
+			int arg[5] = { 0, 0, 0, 0, 0 };
+
+			for (i = 0; i < argn; ++i)
+			{
+				int argval = ReadLong(stream);
+				if (i < countof(arg))
+				{
+					arg[i] = argval;
+				}
+			}
+			if (!CheckCheatmode(player == consoleplayer))
+			{
+				LineSpecials[snum](NULL, players[player].mo, false, arg[0], arg[1], arg[2], arg[3], arg[4]);
+			}
+		}
+		break;
+
 	case DEM_CROUCH:
 		if (gamestate == GS_LEVEL && players[player].mo != NULL && 
 			players[player].health > 0 && !(players[player].oldbuttons & BT_JUMP))
@@ -2521,6 +2547,10 @@ void Net_SkipCommand (int type, BYTE **stream)
 			skip = 3 + *(*stream + 2) * 4;
 			break;
 
+		case DEM_RUNSPECIAL:
+			skip = 2 + *(*stream + 1) * 4;
+			break;
+
 		case DEM_CONVREPLY:
 			skip = 3;
 			break;
diff --git a/src/d_player.h b/src/d_player.h
index 6f414e1ff1..74a3b8a24b 100644
--- a/src/d_player.h
+++ b/src/d_player.h
@@ -137,6 +137,7 @@ public:
 	int			SpawnMask;
 	FNameNoInit	MorphWeapon;
 	fixed_t		AttackZOffset;			// attack height, relative to player center
+	const PClass *FlechetteType;
 
 	// [CW] Fades for when you are being damaged.
 	PalEntry DamageFade;
diff --git a/src/d_protocol.h b/src/d_protocol.h
index a78c39ae25..b96c94e06c 100644
--- a/src/d_protocol.h
+++ b/src/d_protocol.h
@@ -158,6 +158,7 @@ enum EDemoCommand
 	DEM_CONVREPLY,		// 59 Word: Dialogue node, Byte: Reply number
 	DEM_CONVCLOSE,		// 60
 	DEM_CONVNULL,		// 61
+	DEM_RUNSPECIAL,		// 62 Byte: Special number, Byte: Arg count, Ints: Args
 };
 
 // The following are implemented by cht_DoCheat in m_cheat.cpp
diff --git a/src/g_game.cpp b/src/g_game.cpp
index 1d735ee037..1c2a6e5162 100644
--- a/src/g_game.cpp
+++ b/src/g_game.cpp
@@ -455,6 +455,8 @@ CCMD (drop)
 	}
 }
 
+const PClass *GetFlechetteType(AActor *other);
+
 CCMD (useflechette)
 { // Select from one of arti_poisonbag1-3, whichever the player has
 	static const ENamedName bagnames[3] =
@@ -463,22 +465,26 @@ CCMD (useflechette)
 		NAME_ArtiPoisonBag2,
 		NAME_ArtiPoisonBag3
 	};
-	int i, j;
 
 	if (who == NULL)
 		return;
 
-	if (who->IsKindOf (PClass::FindClass (NAME_ClericPlayer)))
-		i = 0;
-	else if (who->IsKindOf (PClass::FindClass (NAME_MagePlayer)))
-		i = 1;
-	else
-		i = 2;
-
-	for (j = 0; j < 3; ++j)
+	const PClass *type = GetFlechetteType(who);
+	if (type != NULL)
 	{
 		AInventory *item;
-		if ( (item = who->FindInventory (bagnames[(i+j)%3])) )
+		if ( (item = who->FindInventory (type) ))
+		{
+			SendItemUse = item;
+			return;
+		}
+	}
+
+	// The default flechette could not be found. Try all 3 types then.
+	for (int j = 0; j < 3; ++j)
+	{
+		AInventory *item;
+		if ( (item = who->FindInventory (bagnames[j])) )
 		{
 			SendItemUse = item;
 			break;
diff --git a/src/g_hexen/a_flechette.cpp b/src/g_hexen/a_flechette.cpp
index ea72cb208c..b99ec97935 100644
--- a/src/g_hexen/a_flechette.cpp
+++ b/src/g_hexen/a_flechette.cpp
@@ -141,6 +141,27 @@ bool AArtiPoisonBag3::Use (bool pickup)
 	return false;
 }
 
+//============================================================================
+//
+// GetFlechetteType
+//
+//============================================================================
+
+const PClass *GetFlechetteType(AActor *other)
+{
+	const PClass *spawntype = NULL;
+	if (other->IsKindOf(RUNTIME_CLASS(APlayerPawn)))
+	{
+		spawntype = static_cast<APlayerPawn*>(other)->FlechetteType;
+	}
+	if (spawntype == NULL)
+	{
+		// default fallback if nothing valid defined.
+		spawntype = RUNTIME_CLASS(AArtiPoisonBag3);
+	}
+	return spawntype;
+}
+
 //============================================================================
 //
 // AArtiPoisonBag :: HandlePickup
@@ -155,21 +176,7 @@ bool AArtiPoisonBag::HandlePickup (AInventory *item)
 		return Super::HandlePickup (item);
 	}
 
-	bool matched;
-
-	if (Owner->IsKindOf (PClass::FindClass(NAME_ClericPlayer)))
-	{
-		matched = (GetClass() == RUNTIME_CLASS(AArtiPoisonBag1));
-	}
-	else if (Owner->IsKindOf (PClass::FindClass(NAME_MagePlayer)))
-	{
-		matched = (GetClass() == RUNTIME_CLASS(AArtiPoisonBag2));
-	}
-	else
-	{
-		matched = (GetClass() == RUNTIME_CLASS(AArtiPoisonBag3));
-	}
-	if (matched)
+	if (GetClass() == GetFlechetteType(Owner))
 	{
 		if (Amount < MaxAmount)
 		{
@@ -204,20 +211,8 @@ AInventory *AArtiPoisonBag::CreateCopy (AActor *other)
 	}
 
 	AInventory *copy;
-	const PClass *spawntype;
 
-	if (other->IsKindOf (PClass::FindClass(NAME_ClericPlayer)))
-	{
-		spawntype = RUNTIME_CLASS(AArtiPoisonBag1);
-	}
-	else if (other->IsKindOf (PClass::FindClass(NAME_MagePlayer)))
-	{
-		spawntype = RUNTIME_CLASS(AArtiPoisonBag2);
-	}
-	else
-	{
-		spawntype = RUNTIME_CLASS(AArtiPoisonBag3);
-	}
+	const PClass *spawntype = GetFlechetteType(other);
 	copy = static_cast<AInventory *>(Spawn (spawntype, 0, 0, 0, NO_REPLACE));
 	copy->Amount = Amount;
 	copy->MaxAmount = MaxAmount;
diff --git a/src/g_shared/a_artifacts.cpp b/src/g_shared/a_artifacts.cpp
index c4f0f9d6a0..0370e226c4 100644
--- a/src/g_shared/a_artifacts.cpp
+++ b/src/g_shared/a_artifacts.cpp
@@ -36,8 +36,6 @@ static FRandom pr_torch ("Torch");
 #define	TIMEFREEZE_TICS	( 12 * TICRATE )
 */
 
-EXTERN_CVAR (Bool, r_drawfuzz);
-
 IMPLEMENT_CLASS (APowerup)
 
 // Powerup-Giver -------------------------------------------------------------
diff --git a/src/g_shared/sbarinfo.cpp b/src/g_shared/sbarinfo.cpp
index a552a3ad1d..c469bb7361 100644
--- a/src/g_shared/sbarinfo.cpp
+++ b/src/g_shared/sbarinfo.cpp
@@ -1190,7 +1190,7 @@ public:
 			}
 
 			if(clearDontDraw)
-				screen->Clear(static_cast<int>(MAX<double>(dx, dcx)), static_cast<int>(MAX<double>(dy, dcy)), static_cast<int>(dcr), static_cast<int>(dcb), GPalette.BlackIndex, 0);
+				screen->Clear(static_cast<int>(MAX<double>(dx, dcx)), static_cast<int>(MAX<double>(dy, dcy)), static_cast<int>(MIN<double>(dcr,w+MAX<double>(dx, dcx))), static_cast<int>(MIN<double>(dcb,MAX<double>(dy, dcy)+h)), GPalette.BlackIndex, 0);
 			else
 			{
 				if(alphaMap)
diff --git a/src/g_shared/sbarinfo_commands.cpp b/src/g_shared/sbarinfo_commands.cpp
index fcc5a6e1ef..c63b009e5d 100644
--- a/src/g_shared/sbarinfo_commands.cpp
+++ b/src/g_shared/sbarinfo_commands.cpp
@@ -2660,6 +2660,58 @@ class CommandPlayerClass : public SBarInfoCommandFlowControl
 
 ////////////////////////////////////////////////////////////////////////////////
 
+class CommandPlayerType : public SBarInfoCommandFlowControl
+{
+	public:
+		CommandPlayerType(SBarInfo *script) : SBarInfoCommandFlowControl(script)
+		{
+		}
+
+		void	Parse(FScanner &sc, bool fullScreenOffsets)
+		{
+			sc.MustGetToken(TK_Identifier);
+			do
+			{
+				bool foundClass = false;
+				const PClass *cls = PClass::FindClass(sc.String);
+				if (cls != NULL)
+				{
+					foundClass = true;
+					classes.Push(cls);
+				}
+				/*
+				if(!foundClass)
+					sc.ScriptError("Unkown PlayerClass '%s'.", sc.String);
+				*/
+				if(!sc.CheckToken(','))
+					break;
+			}
+			while(sc.CheckToken(TK_Identifier));
+			SBarInfoCommandFlowControl::Parse(sc, fullScreenOffsets);
+		}
+		void	Tick(const SBarInfoMainBlock *block, const DSBarInfo *statusBar, bool hudChanged)
+		{
+			SBarInfoCommandFlowControl::Tick(block, statusBar, hudChanged);
+
+			if(statusBar->CPlayer->cls == NULL)
+				return; //No class so we can not continue
+		
+			for(unsigned int i = 0;i < classes.Size();i++)
+			{
+				if (statusBar->CPlayer->cls->IsDescendantOf(classes[i]))
+				{
+					SetTruth(true, block, statusBar);
+					return;
+				}
+			}
+			SetTruth(false, block, statusBar);
+		}
+	protected:
+		TArray<const PClass *> classes;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
 class CommandHasWeaponPiece : public SBarInfoCommandFlowControl
 {
 	public:
@@ -3082,7 +3134,7 @@ static const char *SBarInfoCommandNames[] =
 	"drawmugshot", "drawselectedinventory",
 	"drawinventorybar", "drawbar", "drawgem",
 	"drawshader", "drawstring", "drawkeybar",
-	"gamemode", "playerclass", "aspectratio",
+	"gamemode", "playerclass", "playertype", "aspectratio",
 	"isselected", "usesammo", "usessecondaryammo",
 	"hasweaponpiece", "inventorybarnotvisible",
 	"weaponammo", "ininventory", "alpha",
@@ -3095,7 +3147,7 @@ enum SBarInfoCommands
 	SBARINFO_DRAWMUGSHOT, SBARINFO_DRAWSELECTEDINVENTORY,
 	SBARINFO_DRAWINVENTORYBAR, SBARINFO_DRAWBAR, SBARINFO_DRAWGEM,
 	SBARINFO_DRAWSHADER, SBARINFO_DRAWSTRING, SBARINFO_DRAWKEYBAR,
-	SBARINFO_GAMEMODE, SBARINFO_PLAYERCLASS, SBARINFO_ASPECTRATIO,
+	SBARINFO_GAMEMODE, SBARINFO_PLAYERCLASS, SBARINFO_PLAYERTYPE, SBARINFO_ASPECTRATIO,
 	SBARINFO_ISSELECTED, SBARINFO_USESAMMO, SBARINFO_USESSECONDARYAMMO,
 	SBARINFO_HASWEAPONPIECE, SBARINFO_INVENTORYBARNOTVISIBLE,
 	SBARINFO_WEAPONAMMO, SBARINFO_ININVENTORY, SBARINFO_ALPHA,
@@ -3126,6 +3178,7 @@ SBarInfoCommand *SBarInfoCommandFlowControl::NextCommand(FScanner &sc)
 			case SBARINFO_ASPECTRATIO: return new CommandAspectRatio(script);
 			case SBARINFO_ISSELECTED: return new CommandIsSelected(script);
 			case SBARINFO_PLAYERCLASS: return new CommandPlayerClass(script);
+			case SBARINFO_PLAYERTYPE: return new CommandPlayerType(script);
 			case SBARINFO_HASWEAPONPIECE: return new CommandHasWeaponPiece(script);
 			case SBARINFO_WEAPONAMMO: return new CommandWeaponAmmo(script);
 			case SBARINFO_ININVENTORY: return new CommandInInventory(script);
diff --git a/src/gi.h b/src/gi.h
index 645f5d3ba4..647db1a9bf 100644
--- a/src/gi.h
+++ b/src/gi.h
@@ -47,7 +47,6 @@
 #define GI_COMPATPOLY1			0x00000040	// Hexen's MAP36 needs old polyobject drawing
 #define GI_COMPATPOLY2			0x00000080	// so does HEXDD's MAP47
 #define GI_NOTEXTCOLOR			0x00000100	// Chex Quest 3 would have everything green
-#define GI_COMPATPORTAL			0x00000200	// Urban Brawl relies on the old portal code
 
 #include "gametype.h"
 
diff --git a/src/intermission/intermission_parse.cpp b/src/intermission/intermission_parse.cpp
index fab4dca29e..d621d4c6cb 100644
--- a/src/intermission/intermission_parse.cpp
+++ b/src/intermission/intermission_parse.cpp
@@ -810,7 +810,8 @@ void F_StartFinale (const char *music, int musicorder, int cdtrack, unsigned int
 					const char *text, INTBOOL textInLump, INTBOOL finalePic, INTBOOL lookupText, 
 					bool ending, FName endsequence)
 {
-	if (text != NULL && *text != 0)
+	// Hexen's chess ending doesn't have a text screen, even if the cluster has a message defined.
+	if (text != NULL && *text != 0 && endsequence != NAME_Inter_Chess)
 	{
 		FIntermissionActionTextscreen *textscreen = new FIntermissionActionTextscreen;
 		if (textInLump)
diff --git a/src/m_fixed.h b/src/m_fixed.h
index 61080d73d2..8fb6658813 100644
--- a/src/m_fixed.h
+++ b/src/m_fixed.h
@@ -141,4 +141,36 @@ inline SDWORD ModDiv (SDWORD num, SDWORD den, SDWORD *dmval)
 #define FIXED2FLOAT(f)		((f) / float(65536))
 #define FIXED2DBL(f)		((f) / double(65536))
 
+class Fixed
+{
+	int v;
+
+public:
+
+	Fixed() {}
+	Fixed(int val) { v = val; }
+	Fixed(double val) { v = xs_Fix<16>::ToFix(val); }
+	Fixed &operator = (int val) { v = val; return *this; }
+	Fixed &operator = (double val) { v = xs_Fix<16>::ToFix(val); return *this; }
+
+	Fixed &operator += (Fixed val) { v += val.v; return *this; }
+	Fixed &operator -= (Fixed val) { v -= val.v; return *this; }
+	Fixed &operator *= (Fixed val) { v = FixedMul(v, val.v); return *this; }
+	Fixed &operator /= (Fixed val) { v = FixedDiv(v, val.v); return *this; }
+	Fixed &operator += (double val) { v += xs_Fix<16>::ToFix(val); return *this; }
+	Fixed &operator -= (double val) { v -= xs_Fix<16>::ToFix(val); return *this; }
+	Fixed &operator *= (Fixed val) { v = FixedMul(v, xs_Fix<16>::ToFix(val)); return *this; }
+	Fixed &operator /= (Fixed val) { v = FixedDiv(v, xs_Fix<16>::ToFix(val)); return *this; }
+
+	Fixed operator + (Fixed val) { return v + val.v; }
+	Fixed operator - (Fixed val) { return v - val.v; }
+	Fixed operator * (Fixed val) { return FixedMul(v, val.v); }
+	Fixed operator / (Fixed val) { return FixedDiv(v, val.v); }
+	Fixed operator + (double val) { return v + xs_Fix<16>::ToFix(val); }
+	Fixed operator - (double val) { return v - xs_Fix<16>::ToFix(val); }
+	Fixed operator * (Fixed val) { return FixedMul(v, xs_Fix<16>::ToFix(val)); }
+	Fixed operator / (Fixed val) { return FixedDiv(v, xs_Fix<16>::ToFix(val)); }
+};
+
+
 #endif
diff --git a/src/memarena.cpp b/src/memarena.cpp
new file mode 100644
index 0000000000..c44586deef
--- /dev/null
+++ b/src/memarena.cpp
@@ -0,0 +1,376 @@
+/*
+** memarena.cpp
+** Implements memory arenas.
+**
+**---------------------------------------------------------------------------
+** Copyright 2010 Randy Heit
+** All rights reserved.
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+**
+** 1. Redistributions of source code must retain the above copyright
+**    notice, this list of conditions and the following disclaimer.
+** 2. Redistributions in binary form must reproduce the above copyright
+**    notice, this list of conditions and the following disclaimer in the
+**    documentation and/or other materials provided with the distribution.
+** 3. The name of the author may not be used to endorse or promote products
+**    derived from this software without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+**---------------------------------------------------------------------------
+**
+** A memory arena is used for efficient allocation of many small objects that
+** will all be freed at once. Note that since individual destructors are not
+** called, you must not use an arena to allocate any objects that use a
+** destructor, either explicitly or implicitly (because they have members
+** with destructors).
+*/
+
+#include "doomtype.h"
+#include "m_alloc.h"
+#include "memarena.h"
+#include "c_dispatch.h"
+#include "zstring.h"
+
+#define BLOCK_SIZE			(10*1024)
+
+struct FMemArena::Block
+{
+	Block *NextBlock;
+	void *Limit;			// End of this block
+	void *Avail;			// Start of free space in this block
+
+	void Reset();
+	void *Alloc(size_t size);
+};
+
+//==========================================================================
+//
+// RoundPointer
+//
+// Rounds a pointer up to a pointer-sized boundary.
+//
+//==========================================================================
+
+static inline void *RoundPointer(void *ptr)
+{
+	return (void *)(((size_t)ptr + sizeof(void*) - 1) & ~(sizeof(void*) - 1));
+}
+
+//==========================================================================
+//
+// FMemArena Constructor
+//
+//==========================================================================
+
+FMemArena::FMemArena()
+{
+	TopBlock = NULL;
+	FreeBlocks = NULL;
+}
+
+//==========================================================================
+//
+// FMemArena Destructor
+//
+//==========================================================================
+
+FMemArena::~FMemArena()
+{
+	FreeAllBlocks();
+}
+
+//==========================================================================
+//
+// FMemArena :: Alloc
+//
+//==========================================================================
+
+void *FMemArena::Alloc(size_t size)
+{
+	Block *block;
+
+	for (block = TopBlock; block != NULL; block = block->NextBlock)
+	{
+		void *res = block->Alloc(size);
+		if (res != NULL)
+		{
+			return res;
+		}
+	}
+	block = AddBlock(size);
+	return block->Alloc(size);
+}
+
+//==========================================================================
+//
+// FMemArena :: FreeAll
+//
+// Moves all blocks to the free list. No system-level deallocation occurs.
+//
+//==========================================================================
+
+void FMemArena::FreeAll()
+{
+	for (Block *next, *block = TopBlock; block != NULL; block = next)
+	{
+		next = block->NextBlock;
+		block->Reset();
+		block->NextBlock = FreeBlocks;
+		FreeBlocks = block;
+	}
+	TopBlock = NULL;
+}
+
+//==========================================================================
+//
+// FMemArena :: FreeAllBlocks
+//
+// Frees all blocks used by this arena.
+//
+//==========================================================================
+
+void FMemArena::FreeAllBlocks()
+{
+	FreeBlockChain(TopBlock);
+	FreeBlockChain(FreeBlocks);
+}
+
+//==========================================================================
+//
+// FMemArena :: FreeBlockChain
+//
+// Frees a chain of blocks.
+//
+//==========================================================================
+
+void FMemArena::FreeBlockChain(Block *&top)
+{
+	for (Block *next, *block = top; block != NULL; block = next)
+	{
+		next = block->NextBlock;
+		M_Free(block);
+	}
+	top = NULL;
+}
+
+//==========================================================================
+//
+// FMemArena :: AddBlock
+//
+// Allocates a block large enough to hold at least <size> bytes and adds it
+// to the TopBlock chain.
+//
+//==========================================================================
+
+FMemArena::Block *FMemArena::AddBlock(size_t size)
+{
+	Block *mem, **last;
+	size += sizeof(Block);		// Account for header size
+
+	// Search for a free block to use
+	for (last = &FreeBlocks, mem = FreeBlocks; mem != NULL; last = &mem->NextBlock, mem = mem->NextBlock)
+	{
+		if ((BYTE *)mem->Limit - (BYTE *)mem >= (ptrdiff_t)size)
+		{
+			*last = mem->NextBlock;
+			break;
+		}
+	}
+	if (mem == NULL)
+	{
+		// Allocate a new block
+		if (size < BLOCK_SIZE)
+		{
+			size = BLOCK_SIZE;
+		}
+		else
+		{ // Stick some free space at the end so we can use this block for
+		  // other things.
+			size += BLOCK_SIZE/2;
+		}
+		mem = (Block *)M_Malloc(size);
+		mem->Limit = (BYTE *)mem + size;
+	}
+	mem->Reset();
+	mem->NextBlock = TopBlock;
+	TopBlock = mem;
+	return mem;
+}
+
+//==========================================================================
+//
+// FMemArena :: Block :: Reset
+//
+// Resets this block's Avail pointer.
+//
+//==========================================================================
+
+void FMemArena::Block::Reset()
+{
+	Avail = RoundPointer(this + sizeof(*this));
+}
+
+//==========================================================================
+//
+// FMemArena :: Block :: Alloc
+//
+// Allocates memory from the block if it has space. Returns NULL if not.
+//
+//==========================================================================
+
+void *FMemArena::Block::Alloc(size_t size)
+{
+	if ((char *)Avail + size > Limit)
+	{
+		return NULL;
+	}
+	void *res = Avail;
+	Avail = RoundPointer((char *)Avail + size);
+	return res;
+}
+
+//==========================================================================
+//
+// FSharedStringArena Constructor
+//
+//==========================================================================
+
+FSharedStringArena::FSharedStringArena()
+{
+	memset(Buckets, 0, sizeof(Buckets));
+}
+
+//==========================================================================
+//
+// FSharedStringArena Destructor
+//
+//==========================================================================
+
+FSharedStringArena::~FSharedStringArena()
+{
+	FreeAll();
+	// FMemArena destructor will free the blocks.
+}
+
+//==========================================================================
+//
+// FSharedStringArena :: Alloc
+//
+// Allocates a new string and initializes it with the passed string. This
+// version takes an FString as a parameter, so it won't need to allocate any
+// memory for the string text if it already exists in the arena.
+//
+//==========================================================================
+
+FString *FSharedStringArena::Alloc(const FString &source)
+{
+	unsigned int hash;
+	Node *strnode;
+
+	strnode = FindString(source, source.Len(), hash);
+	if (strnode == NULL)
+	{
+		strnode = (Node *)FMemArena::Alloc(sizeof(Node));
+		::new(&strnode->String) FString(source);
+		strnode->Hash = hash;
+		hash %= countof(Buckets);
+		strnode->Next = Buckets[hash];
+		Buckets[hash] = strnode;
+	}
+	return &strnode->String;
+}
+
+//==========================================================================
+//
+// FSharedStringArena :: Alloc
+//
+//==========================================================================
+
+FString *FSharedStringArena::Alloc(const char *source)
+{
+	return Alloc(source, strlen(source));
+}
+
+//==========================================================================
+//
+// FSharedStringArena :: Alloc
+//
+//==========================================================================
+
+FString *FSharedStringArena::Alloc(const char *source, size_t strlen)
+{
+	unsigned int hash;
+	Node *strnode;
+
+	strnode = FindString(source, strlen, hash);
+	if (strnode == NULL)
+	{
+		strnode = (Node *)FMemArena::Alloc(sizeof(Node));
+		::new(&strnode->String) FString(source, strlen);
+		strnode->Hash = hash;
+		hash %= countof(Buckets);
+		strnode->Next = Buckets[hash];
+		Buckets[hash] = strnode;
+	}
+	return &strnode->String;
+}
+
+//==========================================================================
+//
+// FSharedStringArena :: FindString
+//
+// Finds the string if it's already in the arena. Returns NULL if not.
+//
+//==========================================================================
+
+FSharedStringArena::Node *FSharedStringArena::FindString(const char *str, size_t strlen, unsigned int &hash)
+{
+	hash = SuperFastHash(str, strlen);
+
+	for (Node *node = Buckets[hash % countof(Buckets)]; node != NULL; node = node->Next)
+	{
+		if (node->Hash == hash && node->String.Len() == strlen && memcmp(&node->String[0], str, strlen) == 0)
+		{
+			return node;
+		}
+	}
+	return NULL;
+}
+
+//==========================================================================
+//
+// FSharedStringArena :: FreeAll
+//
+// In addition to moving all used blocks onto the free list, all FStrings
+// they contain will have their destructors called.
+//
+//==========================================================================
+
+void FSharedStringArena::FreeAll()
+{
+	for (Block *next, *block = TopBlock; block != NULL; block = next)
+	{
+		next = block->NextBlock;
+		void *limit = block->Avail;
+		block->Reset();
+		for (Node *string = (Node *)block->Avail; string < limit; ++string)
+		{
+			string->~Node();
+		}
+		block->NextBlock = FreeBlocks;
+		FreeBlocks = block;
+	}
+	memset(Buckets, 0, sizeof(Buckets));
+}
diff --git a/src/memarena.h b/src/memarena.h
new file mode 100644
index 0000000000..e933fc0728
--- /dev/null
+++ b/src/memarena.h
@@ -0,0 +1,83 @@
+/*
+** memarena.h
+**
+**---------------------------------------------------------------------------
+** Copyright 2010 Randy Heit
+** All rights reserved.
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+**
+** 1. Redistributions of source code must retain the above copyright
+**    notice, this list of conditions and the following disclaimer.
+** 2. Redistributions in binary form must reproduce the above copyright
+**    notice, this list of conditions and the following disclaimer in the
+**    documentation and/or other materials provided with the distribution.
+** 3. The name of the author may not be used to endorse or promote products
+**    derived from this software without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+**---------------------------------------------------------------------------
+**
+*/
+
+#include "zstring.h"
+
+// A general purpose arena.
+class FMemArena
+{
+public:
+	FMemArena();
+	~FMemArena();
+
+	void *Alloc(size_t size);
+	void FreeAll();
+	void FreeAllBlocks();
+
+protected:
+	struct Block;
+
+	Block *AddBlock(size_t size);
+	void FreeBlockChain(Block *&top);
+
+	Block *TopBlock;
+	Block *FreeBlocks;
+};
+
+// An arena specializing in storage of FStrings. It knows how to free them,
+// but this means it also should never be used for allocating anything else.
+// Identical strings all return the same pointer.
+class FSharedStringArena : public FMemArena
+{
+public:
+	FSharedStringArena();
+	~FSharedStringArena();
+	void FreeAll();
+
+	class FString *Alloc(const FString &source);
+	class FString *Alloc(const char *source);
+	class FString *Alloc(const char *source, size_t strlen);
+
+protected:
+	struct Node
+	{
+		Node *Next;
+		FString String;
+		unsigned int Hash;
+	};
+	Node *Buckets[256];
+
+	Node *FindString(const char *str, size_t strlen, unsigned int &hash);
+private:
+	void *Alloc(size_t size) { return NULL; }	// No access to FMemArena::Alloc for outsiders.
+};
diff --git a/src/menu/playermenu.cpp b/src/menu/playermenu.cpp
index 03300af140..de0292f7af 100644
--- a/src/menu/playermenu.cpp
+++ b/src/menu/playermenu.cpp
@@ -912,7 +912,7 @@ void DPlayerMenu::ClassChanged (FListMenuItem *li)
 		players[consoleplayer].userinfo.PlayerClass = sel-1;
 		PickPlayerClass();
 
-		cvar_set ("playerclass", sel == 0 ? "Random" : PlayerClass->Type->TypeName);
+		cvar_set ("playerclass", sel == 0 ? "Random" : PlayerClass->Type->Meta.GetMetaString (APMETA_DisplayName));
 
 		UpdateSkins();
 		UpdateColorsets();
diff --git a/src/namedef.h b/src/namedef.h
index d9573b7478..52fc87e665 100644
--- a/src/namedef.h
+++ b/src/namedef.h
@@ -529,6 +529,7 @@ xx(res_9)
 xx(AlwaysRun)
 
 // end sequences
+xx(Inter_Chess)
 xx(Inter_Strife)
 xx(Inter_Strife_Good)
 xx(Inter_Strife_Sad)
diff --git a/src/p_acs.cpp b/src/p_acs.cpp
index cd9d3c7a22..63c3f0a6ca 100644
--- a/src/p_acs.cpp
+++ b/src/p_acs.cpp
@@ -2829,6 +2829,9 @@ int DLevelScript::CheckActorProperty (int tid, int property, int value)
 		case APROP_MasterTID:
 		case APROP_TargetTID:
 		case APROP_TracerTID:
+		case APROP_WaterLevel:
+		case APROP_ScaleX:
+		case APROP_ScaleY:
 			return (GetActorProperty(tid, property) == value);
 
 		// Boolean values need to compare to a binary version of value
diff --git a/src/p_ceiling.cpp b/src/p_ceiling.cpp
index ec569735c7..3cb60bcbbf 100644
--- a/src/p_ceiling.cpp
+++ b/src/p_ceiling.cpp
@@ -30,9 +30,11 @@
 #include "r_state.h"
 #include "gi.h"
 
+//============================================================================
 //
 // CEILINGS
 //
+//============================================================================
 
 IMPLEMENT_CLASS (DCeiling)
 
@@ -40,6 +42,12 @@ DCeiling::DCeiling ()
 {
 }
 
+//============================================================================
+//
+// 
+//
+//============================================================================
+
 void DCeiling::Serialize (FArchive &arc)
 {
 	Super::Serialize (arc);
@@ -59,6 +67,12 @@ void DCeiling::Serialize (FArchive &arc)
 		<< m_Hexencrush;
 }
 
+//============================================================================
+//
+// 
+//
+//============================================================================
+
 void DCeiling::PlayCeilingSound ()
 {
 	if (m_Sector->seqType >= 0)
@@ -80,9 +94,12 @@ void DCeiling::PlayCeilingSound ()
 	}
 }
 
+//============================================================================
 //
-// T_MoveCeiling
+// DCeiling :: Tick
 //
+//============================================================================
+
 void DCeiling::Tick ()
 {
 	EResult res;
@@ -176,6 +193,12 @@ void DCeiling::Tick ()
 	}
 }
 
+//============================================================================
+//
+// 
+//
+//============================================================================
+
 DCeiling::DCeiling (sector_t *sec)
 	: DMovingCeiling (sec)
 {
@@ -191,11 +214,258 @@ DCeiling::DCeiling (sector_t *sec, fixed_t speed1, fixed_t speed2, int silent)
 	m_Silent = silent;
 }
 
+//============================================================================
+//
+// 
+//
+//============================================================================
+
+DCeiling *DCeiling::Create(sector_t *sec, DCeiling::ECeiling type, line_t *line, int tag, 
+				   fixed_t speed, fixed_t speed2, fixed_t height,
+				   int crush, int silent, int change, bool hexencrush)
+{
+	fixed_t		targheight = 0;	// Silence, GCC
+
+	// if ceiling already moving, don't start a second function on it
+	if (sec->PlaneMoving(sector_t::ceiling))
+	{
+		return NULL;
+	}
+	
+	// new door thinker
+	DCeiling *ceiling = new DCeiling (sec, speed, speed2, silent);
+	vertex_t *spot = sec->lines[0]->v1;
+
+	switch (type)
+	{
+	case ceilCrushAndRaise:
+	case ceilCrushRaiseAndStay:
+		ceiling->m_TopHeight = sec->ceilingplane.d;
+	case ceilLowerAndCrush:
+	case ceilLowerAndCrushDist:
+		targheight = sec->FindHighestFloorPoint (&spot);
+		if (type == ceilLowerAndCrush)
+		{
+			targheight += 8*FRACUNIT;
+		}
+		else if (type == ceilLowerAndCrushDist)
+		{
+			targheight += height;
+		}
+		ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
+		ceiling->m_Direction = -1;
+		break;
+
+	case ceilRaiseToHighest:
+		targheight = sec->FindHighestCeilingSurrounding (&spot);
+		ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
+		ceiling->m_Direction = 1;
+		break;
+
+	case ceilLowerByValue:
+		targheight = sec->ceilingplane.ZatPoint (spot) - height;
+		ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
+		ceiling->m_Direction = -1;
+		break;
+
+	case ceilRaiseByValue:
+		targheight = sec->ceilingplane.ZatPoint (spot) + height;
+		ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
+		ceiling->m_Direction = 1;
+		break;
+
+	case ceilMoveToValue:
+		{
+			int diff = height - sec->ceilingplane.ZatPoint (spot);
+
+			targheight = height;
+			if (diff < 0)
+			{
+				ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, height);
+				ceiling->m_Direction = -1;
+			}
+			else
+			{
+				ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, height);
+				ceiling->m_Direction = 1;
+			}
+		}
+		break;
+
+	case ceilLowerToHighestFloor:
+		targheight = sec->FindHighestFloorSurrounding (&spot);
+		ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
+		ceiling->m_Direction = -1;
+		break;
+
+	case ceilRaiseToHighestFloor:
+		targheight = sec->FindHighestFloorSurrounding (&spot);
+		ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
+		ceiling->m_Direction = 1;
+		break;
+
+	case ceilLowerInstant:
+		targheight = sec->ceilingplane.ZatPoint (spot) - height;
+		ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
+		ceiling->m_Direction = -1;
+		ceiling->m_Speed = height;
+		break;
+
+	case ceilRaiseInstant:
+		targheight = sec->ceilingplane.ZatPoint (spot) + height;
+		ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
+		ceiling->m_Direction = 1;
+		ceiling->m_Speed = height;
+		break;
+
+	case ceilLowerToNearest:
+		targheight = sec->FindNextLowestCeiling (&spot);
+		ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
+		ceiling->m_Direction = -1;
+		break;
+
+	case ceilRaiseToNearest:
+		targheight = sec->FindNextHighestCeiling (&spot);
+		ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
+		ceiling->m_Direction = 1;
+		break;
+
+	case ceilLowerToLowest:
+		targheight = sec->FindLowestCeilingSurrounding (&spot);
+		ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
+		ceiling->m_Direction = -1;
+		break;
+
+	case ceilRaiseToLowest:
+		targheight = sec->FindLowestCeilingSurrounding (&spot);
+		ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
+		ceiling->m_Direction = 1;
+		break;
+
+	case ceilLowerToFloor:
+		targheight = sec->FindHighestFloorPoint (&spot);
+		ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
+		ceiling->m_Direction = -1;
+		break;
+
+	case ceilRaiseToFloor:	// [RH] What's this for?
+		targheight = sec->FindHighestFloorPoint (&spot);
+		ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
+		ceiling->m_Direction = 1;
+		break;
+
+	case ceilLowerToHighest:
+		targheight = sec->FindHighestCeilingSurrounding (&spot);
+		ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
+		ceiling->m_Direction = -1;
+		break;
+
+	case ceilLowerByTexture:
+		targheight = sec->ceilingplane.ZatPoint (spot) - sec->FindShortestUpperAround ();
+		ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
+		ceiling->m_Direction = -1;
+		break;
+
+	case ceilRaiseByTexture:
+		targheight = sec->ceilingplane.ZatPoint (spot) + sec->FindShortestUpperAround ();
+		ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
+		ceiling->m_Direction = 1;
+		break;
+
+	default:
+		break;	// Silence GCC
+	}
+			
+	ceiling->m_Tag = tag;
+	ceiling->m_Type = type;
+	ceiling->m_Crush = crush;
+	ceiling->m_Hexencrush = hexencrush;
+
+	// Do not interpolate instant movement ceilings.
+	// Note for ZDoomGL: Check to make sure that you update the sector
+	// after the ceiling moves, because it hasn't actually moved yet.
+	fixed_t movedist;
+
+	if (ceiling->m_Direction < 0)
+	{
+		movedist = sec->ceilingplane.d - ceiling->m_BottomHeight;
+	}
+	else
+	{
+		movedist = ceiling->m_TopHeight - sec->ceilingplane.d;
+	}
+	if (ceiling->m_Speed >= movedist)
+	{
+		ceiling->StopInterpolation();
+	}
+
+	// set texture/type change properties
+	if (change & 3)		// if a texture change is indicated
+	{
+		if (change & 4)	// if a numeric model change
+		{
+			sector_t *modelsec;
+
+			//jff 5/23/98 find model with floor at target height if target
+			//is a floor type
+			modelsec = (/*type == ceilRaiseToHighest ||*/
+				   type == ceilRaiseToFloor ||
+				   /*type == ceilLowerToHighest ||*/
+				   type == ceilLowerToFloor) ?
+				sec->FindModelFloorSector (targheight) :
+				sec->FindModelCeilingSector (targheight);
+			if (modelsec != NULL)
+			{
+				ceiling->m_Texture = modelsec->GetTexture(sector_t::ceiling);
+				switch (change & 3)
+				{
+					case 1:		// type is zeroed
+						ceiling->m_NewSpecial = 0;
+						ceiling->m_Type = genCeilingChg0;
+						break;
+					case 2:		// type is copied
+						ceiling->m_NewSpecial = sec->special;
+						ceiling->m_Type = genCeilingChgT;
+						break;
+					case 3:		// type is left alone
+						ceiling->m_Type = genCeilingChg;
+						break;
+				}
+			}
+		}
+		else if (line)	// else if a trigger model change
+		{
+			ceiling->m_Texture = line->frontsector->GetTexture(sector_t::ceiling);
+			switch (change & 3)
+			{
+				case 1:		// type is zeroed
+					ceiling->m_NewSpecial = 0;
+					ceiling->m_Type = genCeilingChg0;
+					break;
+				case 2:		// type is copied
+					ceiling->m_NewSpecial = line->frontsector->special;
+					ceiling->m_Type = genCeilingChgT;
+					break;
+				case 3:		// type is left alone
+					ceiling->m_Type = genCeilingChg;
+					break;
+			}
+		}
+	}
+
+	ceiling->PlayCeilingSound ();
+	return ceiling;
+}
+
+//============================================================================
 //
 // EV_DoCeiling
 // Move a ceiling up/down and all around!
 //
 // [RH] Added tag, speed, speed2, height, crush, silent, change params
+//
+//============================================================================
+
 bool EV_DoCeiling (DCeiling::ECeiling type, line_t *line,
 				   int tag, fixed_t speed, fixed_t speed2, fixed_t height,
 				   int crush, int silent, int change, bool hexencrush)
@@ -203,10 +473,6 @@ bool EV_DoCeiling (DCeiling::ECeiling type, line_t *line,
 	int 		secnum;
 	bool 		rtn;
 	sector_t*	sec;
-	DCeiling*	ceiling;
-	bool		manual = false;
-	fixed_t		targheight = 0;	// Silence, GCC
-	vertex_t*	spot;
 		
 	rtn = false;
 
@@ -216,11 +482,10 @@ bool EV_DoCeiling (DCeiling::ECeiling type, line_t *line,
 		if (!line || !(sec = line->backsector))
 			return rtn;
 		secnum = (int)(sec-sectors);
-		manual = true;
 		// [RH] Hack to let manual crushers be retriggerable, too
 		tag ^= secnum | 0x1000000;
 		P_ActivateInStasisCeiling (tag);
-		goto manual_ceiling;
+		return !!DCeiling::Create(sec, type, line, tag, speed, speed2, height, crush, silent, change, hexencrush);
 	}
 	
 	//	Reactivate in-stasis ceilings...for certain types.
@@ -234,252 +499,19 @@ bool EV_DoCeiling (DCeiling::ECeiling type, line_t *line,
 	// affects all sectors with the same tag as the linedef
 	while ((secnum = P_FindSectorFromTag (tag, secnum)) >= 0)
 	{
-		sec = &sectors[secnum];
-manual_ceiling:
-		// if ceiling already moving, don't start a second function on it
-		if (sec->PlaneMoving(sector_t::ceiling))
-		{
-			if (!manual)
-				continue;
-			else
-				return false;
-		}
-		
-		// new door thinker
-		rtn = 1;
-		ceiling = new DCeiling (sec, speed, speed2, silent);
-		spot = sec->lines[0]->v1;
-
-		switch (type)
-		{
-		case DCeiling::ceilCrushAndRaise:
-		case DCeiling::ceilCrushRaiseAndStay:
-			ceiling->m_TopHeight = sec->ceilingplane.d;
-		case DCeiling::ceilLowerAndCrush:
-		case DCeiling::ceilLowerAndCrushDist:
-			targheight = sec->FindHighestFloorPoint (&spot);
-			if (type == DCeiling::ceilLowerAndCrush)
-			{
-				targheight += 8*FRACUNIT;
-			}
-			else if (type == DCeiling::ceilLowerAndCrushDist)
-			{
-				targheight += height;
-			}
-			ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
-			ceiling->m_Direction = -1;
-			break;
-
-		case DCeiling::ceilRaiseToHighest:
-			targheight = sec->FindHighestCeilingSurrounding (&spot);
-			ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
-			ceiling->m_Direction = 1;
-			break;
-
-		case DCeiling::ceilLowerByValue:
-			targheight = sec->ceilingplane.ZatPoint (spot) - height;
-			ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
-			ceiling->m_Direction = -1;
-			break;
-
-		case DCeiling::ceilRaiseByValue:
-			targheight = sec->ceilingplane.ZatPoint (spot) + height;
-			ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
-			ceiling->m_Direction = 1;
-			break;
-
-		case DCeiling::ceilMoveToValue:
-			{
-				int diff = height - sec->ceilingplane.ZatPoint (spot);
-
-				targheight = height;
-				if (diff < 0)
-				{
-					ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, height);
-					ceiling->m_Direction = -1;
-				}
-				else
-				{
-					ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, height);
-					ceiling->m_Direction = 1;
-				}
-			}
-			break;
-
-		case DCeiling::ceilLowerToHighestFloor:
-			targheight = sec->FindHighestFloorSurrounding (&spot);
-			ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
-			ceiling->m_Direction = -1;
-			break;
-
-		case DCeiling::ceilRaiseToHighestFloor:
-			targheight = sec->FindHighestFloorSurrounding (&spot);
-			ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
-			ceiling->m_Direction = 1;
-			break;
-
-		case DCeiling::ceilLowerInstant:
-			targheight = sec->ceilingplane.ZatPoint (spot) - height;
-			ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
-			ceiling->m_Direction = -1;
-			ceiling->m_Speed = height;
-			break;
-
-		case DCeiling::ceilRaiseInstant:
-			targheight = sec->ceilingplane.ZatPoint (spot) + height;
-			ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
-			ceiling->m_Direction = 1;
-			ceiling->m_Speed = height;
-			break;
-
-		case DCeiling::ceilLowerToNearest:
-			targheight = sec->FindNextLowestCeiling (&spot);
-			ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
-			ceiling->m_Direction = -1;
-			break;
-
-		case DCeiling::ceilRaiseToNearest:
-			targheight = sec->FindNextHighestCeiling (&spot);
-			ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
-			ceiling->m_Direction = 1;
-			break;
-
-		case DCeiling::ceilLowerToLowest:
-			targheight = sec->FindLowestCeilingSurrounding (&spot);
-			ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
-			ceiling->m_Direction = -1;
-			break;
-
-		case DCeiling::ceilRaiseToLowest:
-			targheight = sec->FindLowestCeilingSurrounding (&spot);
-			ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
-			ceiling->m_Direction = 1;
-			break;
-
-		case DCeiling::ceilLowerToFloor:
-			targheight = sec->FindHighestFloorPoint (&spot);
-			ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
-			ceiling->m_Direction = -1;
-			break;
-
-		case DCeiling::ceilRaiseToFloor:	// [RH] What's this for?
-			targheight = sec->FindHighestFloorPoint (&spot);
-			ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
-			ceiling->m_Direction = 1;
-			break;
-
-		case DCeiling::ceilLowerToHighest:
-			targheight = sec->FindHighestCeilingSurrounding (&spot);
-			ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
-			ceiling->m_Direction = -1;
-			break;
-
-		case DCeiling::ceilLowerByTexture:
-			targheight = sec->ceilingplane.ZatPoint (spot) - sec->FindShortestUpperAround ();
-			ceiling->m_BottomHeight = sec->ceilingplane.PointToDist (spot, targheight);
-			ceiling->m_Direction = -1;
-			break;
-
-		case DCeiling::ceilRaiseByTexture:
-			targheight = sec->ceilingplane.ZatPoint (spot) + sec->FindShortestUpperAround ();
-			ceiling->m_TopHeight = sec->ceilingplane.PointToDist (spot, targheight);
-			ceiling->m_Direction = 1;
-			break;
-
-		default:
-			break;	// Silence GCC
-		}
-				
-		ceiling->m_Tag = tag;
-		ceiling->m_Type = type;
-		ceiling->m_Crush = crush;
-		ceiling->m_Hexencrush = hexencrush;
-
-		// Do not interpolate instant movement ceilings.
-		// Note for ZDoomGL: Check to make sure that you update the sector
-		// after the ceiling moves, because it hasn't actually moved yet.
-		fixed_t movedist;
-
-		if (ceiling->m_Direction < 0)
-		{
-			movedist = sec->ceilingplane.d - ceiling->m_BottomHeight;
-		}
-		else
-		{
-			movedist = ceiling->m_TopHeight - sec->ceilingplane.d;
-		}
-		if (ceiling->m_Speed >= movedist)
-		{
-			ceiling->StopInterpolation();
-		}
-
-		// set texture/type change properties
-		if (change & 3)		// if a texture change is indicated
-		{
-			if (change & 4)	// if a numeric model change
-			{
-				sector_t *modelsec;
-
-				//jff 5/23/98 find model with floor at target height if target
-				//is a floor type
-				modelsec = (/*type == DCeiling::ceilRaiseToHighest ||*/
-					   type == DCeiling::ceilRaiseToFloor ||
-					   /*type == DCeiling::ceilLowerToHighest ||*/
-					   type == DCeiling::ceilLowerToFloor) ?
-					sec->FindModelFloorSector (targheight) :
-					sec->FindModelCeilingSector (targheight);
-				if (modelsec != NULL)
-				{
-					ceiling->m_Texture = modelsec->GetTexture(sector_t::ceiling);
-					switch (change & 3)
-					{
-						case 1:		// type is zeroed
-							ceiling->m_NewSpecial = 0;
-							ceiling->m_Type = DCeiling::genCeilingChg0;
-							break;
-						case 2:		// type is copied
-							ceiling->m_NewSpecial = sec->special;
-							ceiling->m_Type = DCeiling::genCeilingChgT;
-							break;
-						case 3:		// type is left alone
-							ceiling->m_Type = DCeiling::genCeilingChg;
-							break;
-					}
-				}
-			}
-			else if (line)	// else if a trigger model change
-			{
-				ceiling->m_Texture = line->frontsector->GetTexture(sector_t::ceiling);
-				switch (change & 3)
-				{
-					case 1:		// type is zeroed
-						ceiling->m_NewSpecial = 0;
-						ceiling->m_Type = DCeiling::genCeilingChg0;
-						break;
-					case 2:		// type is copied
-						ceiling->m_NewSpecial = line->frontsector->special;
-						ceiling->m_Type = DCeiling::genCeilingChgT;
-						break;
-					case 3:		// type is left alone
-						ceiling->m_Type = DCeiling::genCeilingChg;
-						break;
-				}
-			}
-		}
-
-		ceiling->PlayCeilingSound ();
-
-		if (manual)
-			return rtn;
+		rtn |= !!DCeiling::Create(&sectors[secnum], type, line, tag, speed, speed2, height, crush, silent, change, hexencrush);
 	}
 	return rtn;
 }
 
 
+//============================================================================
 //
 // Restart a ceiling that's in-stasis
 // [RH] Passed a tag instead of a line and rewritten to use a list
 //
+//============================================================================
+
 void P_ActivateInStasisCeiling (int tag)
 {
 	DCeiling *scan;
@@ -495,11 +527,14 @@ void P_ActivateInStasisCeiling (int tag)
 	}
 }
 
+//============================================================================
 //
 // EV_CeilingCrushStop
 // Stop a ceiling from crushing!
 // [RH] Passed a tag instead of a line and rewritten to use a list
 //
+//============================================================================
+
 bool EV_CeilingCrushStop (int tag)
 {
 	bool rtn = false;
diff --git a/src/p_doors.cpp b/src/p_doors.cpp
index 557928c557..c01abab6ac 100644
--- a/src/p_doors.cpp
+++ b/src/p_doors.cpp
@@ -36,6 +36,12 @@
 #include "sc_man.h"
 #include "cmdlib.h"
 
+//============================================================================
+//
+// VERTICAL DOORS
+//
+//============================================================================
+
 IMPLEMENT_CLASS (DDoor)
 
 DDoor::DDoor ()
@@ -55,14 +61,12 @@ void DDoor::Serialize (FArchive &arc)
 		<< m_LightTag;
 }
 
-
-//
-// VERTICAL DOORS
-//
-
+//============================================================================
 //
 // T_VerticalDoor
 //
+//============================================================================
+
 void DDoor::Tick ()
 {
 	EResult res;
@@ -215,7 +219,12 @@ void DDoor::Tick ()
 	}
 }
 
+//============================================================================
+//
 // [RH] DoorSound: Plays door sound depending on direction and speed
+//
+//============================================================================
+
 void DDoor::DoorSound (bool raise) const
 {
 	int choice;
@@ -309,10 +318,12 @@ DDoor::DDoor (sector_t *sector)
 {
 }
 
-// [RH] Merged EV_VerticalDoor and EV_DoLockedDoor into EV_DoDoor
-//		and made them more general to support the new specials.
-
+//============================================================================
+//
 // [RH] SpawnDoor: Helper function for EV_DoDoor
+//
+//============================================================================
+
 DDoor::DDoor (sector_t *sec, EVlDoor type, fixed_t speed, int delay, int lightTag)
 	: DMovingCeiling (sec),
   	  m_Type (type), m_Speed (speed), m_TopWait (delay), m_LightTag (lightTag)
@@ -371,6 +382,13 @@ DDoor::DDoor (sector_t *sec, EVlDoor type, fixed_t speed, int delay, int lightTa
 	m_OldFloorDist = sec->floorplane.d;
 }
 
+//============================================================================
+//
+// [RH] Merged EV_VerticalDoor and EV_DoLockedDoor into EV_DoDoor
+//		and made them more general to support the new specials.
+//
+//============================================================================
+
 bool EV_DoDoor (DDoor::EVlDoor type, line_t *line, AActor *thing,
 				int tag, int speed, int delay, int lock, int lightTag)
 {
@@ -464,10 +482,12 @@ bool EV_DoDoor (DDoor::EVlDoor type, line_t *line, AActor *thing,
 	return rtn;
 }
 
-
+//============================================================================
 //
 // Spawn a door that closes after 30 seconds
 //
+//============================================================================
+
 void P_SpawnDoorCloseIn30 (sector_t *sec)
 {
 	fixed_t height;
@@ -487,18 +507,56 @@ void P_SpawnDoorCloseIn30 (sector_t *sec)
 	door->m_LightTag = 0;
 }
 
+//============================================================================
 //
 // Spawn a door that opens after 5 minutes
 //
+//============================================================================
+
 void P_SpawnDoorRaiseIn5Mins (sector_t *sec)
 {
 	sec->special = 0;
 	new DDoor (sec, DDoor::doorRaiseIn5Mins, 2*FRACUNIT, TICRATE*30/7, 0);
 }
 
-// EV_SlidingDoor : slide a door horizontally
-// (animate midtexture, then set noblocking line)
+
+//============================================================================
 //
+// animated doors
+//
+//============================================================================
+
+IMPLEMENT_CLASS (DAnimatedDoor)
+
+DAnimatedDoor::DAnimatedDoor ()
+{
+}
+
+DAnimatedDoor::DAnimatedDoor (sector_t *sec)
+	: DMovingCeiling (sec)
+{
+}
+
+void DAnimatedDoor::Serialize (FArchive &arc)
+{
+	Super::Serialize (arc);
+	
+	arc << m_Line1 << m_Line2
+		<< m_Frame
+		<< m_Timer
+		<< m_BotDist
+		<< m_Status
+		<< m_Speed
+		<< m_Delay
+		<< m_DoorAnim
+		<< m_SetBlocking1 << m_SetBlocking2;
+}
+
+//============================================================================
+//
+// Starts a closing action on an animated door
+//
+//============================================================================
 
 bool DAnimatedDoor::StartClosing ()
 {
@@ -528,6 +586,12 @@ bool DAnimatedDoor::StartClosing ()
 	return true;
 }
 
+//============================================================================
+//
+//
+//
+//============================================================================
+
 void DAnimatedDoor::Tick ()
 {
 	if (m_DoorAnim == NULL)
@@ -624,31 +688,11 @@ void DAnimatedDoor::Tick ()
 	}
 }
 
-IMPLEMENT_CLASS (DAnimatedDoor)
-
-DAnimatedDoor::DAnimatedDoor ()
-{
-}
-
-DAnimatedDoor::DAnimatedDoor (sector_t *sec)
-	: DMovingCeiling (sec)
-{
-}
-
-void DAnimatedDoor::Serialize (FArchive &arc)
-{
-	Super::Serialize (arc);
-	
-	arc << m_Line1 << m_Line2
-		<< m_Frame
-		<< m_Timer
-		<< m_BotDist
-		<< m_Status
-		<< m_Speed
-		<< m_Delay
-		<< m_DoorAnim
-		<< m_SetBlocking1 << m_SetBlocking2;
-}
+//============================================================================
+//
+//
+//
+//============================================================================
 
 DAnimatedDoor::DAnimatedDoor (sector_t *sec, line_t *line, int speed, int delay, FDoorAnimation *anim)
 	: DMovingCeiling (sec)
@@ -706,7 +750,8 @@ DAnimatedDoor::DAnimatedDoor (sector_t *sec, line_t *line, int speed, int delay,
 
 //============================================================================
 //
-// EV_SlidingDoor
+// EV_SlidingDoor : slide a door horizontally
+// (animate midtexture, then set noblocking line)
 //
 //============================================================================
 
diff --git a/src/p_glnodes.cpp b/src/p_glnodes.cpp
index c48d72e8f0..4d34c70476 100644
--- a/src/p_glnodes.cpp
+++ b/src/p_glnodes.cpp
@@ -1223,6 +1223,7 @@ static void CreateCachedNodes(MapData *map)
 	FILE *f = fopen(path, "wb");
 	fwrite(compressed, 1, outlen+offset, f);
 	fclose(f);
+	delete [] compressed;
 }
 
 
diff --git a/src/p_mobj.cpp b/src/p_mobj.cpp
index fbf6b28aea..39a17bf763 100644
--- a/src/p_mobj.cpp
+++ b/src/p_mobj.cpp
@@ -81,7 +81,6 @@ static void PlayerLandedOnThing (AActor *mo, AActor *onmobj);
 
 extern cycle_t BotSupportCycles;
 extern int BotWTG;
-EXTERN_CVAR (Bool, r_drawfuzz);
 EXTERN_CVAR (Int,  cl_rockettrails)
 
 // PRIVATE DATA DEFINITIONS ------------------------------------------------
diff --git a/src/p_setup.cpp b/src/p_setup.cpp
index 091b8bb474..43f9704519 100644
--- a/src/p_setup.cpp
+++ b/src/p_setup.cpp
@@ -2519,10 +2519,10 @@ void P_LoadSideDefs2 (MapData * map)
 // as possible from its ZDBSP incarnation.
 //
 
-static unsigned int BlockHash (TArray<WORD> *block)
+static unsigned int BlockHash (TArray<int> *block)
 {
 	int hash = 0;
-	WORD *ar = &(*block)[0];
+	int *ar = &(*block)[0];
 	for (size_t i = 0; i < block->Size(); ++i)
 	{
 		hash = hash * 12235 + ar[i];
@@ -2530,7 +2530,7 @@ static unsigned int BlockHash (TArray<WORD> *block)
 	return hash & 0x7fffffff;
 }
 
-static bool BlockCompare (TArray<WORD> *block1, TArray<WORD> *block2)
+static bool BlockCompare (TArray<int> *block1, TArray<int> *block2)
 {
 	size_t size = block1->Size();
 
@@ -2542,8 +2542,8 @@ static bool BlockCompare (TArray<WORD> *block1, TArray<WORD> *block2)
 	{
 		return true;
 	}
-	WORD *ar1 = &(*block1)[0];
-	WORD *ar2 = &(*block2)[0];
+	int *ar1 = &(*block1)[0];
+	int *ar2 = &(*block2)[0];
 	for (size_t i = 0; i < size; ++i)
 	{
 		if (ar1[i] != ar2[i])
@@ -2554,20 +2554,20 @@ static bool BlockCompare (TArray<WORD> *block1, TArray<WORD> *block2)
 	return true;
 }
 
-static void CreatePackedBlockmap (TArray<int> &BlockMap, TArray<WORD> *blocks, int bmapwidth, int bmapheight)
+static void CreatePackedBlockmap (TArray<int> &BlockMap, TArray<int> *blocks, int bmapwidth, int bmapheight)
 {
 	int buckets[4096];
 	int *hashes, hashblock;
-	TArray<WORD> *block;
+	TArray<int> *block;
 	int zero = 0;
 	int terminator = -1;
-	WORD *array;
+	int *array;
 	int i, hash;
 	int hashed = 0, nothashed = 0;
 
 	hashes = new int[bmapwidth * bmapheight];
 
-	memset (hashes, 0xff, sizeof(WORD)*bmapwidth*bmapheight);
+	memset (hashes, 0xff, sizeof(int)*bmapwidth*bmapheight);
 	memset (buckets, 0xff, sizeof(buckets));
 
 	for (i = 0; i < bmapwidth * bmapheight; ++i)
@@ -2614,12 +2614,12 @@ static void CreatePackedBlockmap (TArray<int> &BlockMap, TArray<WORD> *blocks, i
 
 static void P_CreateBlockMap ()
 {
-	TArray<WORD> *BlockLists, *block, *endblock;
-	WORD adder;
+	TArray<int> *BlockLists, *block, *endblock;
+	int adder;
 	int bmapwidth, bmapheight;
 	int minx, maxx, miny, maxy;
 	int i;
-	WORD line;
+	int line;
 
 	if (numvertexes <= 0)
 		return;
@@ -2651,7 +2651,7 @@ static void P_CreateBlockMap ()
 	adder = bmapwidth;		BlockMap.Push (adder);
 	adder = bmapheight;		BlockMap.Push (adder);
 
-	BlockLists = new TArray<WORD>[bmapwidth * bmapheight];
+	BlockLists = new TArray<int>[bmapwidth * bmapheight];
 
 	for (line = 0; line < numlines; ++line)
 	{
diff --git a/src/p_spec.cpp b/src/p_spec.cpp
index dd3e0ca11e..cf97c16fc5 100644
--- a/src/p_spec.cpp
+++ b/src/p_spec.cpp
@@ -921,39 +921,6 @@ static bool SpreadCeilingPortal(AStackPoint *pt, fixed_t alpha, sector_t *sector
 	return fail;
 }
 
-static bool SpreadFloorPortal(AStackPoint *pt, fixed_t alpha, sector_t *sector)
-{
-	bool fail = false;
-	sector->validcount = validcount;
-	for(int i=0; i<sector->linecount; i++)
-	{
-		line_t *line = sector->lines[i];
-		sector_t *backsector = sector == line->frontsector? line->backsector : line->frontsector;
-		if (line->backsector == line->frontsector) continue;
-		if (backsector == NULL) { fail = true; continue; }
-		if (backsector->validcount == validcount) continue;
-		if (backsector->FloorSkyBox == pt) continue;
-
-		// Check if the backside would map to the same visplane
-		if (backsector->FloorSkyBox != NULL) { fail = true; continue; }
-		if (backsector->floorplane != sector->ceilingplane) { fail = true; continue; }
-		if (backsector->lightlevel != sector->lightlevel) { fail = true; continue; }
-		if (backsector->GetTexture(sector_t::floor)		!= sector->GetTexture(sector_t::floor)) { fail = true; continue; }
-		if (backsector->GetXOffset(sector_t::floor)		!= sector->GetXOffset(sector_t::floor)) { fail = true; continue; }
-		if (backsector->GetYOffset(sector_t::floor)		!= sector->GetYOffset(sector_t::floor)) { fail = true; continue; }
-		if (backsector->GetXScale(sector_t::floor)		!= sector->GetXScale(sector_t::floor)) { fail = true; continue; }
-		if (backsector->GetYScale(sector_t::floor)		!= sector->GetYScale(sector_t::floor)) { fail = true; continue; }
-		if (backsector->GetAngle(sector_t::floor)		!= sector->GetAngle(sector_t::floor)) { fail = true; continue; }
-		if (SpreadFloorPortal(pt, alpha, backsector)) { fail = true; continue; }
-	}
-	if (!fail) 
-	{
-		sector->FloorSkyBox = pt;
-		sector->SetAlpha(sector_t::floor, alpha);
-	}
-	return fail;
-}
-
 void P_SetupPortals()
 {
 	TThinkerIterator<AStackPoint> it;
@@ -974,51 +941,6 @@ void P_SetupPortals()
 		pt->special1 = 0;
 		points.Push(pt);
 	}
-
-	// Maps using undefined portal hacks may not benefit from portal optimizations.
-	if (ib_compatflags & BCOMPATF_BADPORTALS) return;
-
-	for(unsigned i=0;i<points.Size(); i++)
-	{
-		if (points[i]->special1 == 0 && points[i]->Mate != NULL)
-		{
-			for(unsigned j=1;j<points.Size(); j++)
-			{
-				if (points[j]->special1 == 0 && points[j]->Mate != NULL && points[i]->GetClass() == points[j]->GetClass())
-				{
-					fixed_t deltax1 = points[i]->Mate->x - points[i]->x;
-					fixed_t deltay1 = points[i]->Mate->y - points[i]->y;
-					fixed_t deltax2 = points[j]->Mate->x - points[j]->x;
-					fixed_t deltay2 = points[j]->Mate->y - points[j]->y;
-
-					if (deltax1 == deltax2 && deltay1 == deltay2)
-					{
-						if (points[j]->Sector->FloorSkyBox == points[j]->Mate)
-							points[j]->Sector->FloorSkyBox = points[i]->Mate;
-
-						if (points[j]->Sector->CeilingSkyBox == points[j]->Mate)
-							points[j]->Sector->CeilingSkyBox = points[i]->Mate;
-
-						points[j]->special1 = 1;
-					}
-				}
-			}
-		}
-	}
-	validcount++;
-	// Some fudging to preserve an unintended 'portal bleeding' effect caused by incomplete checks in the rendering code.
-	// Due to the addition of linedef-based portals this effect no longer works.
-	for(int i=0;i<numsectors; i++)
-	{
-		if (sectors[i].CeilingSkyBox != NULL && sectors[i].CeilingSkyBox->bAlways && sectors[i].validcount != validcount)
-		{
-			SpreadCeilingPortal(barrier_cast<AStackPoint*>(sectors[i].CeilingSkyBox), sectors[i].GetAlpha(sector_t::ceiling), &sectors[i]);
-		}
-		if (sectors[i].FloorSkyBox != NULL && sectors[i].FloorSkyBox->bAlways && sectors[i].validcount != validcount)
-		{
-			SpreadFloorPortal(barrier_cast<AStackPoint*>(sectors[i].FloorSkyBox), sectors[i].GetAlpha(sector_t::floor), &sectors[i]);
-		}
-	}
 }
 
 inline void SetPortal(sector_t *sector, int plane, AStackPoint *portal, fixed_t alpha)
diff --git a/src/p_spec.h b/src/p_spec.h
index 21427626e2..8656e42473 100644
--- a/src/p_spec.h
+++ b/src/p_spec.h
@@ -677,6 +677,10 @@ public:
 	void Serialize (FArchive &arc);
 	void Tick ();
 
+	static DCeiling *Create(sector_t *sec, DCeiling::ECeiling type, line_t *line, int tag,
+						fixed_t speed, fixed_t speed2, fixed_t height,
+						int crush, int silent, int change, bool hexencrush);
+
 protected:
 	ECeiling	m_Type;
 	fixed_t 	m_BottomHeight;
@@ -702,9 +706,6 @@ protected:
 private:
 	DCeiling ();
 
-	friend bool EV_DoCeiling (DCeiling::ECeiling type, line_t *line,
-		int tag, fixed_t speed, fixed_t speed2, fixed_t height,
-		int crush, int silent, int change, bool hexencrush);
 	friend bool EV_CeilingCrushStop (int tag);
 	friend void P_ActivateInStasisCeiling (int tag);
 };
diff --git a/src/p_user.cpp b/src/p_user.cpp
index 831d65dd5c..d18a31b6a8 100644
--- a/src/p_user.cpp
+++ b/src/p_user.cpp
@@ -432,7 +432,8 @@ void APlayerPawn::Serialize (FArchive &arc)
 		<< InvSel
 		<< MorphWeapon
 		<< DamageFade
-		<< PlayerFlags;
+		<< PlayerFlags
+		<< FlechetteType;
 }
 
 //===========================================================================
diff --git a/src/r_blend.h b/src/r_blend.h
index 132d09507e..f9fefc9d11 100644
--- a/src/r_blend.h
+++ b/src/r_blend.h
@@ -48,6 +48,7 @@ enum ERenderStyle
 	STYLE_Add,				// Draw additive
 	STYLE_Shaded,			// Treat patch data as alpha values for alphacolor
 	STYLE_TranslucentStencil,
+	STYLE_Shadow,
 
 	STYLE_Count
 };
@@ -63,6 +64,9 @@ enum ERenderOp
 	STYLEOP_FuzzOrAdd,		// Draw fuzzy or add, based on user preference
 	STYLEOP_FuzzOrSub,		// Draw fuzzy or subtract, based on user preference
 	STYLEOP_FuzzOrRevSub,	// Draw fuzzy or reverse subtract, based on user preference
+
+	// special styles
+	STYLEOP_Shadow,			
 };
 
 enum ERenderAlpha
diff --git a/src/r_data.cpp b/src/r_data.cpp
index a298cc03ff..8983d5e559 100644
--- a/src/r_data.cpp
+++ b/src/r_data.cpp
@@ -355,6 +355,304 @@ const BYTE *R_GetColumn (FTexture *tex, int col)
 	return tex->GetColumn (col, NULL);
 }
 
+//==========================================================================
+//
+// GetVoxelRemap
+//
+// Calculates a remap table for the voxel's palette. Results are cached so
+// passing the same palette repeatedly will not require repeated
+// recalculations.
+//
+//==========================================================================
+
+static BYTE *GetVoxelRemap(const BYTE *pal)
+{
+	static BYTE remap[256];
+	static BYTE oldpal[768];
+	static bool firsttime = true;
+
+	if (firsttime || memcmp(oldpal, pal, 768) != 0)
+	{ // Not the same palette as last time, so recalculate.
+		firsttime = false;
+		memcpy(oldpal, pal, 768);
+		for (int i = 0; i < 256; ++i)
+		{
+			// The voxel palette uses VGA colors, so we have to expand it
+			// from 6 to 8 bits per component.
+			remap[i] = BestColor((uint32 *)GPalette.BaseColors,
+				(oldpal[i*3 + 0] << 2) | (oldpal[i*3 + 0] >> 4),
+				(oldpal[i*3 + 1] << 2) | (oldpal[i*3 + 1] >> 4),
+				(oldpal[i*3 + 2] << 2) | (oldpal[i*3 + 2] >> 4));
+		}
+	}
+	return remap;
+}
+
+//==========================================================================
+//
+// CopyVoxelSlabs
+//
+// Copy all the slabs in a block of slabs.
+//
+//==========================================================================
+
+static bool CopyVoxelSlabs(kvxslab_t *dest, const kvxslab_t *src, int size)
+{
+	while (size >= 3)
+	{
+		int slabzleng = src->zleng;
+
+		if (3 + slabzleng > size)
+		{ // slab is too tall
+			return false;
+		}
+
+		dest->ztop = src->ztop;
+		dest->zleng = src->zleng;
+		dest->backfacecull = src->backfacecull;
+
+		for (int j = 0; j < slabzleng; ++j)
+		{
+			dest->col[j] = src->col[j];
+		}
+		slabzleng += 3;
+		src = (kvxslab_t *)((BYTE *)src + slabzleng);
+		dest = (kvxslab_t *)((BYTE *)dest + slabzleng);
+		size -= slabzleng;
+	}
+	return true;
+}
+
+//==========================================================================
+//
+// RemapVoxelSlabs
+//
+// Remaps all the slabs in a block of slabs.
+//
+//==========================================================================
+
+static void RemapVoxelSlabs(kvxslab_t *dest, int size, const BYTE *remap)
+{
+	while (size >= 3)
+	{
+		int slabzleng = dest->zleng;
+
+		for (int j = 0; j < slabzleng; ++j)
+		{
+			dest->col[j] = remap[dest->col[j]];
+		}
+		slabzleng += 3;
+		dest = (kvxslab_t *)((BYTE *)dest + slabzleng);
+		size -= slabzleng;
+	}
+}
+
+//==========================================================================
+//
+// R_LoadKVX
+//
+//==========================================================================
+
+FVoxel *R_LoadKVX(int lumpnum)
+{
+	const kvxslab_t *slabs[MAXVOXMIPS];
+	FVoxel *voxel = new FVoxel;
+	const BYTE *rawmip;
+	int mip, maxmipsize;
+	int i, j, n;
+
+	FMemLump lump = Wads.ReadLump(lumpnum);	// FMemLump adds an extra 0 byte to the end.
+	BYTE *rawvoxel = (BYTE *)lump.GetMem();
+	int voxelsize = (int)(lump.GetSize()-1);
+
+	// Oh, KVX, why couldn't you have a proper header? We'll just go through
+	// and collect each MIP level, doing lots of range checking, and if the
+	// last one doesn't end exactly 768 bytes before the end of the file,
+	// we'll reject it.
+
+	for (mip = 0, rawmip = rawvoxel, maxmipsize = voxelsize - 768 - 4;
+		 mip < MAXVOXMIPS;
+		 mip++)
+	{
+		int numbytes = GetInt(rawmip);
+		if (numbytes > maxmipsize || numbytes < 24)
+		{
+			break;
+		}
+		rawmip += 4;
+
+		FVoxelMipLevel *mipl = &voxel->Mips[mip];
+
+		// Load header data.
+		mipl->SizeX = GetInt(rawmip + 0);
+		mipl->SizeY = GetInt(rawmip + 4);
+		mipl->SizeZ = GetInt(rawmip + 8);
+		mipl->PivotX = GetInt(rawmip + 12);
+		mipl->PivotY = GetInt(rawmip + 16);
+		mipl->PivotZ = GetInt(rawmip + 20);
+
+		// How much space do we have for voxdata?
+		int offsetsize = (mipl->SizeX + 1) * 4 + mipl->SizeX * (mipl->SizeY + 1) * 2;
+		int voxdatasize = numbytes - 24 - offsetsize;
+		if (voxdatasize < 0)
+		{ // Clearly, not enough.
+			break;
+		}
+		if (voxdatasize == 0)
+		{ // This mip level is empty.
+			goto nextmip;
+		}
+
+		// Allocate slab data space.
+		mipl->OffsetX = new int[(numbytes - 24 + 3) / 4];
+		mipl->OffsetXY = (short *)(mipl->OffsetX + mipl->SizeX + 1);
+		mipl->SlabData = (BYTE *)(mipl->OffsetXY + mipl->SizeX * (mipl->SizeY + 1));
+
+		// Load x offsets.
+		for (i = 0, n = mipl->SizeX; i <= n; ++i)
+		{
+			// The X offsets stored in the KVX file are relative to the start of the
+			// X offsets array. Make them relative to voxdata instead.
+			mipl->OffsetX[i] = GetInt(rawmip + 24 + i * 4) - offsetsize;
+		}
+
+		// The first X offset must be 0 (since we subtracted offsetsize), according to the spec:
+		//		NOTE: xoffset[0] = (xsiz+1)*4 + xsiz*(ysiz+1)*2 (ALWAYS)
+		if (mipl->OffsetX[0] != 0)
+		{
+			break;
+		}
+		// And the final X offset must point just past the end of the voxdata.
+		if (mipl->OffsetX[mipl->SizeX] != voxdatasize)
+		{
+			break;
+		}
+
+		// Load xy offsets.
+		i = 24 + i * 4;
+		for (j = 0, n *= mipl->SizeY + 1; j < n; ++j)
+		{
+			mipl->OffsetXY[j] = GetShort(rawmip + i + j * 2);
+		}
+
+		// Ensure all offsets are within bounds.
+		for (i = 0; i < mipl->SizeX; ++i)
+		{
+			int xoff = mipl->OffsetX[i];
+			for (j = 0; j < mipl->SizeY; ++j)
+			{
+				int yoff = mipl->OffsetXY[(mipl->SizeY + 1) * i + j];
+				if (unsigned(xoff + yoff) > unsigned(voxdatasize))
+				{
+					goto bad;
+				}
+			}
+		}
+
+		// Record slab location for the end.
+		slabs[mip] = (kvxslab_t *)(rawmip + 24 + offsetsize);
+
+		// Time for the next mip Level.
+nextmip:
+		rawmip += numbytes;
+		maxmipsize -= numbytes + 4;
+	}
+	// Did we get any mip levels, and if so, does the last one leave just
+	// enough room for the palette after it?
+	if (mip == 0 || rawmip != rawvoxel + voxelsize - 768)
+	{
+bad:	delete voxel;
+		return NULL;
+	}
+
+	// Do not count empty mips at the end.
+	for (; mip > 0; --mip)
+	{
+		if (voxel->Mips[mip - 1].SlabData != NULL)
+			break;
+	}
+	voxel->NumMips = mip;
+
+	for (i = 0; i < mip; ++i)
+	{
+		if (!CopyVoxelSlabs((kvxslab_t *)voxel->Mips[i].SlabData, slabs[i], voxel->Mips[i].OffsetX[voxel->Mips[i].SizeX]))
+		{ // Invalid slabs encountered. Reject this voxel.
+			delete voxel;
+			return NULL;
+		}
+	}
+
+	voxel->LumpNum = lumpnum;
+	voxel->Palette = new BYTE[768];
+	memcpy(voxel->Palette, rawvoxel + voxelsize - 768, 768);
+
+	return voxel;
+}
+
+//==========================================================================
+//
+// FVoxelMipLevel Constructor
+//
+//==========================================================================
+
+FVoxelMipLevel::FVoxelMipLevel()
+{
+	SizeZ = SizeY = SizeX = 0;
+	PivotZ = PivotY = PivotX = 0;
+	OffsetX = NULL;
+	OffsetXY = NULL;
+	SlabData = NULL;
+}
+
+//==========================================================================
+//
+// FVoxelMipLevel Destructor
+//
+//==========================================================================
+
+FVoxelMipLevel::~FVoxelMipLevel()
+{
+	if (OffsetX != NULL)
+	{
+		delete[] OffsetX;
+	}
+}
+
+//==========================================================================
+//
+// FVoxel Constructor
+//
+//==========================================================================
+
+FVoxel::FVoxel()
+{
+	Palette = NULL;
+}
+
+FVoxel::~FVoxel()
+{
+	if (Palette != NULL) delete [] Palette;
+}
+
+//==========================================================================
+//
+// Remap the voxel to the game palette
+//
+//==========================================================================
+
+void FVoxel::Remap()
+{
+	if (Palette != NULL)
+	{
+		BYTE *remap = GetVoxelRemap(Palette);
+		for (int i = 0; i < NumMips; ++i)
+		{
+			RemapVoxelSlabs((kvxslab_t *)Mips[i].SlabData, Mips[i].OffsetX[Mips[i].SizeX], remap);
+		}
+		delete [] Palette;
+		Palette = NULL;
+	}
+}
 
 //==========================================================================
 //
@@ -389,10 +687,4 @@ CCMD (printspans)
 		Printf ("\n");
 	}
 }
-
-CCMD (picnum)
-{
-	//int picnum = TexMan.GetTexture (argv[1], FTexture::TEX_Any);
-	//Printf ("%d: %s - %s\n", picnum, TexMan[picnum]->Name, TexMan(picnum)->Name);
-}
 #endif
diff --git a/src/r_data.h b/src/r_data.h
index 487860e589..d2f25dfa97 100644
--- a/src/r_data.h
+++ b/src/r_data.h
@@ -144,4 +144,6 @@ extern size_t numfakecmaps;
 
 int R_FindSkin (const char *name, int pclass);	// [RH] Find a skin
 
+FVoxel *R_LoadKVX(int lumpnum);
+
 #endif
diff --git a/src/r_defs.h b/src/r_defs.h
index e86c2ea85a..008002548f 100644
--- a/src/r_defs.h
+++ b/src/r_defs.h
@@ -25,6 +25,7 @@
 
 #include "doomdef.h"
 #include "templates.h"
+#include "memarena.h"
 
 // Some more or less basic data types
 // we depend on.
@@ -1038,7 +1039,6 @@ struct column_t
 
 typedef BYTE lighttable_t;	// This could be wider for >8 bit display.
 
-
 // A vissprite_t is a thing
 //	that will be drawn during a refresh.
 // I.e. a sprite object that is partly visible.
@@ -1046,8 +1046,9 @@ struct vissprite_t
 {
 	short			x1, x2;
 	fixed_t			cx;				// for line side calculation
-	fixed_t			gx, gy;			// for drawseg and fake floor clipping
-	fixed_t			gz, gzt;		// global bottom / top for silhouette clipping
+	fixed_t			gx, gy, gz;		// origin in world coordinates
+	angle_t			angle;
+	fixed_t			gzb, gzt;		// global bottom / top for silhouette clipping
 	fixed_t			startfrac;		// horizontal position of x1
 	fixed_t			xscale, yscale;
 	fixed_t			xiscale;		// negative if flipped
@@ -1060,12 +1061,17 @@ struct vissprite_t
 	sector_t		*sector;		// [RH] sector this sprite is in
 	fixed_t			alpha;
 	fixed_t			floorclip;
-	FTexture		*pic;
+	union
+	{
+		FTexture	  *pic;
+		struct FVoxel *voxel;
+	};
+	BYTE			bIsVoxel:1;		// [RH] Use voxel instead of pic
+	BYTE			bSplitSprite:1;	// [RH] Sprite was split by a drawseg
+	BYTE			FakeFlatStat;	// [RH] which side of fake/floor ceiling sprite is on
 	short 			renderflags;
 	DWORD			Translation;	// [RH] for color translation
 	FRenderStyle	RenderStyle;
-	BYTE			FakeFlatStat;	// [RH] which side of fake/floor ceiling sprite is on
-	BYTE			bSplitSprite;	// [RH] Sprite was split by a drawseg
 };
 
 enum
@@ -1087,14 +1093,16 @@ enum
 //
 struct spriteframe_t
 {
+	struct FVoxelDef *Voxel;// voxel to use for this frame
 	FTextureID Texture[16];	// texture to use for view angles 0-15
-	WORD Flip;			// flip (1 = flip) to use for view angles 0-15.
+	WORD Flip;				// flip (1 = flip) to use for view angles 0-15.
 };
 
 //
 // A sprite definition:
 //	a number of animation frames.
 //
+
 struct spritedef_t
 {
 	union
@@ -1127,4 +1135,77 @@ public:
 	int			namespc;	// namespace for this skin
 };
 
+
+// [RH] Voxels from Build
+
+#define MAXVOXMIPS 5
+
+struct kvxslab_t
+{
+	BYTE		ztop;			// starting z coordinate of top of slab
+	BYTE		zleng;			// # of bytes in the color array - slab height
+	BYTE		backfacecull;	// low 6 bits tell which of 6 faces are exposed
+	BYTE		col[1/*zleng*/];// color data from top to bottom
+};
+
+struct FVoxelMipLevel
+{
+	FVoxelMipLevel();
+	~FVoxelMipLevel();
+
+	int			SizeX;
+	int			SizeY;
+	int			SizeZ;
+	fixed_t		PivotX;		// 24.8 fixed point
+	fixed_t		PivotY;		// ""
+	fixed_t		PivotZ;		// ""
+	int			*OffsetX;
+	short		*OffsetXY;
+	BYTE		*SlabData;
+};
+
+struct FVoxel
+{
+	int LumpNum;
+	int NumMips;
+	BYTE *Palette;
+	FVoxelMipLevel Mips[MAXVOXMIPS];
+
+	FVoxel();
+	~FVoxel();
+	void Remap();
+};
+
+struct FVoxelDef
+{
+	FVoxel *Voxel;
+	int PlacedSpin;			// degrees/sec to spin actors without MF_DROPPED set
+	int DroppedSpin;		// degrees/sec to spin actors with MF_DROPPED set
+	fixed_t Scale;
+	angle_t AngleOffset;	// added to actor's angle to compensate for wrong-facing voxels
+};
+
+// [RH] A c-buffer. Used for keeping track of offscreen voxel spans.
+
+struct FCoverageBuffer
+{
+	struct Span
+	{
+		Span *NextSpan;
+		short Start, Stop;
+	};
+
+	FCoverageBuffer(int size);
+	~FCoverageBuffer();
+
+	void Clear();
+	void InsertSpan(int listnum, int start, int stop);
+	Span *AllocSpan();
+
+	FMemArena SpanArena;
+	Span **Spans;	// [0..NumLists-1] span lists
+	Span *FreeSpans;
+	unsigned int NumLists;
+};
+
 #endif
diff --git a/src/r_draw.cpp b/src/r_draw.cpp
index ba77ad2d8c..36c87fa89e 100644
--- a/src/r_draw.cpp
+++ b/src/r_draw.cpp
@@ -141,6 +141,7 @@ FRenderStyle LegacyRenderStyles[STYLE_Count] =
 			 /* STYLE_Add */  {{ STYLEOP_Add,		STYLEALPHA_Src,		STYLEALPHA_One,		0 }},
 		  /* STYLE_Shaded */  {{ STYLEOP_Add,		STYLEALPHA_Src,		STYLEALPHA_InvSrc,	STYLEF_RedIsAlpha | STYLEF_ColorIsFixed }},
 /* STYLE_TranslucentStencil */{{ STYLEOP_Add,		STYLEALPHA_Src,		STYLEALPHA_InvSrc,	STYLEF_ColorIsFixed }},
+            /* STYLE_Shadow */{{ STYLEOP_Shadow,	0,					0,					0 }},
 };
 #else
 FRenderStyle LegacyRenderStyles[STYLE_Count];
@@ -157,6 +158,7 @@ static const BYTE Styles[STYLE_Count * 4] =
 	STYLEOP_Add,		STYLEALPHA_Src,		STYLEALPHA_One,		0,
 	STYLEOP_Add,		STYLEALPHA_Src,		STYLEALPHA_InvSrc,	STYLEF_RedIsAlpha | STYLEF_ColorIsFixed,
 	STYLEOP_Add,		STYLEALPHA_Src,		STYLEALPHA_InvSrc,	STYLEF_ColorIsFixed,
+	STYLEOP_Shadow,		0,					0,					0
 };
 
 static struct LegacyInit
@@ -1350,6 +1352,97 @@ void R_FillSpan (void)
 	memset (ylookup[ds_y] + ds_x1 + dc_destorg, ds_color, ds_x2 - ds_x1 + 1);
 }
 
+// Draw a voxel slab
+//
+// "Build Engine & Tools" Copyright (c) 1993-1997 Ken Silverman
+// Ken Silverman's official web site: "http://www.advsys.net/ken"
+// See the included license file "BUILDLIC.TXT" for license info.
+
+// Actually, this is just R_DrawColumn with an extra width parameter.
+
+#ifndef X86_ASM
+static const BYTE *slabcolormap;
+
+extern "C" void R_SetupDrawSlab(const BYTE *colormap)
+{
+	slabcolormap = colormap;
+}
+
+extern "C" void STACK_ARGS R_DrawSlab(int dx, fixed_t v, int dy, fixed_t vi, const BYTE *vptr, BYTE *p)
+{
+	int x;
+	const BYTE *colormap = slabcolormap;
+	int pitch = dc_pitch;
+
+	assert(dx > 0);
+
+	if (dx == 1)
+	{
+		while (dy > 0)
+		{
+			*p = colormap[vptr[v >> FRACBITS]];
+			p += pitch;
+			v += vi;
+			dy--;
+		}
+	}
+	else if (dx == 2)
+	{
+		while (dy > 0)
+		{
+			BYTE color = colormap[vptr[v >> FRACBITS]];
+			p[0] = color;
+			p[1] = color;
+			p += pitch;
+			v += vi;
+			dy--;
+		}
+	}
+	else if (dx == 3)
+	{
+		while (dy > 0)
+		{
+			BYTE color = colormap[vptr[v >> FRACBITS]];
+			p[0] = color;
+			p[1] = color;
+			p[2] = color;
+			p += pitch;
+			v += vi;
+			dy--;
+		}
+	}
+	else if (dx == 4)
+	{
+		while (dy > 0)
+		{
+			BYTE color = colormap[vptr[v >> FRACBITS]];
+			p[0] = color;
+			p[1] = color;
+			p[2] = color;
+			p[3] = color;
+			p += pitch;
+			v += vi;
+			dy--;
+		}
+	}
+	else while (dy > 0)
+	{
+		BYTE color = colormap[vptr[v >> FRACBITS]];
+		// The optimizer will probably turn this into a memset call.
+		// Since dx is not likely to be large, I'm not sure that's a good thing,
+		// hence the alternatives above.
+		for (x = 0; x < dx; x++)
+		{
+			p[x] = color;
+		}
+		p += pitch;
+		v += vi;
+		dy--;
+	}
+}
+#endif
+
+
 /****************************************************/
 /****************************************************/
 
@@ -2068,7 +2161,7 @@ void R_InitColumnDrawers ()
 }
 
 // [RH] Choose column drawers in a single place
-EXTERN_CVAR (Bool, r_drawfuzz)
+EXTERN_CVAR (Int, r_drawfuzz)
 EXTERN_CVAR (Float, transsouls)
 CVAR (Bool, r_drawtrans, true, 0)
 
@@ -2235,6 +2328,13 @@ ESPSResult R_SetPatchStyle (FRenderStyle style, fixed_t alpha, int translation,
 
 	style.CheckFuzz();
 
+	if (style.BlendOp == STYLEOP_Shadow)
+	{
+		style = LegacyRenderStyles[STYLE_TranslucentStencil];
+		alpha = FRACUNIT*3/10;
+		color = 0;
+	}
+
 	if (style.Flags & STYLEF_TransSoulsAlpha)
 	{
 		alpha = fixed_t(transsouls * FRACUNIT);
@@ -2390,16 +2490,42 @@ bool FRenderStyle::IsVisible(fixed_t alpha) const throw()
 
 void FRenderStyle::CheckFuzz()
 {
-	if (BlendOp == STYLEOP_FuzzOrAdd)
+	switch (BlendOp)
 	{
-		BlendOp = (r_drawfuzz || !r_drawtrans) ? STYLEOP_Fuzz : STYLEOP_Add;
+	default:
+		return;
+
+	case STYLEOP_FuzzOrAdd:
+		if (r_drawtrans && r_drawfuzz == 0)
+		{
+			BlendOp = STYLEOP_Add;
+			return;
+		}
+		break;
+
+	case STYLEOP_FuzzOrSub:
+		if (r_drawtrans && r_drawfuzz == 0)
+		{
+			BlendOp = STYLEOP_Sub;
+			return;
+		}
+		break;
+
+	case STYLEOP_FuzzOrRevSub:
+		if (r_drawtrans && r_drawfuzz == 0)
+		{
+			BlendOp = STYLEOP_RevSub;
+			return;
+		}
+		break;
 	}
-	else if (BlendOp == STYLEOP_FuzzOrSub)
+
+	if (r_drawfuzz == 2)
 	{
-		BlendOp = (r_drawfuzz || !r_drawtrans) ? STYLEOP_Fuzz : STYLEOP_Sub;
+		BlendOp = STYLEOP_Shadow;
 	}
-	else if (BlendOp == STYLEOP_FuzzOrRevSub)
+	else
 	{
-		BlendOp = (r_drawfuzz || !r_drawtrans) ? STYLEOP_Fuzz : STYLEOP_RevSub;
+		BlendOp = STYLEOP_Fuzz;
 	}
 }
diff --git a/src/r_draw.h b/src/r_draw.h
index 96e58bf8da..57dfd8712d 100644
--- a/src/r_draw.h
+++ b/src/r_draw.h
@@ -53,7 +53,7 @@ extern "C" BYTE*		palookupoffse[4];
 extern "C" const BYTE*	bufplce[4];
 
 // [RH] Temporary buffer for column drawing
-extern "C" BYTE			dc_temp[MAXHEIGHT*4];
+extern "C" BYTE			*dc_temp;
 extern "C" unsigned int	dc_tspans[4][MAXHEIGHT];
 extern "C" unsigned int	*dc_ctspan[4];
 extern "C" unsigned int	horizspans[4];
@@ -178,7 +178,7 @@ extern void (STACK_ARGS *rt_map4cols)(int sx, int yl, int yh);
 void rt_draw4cols (int sx);
 
 // [RH] Preps the temporary horizontal buffer.
-void rt_initcols (void);
+void rt_initcols (BYTE *buffer=NULL);
 
 void R_DrawFogBoundary (int x1, int x2, short *uclip, short *dclip);
 
@@ -216,6 +216,9 @@ void	R_FillColumnP (void);
 void	R_FillColumnHorizP (void);
 void	R_FillSpan (void);
 
+extern "C" void			   R_SetupDrawSlab(const BYTE *colormap);
+extern "C" void STACK_ARGS R_DrawSlab(int dx, fixed_t v, int dy, fixed_t vi, const BYTE *vptr, BYTE *p);
+
 extern "C" int				ds_y;
 extern "C" int				ds_x1;
 extern "C" int				ds_x2;
diff --git a/src/r_drawt.cpp b/src/r_drawt.cpp
index fbfaf6307d..c99bd3afbc 100644
--- a/src/r_drawt.cpp
+++ b/src/r_drawt.cpp
@@ -52,9 +52,13 @@
 // dc_temp is the buffer R_DrawColumnHoriz writes into.
 // dc_tspans points into it.
 // dc_ctspan points into dc_tspans.
-// But what is horizspan, and what is its relation with dc_ctspan?
+// horizspan also points into dc_tspans.
 
-BYTE dc_temp[MAXHEIGHT*4];
+// dc_ctspan is advanced while drawing into dc_temp.
+// horizspan is advanced up to dc_ctspan when drawing from dc_temp to the screen.
+
+BYTE dc_tempbuff[MAXHEIGHT*4];
+BYTE *dc_temp;
 unsigned int dc_tspans[4][MAXHEIGHT];
 unsigned int *dc_ctspan[4];
 unsigned int *horizspan[4];
@@ -998,10 +1002,11 @@ void rt_draw4cols (int sx)
 
 // Before each pass through a rendering loop that uses these routines,
 // call this function to set up the span pointers.
-void rt_initcols (void)
+void rt_initcols (BYTE *buff)
 {
 	int y;
 
+	dc_temp = buff == NULL ? dc_tempbuff : buff;
 	for (y = 3; y >= 0; y--)
 		horizspan[y] = dc_ctspan[y] = &dc_tspans[y][0];
 }
@@ -1035,26 +1040,18 @@ void R_DrawColumnHorizP_C (void)
 		const BYTE *source = dc_source;
 
 		if (count & 1) {
-			*dest = source[frac>>FRACBITS];
-			dest += 4;
-			frac += fracstep;
+			*dest = source[frac>>FRACBITS]; dest += 4; frac += fracstep;
 		}
 		if (count & 2) {
-			dest[0] = source[frac>>FRACBITS];
-			frac += fracstep;
-			dest[4] = source[frac>>FRACBITS];
-			frac += fracstep;
+			dest[0] = source[frac>>FRACBITS]; frac += fracstep;
+			dest[4] = source[frac>>FRACBITS]; frac += fracstep;
 			dest += 8;
 		}
 		if (count & 4) {
-			dest[0] = source[frac>>FRACBITS];
-			frac += fracstep;
-			dest[4] = source[frac>>FRACBITS];
-			frac += fracstep;
-			dest[8] = source[frac>>FRACBITS];
-			frac += fracstep;
-			dest[12] = source[frac>>FRACBITS];
-			frac += fracstep;
+			dest[0] = source[frac>>FRACBITS]; frac += fracstep;
+			dest[4] = source[frac>>FRACBITS]; frac += fracstep;
+			dest[8] = source[frac>>FRACBITS]; frac += fracstep;
+			dest[12]= source[frac>>FRACBITS]; frac += fracstep;
 			dest += 16;
 		}
 		count >>= 3;
@@ -1062,22 +1059,14 @@ void R_DrawColumnHorizP_C (void)
 
 		do
 		{
-			dest[0] = source[frac>>FRACBITS];
-			frac += fracstep;
-			dest[4] = source[frac>>FRACBITS];
-			frac += fracstep;
-			dest[8] = source[frac>>FRACBITS];
-			frac += fracstep;
-			dest[12] = source[frac>>FRACBITS];
-			frac += fracstep;
-			dest[16] = source[frac>>FRACBITS];
-			frac += fracstep;
-			dest[20] = source[frac>>FRACBITS];
-			frac += fracstep;
-			dest[24] = source[frac>>FRACBITS];
-			frac += fracstep;
-			dest[28] = source[frac>>FRACBITS];
-			frac += fracstep;
+			dest[0] = source[frac>>FRACBITS]; frac += fracstep;
+			dest[4] = source[frac>>FRACBITS]; frac += fracstep;
+			dest[8] = source[frac>>FRACBITS]; frac += fracstep;
+			dest[12]= source[frac>>FRACBITS]; frac += fracstep;
+			dest[16]= source[frac>>FRACBITS]; frac += fracstep;
+			dest[20]= source[frac>>FRACBITS]; frac += fracstep;
+			dest[24]= source[frac>>FRACBITS]; frac += fracstep;
+			dest[28]= source[frac>>FRACBITS]; frac += fracstep;
 			dest += 32;
 		} while (--count);
 	}
@@ -1110,8 +1099,7 @@ void R_FillColumnHorizP (void)
 	if (!(count >>= 1))
 		return;
 	do {
-		dest[0] = color;
-		dest[4] = color;
+		dest[0] = color; dest[4] = color;
 		dest += 8;
 	} while (--count);
 }
diff --git a/src/r_main.cpp b/src/r_main.cpp
index 8e78cb44a8..0f3a8fe75b 100644
--- a/src/r_main.cpp
+++ b/src/r_main.cpp
@@ -103,7 +103,6 @@ static fixed_t MaxVisForFloor;
 static FRandom pr_torchflicker ("TorchFlicker");
 static FRandom pr_hom;
 static TArray<InterpolationViewer> PastViewers;
-static int centerxwide;
 static bool polyclipped;
 static bool r_showviewer;
 bool r_dontmaplines;
@@ -135,6 +134,7 @@ float			LastFOV;
 int				WidescreenRatio;
 
 fixed_t			GlobVis;
+fixed_t			viewingrangerecip;
 fixed_t			FocalTangent;
 fixed_t			FocalLengthX;
 fixed_t			FocalLengthY;
@@ -151,6 +151,8 @@ float			WallTMapScale2;
 extern "C" {
 int 			centerx;
 int				centery;
+int				centerxwide;
+
 }
 
 DCanvas			*RenderTarget;		// [RH] canvas to render to
@@ -159,6 +161,7 @@ fixed_t			globaluclip, globaldclip;
 fixed_t 		centerxfrac;
 fixed_t 		centeryfrac;
 fixed_t			yaspectmul;
+fixed_t			baseyaspectmul;		// yaspectmul without a forced aspect ratio
 float			iyaspectmulfloat;
 fixed_t			InvZtoScale;
 
@@ -458,6 +461,9 @@ void R_InitTextureMapping ()
 	FocalLengthY = Scale (centerxfrac, yaspectmul, hitan);
 	FocalLengthXfloat = (float)FocalLengthX / 65536.f;
 
+	// This is 1/FocalTangent before the widescreen extension of FOV.
+	viewingrangerecip = DivScale32(1, finetangent[FINEANGLES/4+(FieldOfView/2)]);
+
 	// Now generate xtoviewangle for sky texture mapping.
 	// [RH] Do not generate viewangletox, because texture mapping is no
 	// longer done with trig, so it's not needed.
@@ -600,7 +606,7 @@ void R_SetViewSize (int blocks)
 
 void R_SetWindow (int windowSize, int fullWidth, int fullHeight, int stHeight)
 {
-	int virtheight, virtwidth;
+	int virtheight, virtwidth, trueratio, virtwidth2, virtheight2;
 
 	if (windowSize >= 11)
 	{
@@ -621,7 +627,7 @@ void R_SetWindow (int windowSize, int fullWidth, int fullHeight, int stHeight)
 	}
 
 	// If the screen is approximately 16:9 or 16:10, consider it widescreen.
-	WidescreenRatio = CheckRatio (fullWidth, fullHeight);
+	WidescreenRatio = CheckRatio (fullWidth, fullHeight, &trueratio);
 
 	DrawFSHUD = (windowSize == 11);
 	
@@ -644,8 +650,18 @@ void R_SetWindow (int windowSize, int fullWidth, int fullHeight, int stHeight)
 	centerxfrac = centerx<<FRACBITS;
 	centeryfrac = centery<<FRACBITS;
 
-	virtwidth = fullWidth;
-	virtheight = fullHeight;
+	virtwidth = virtwidth2 = fullWidth;
+	virtheight = virtheight2 = fullHeight;
+
+	if (trueratio & 4)
+	{
+		virtheight2 = virtheight2 * BaseRatioSizes[trueratio][3] / 48;
+	}
+	else
+	{
+		virtwidth2 = virtwidth2 * BaseRatioSizes[trueratio][3] / 48;
+	}
+
 	if (WidescreenRatio & 4)
 	{
 		virtheight = virtheight * BaseRatioSizes[WidescreenRatio][3] / 48;
@@ -657,6 +673,7 @@ void R_SetWindow (int windowSize, int fullWidth, int fullHeight, int stHeight)
 		centerxwide = centerx * BaseRatioSizes[WidescreenRatio][3] / 48;
 	}
 
+	baseyaspectmul = Scale(320 << FRACBITS, virtheight2, r_Yaspect * virtwidth2);
 	yaspectmul = Scale ((320<<FRACBITS), virtheight, r_Yaspect * virtwidth);
 	iyaspectmulfloat = (float)virtwidth * r_Yaspect / 320.f / (float)virtheight;
 	InvZtoScale = yaspectmul * centerx;
diff --git a/src/r_main.h b/src/r_main.h
index c894a2bcf4..d91450a349 100644
--- a/src/r_main.h
+++ b/src/r_main.h
@@ -43,6 +43,7 @@ extern fixed_t			viewsin;
 extern fixed_t			viewtancos;
 extern fixed_t			viewtansin;
 extern fixed_t			FocalTangent;
+extern fixed_t			viewingrangerecip;
 extern fixed_t			FocalLengthX, FocalLengthY;
 extern float			FocalLengthXfloat;
 extern fixed_t			InvZtoScale;
@@ -62,7 +63,7 @@ extern int				viewwindowy;
 
 
 
-extern "C" int			centerx;
+extern "C" int			centerx, centerxwide;
 extern "C" int			centery;
 
 extern fixed_t			centerxfrac;
diff --git a/src/r_plane.cpp b/src/r_plane.cpp
index d209976bf6..b26e238673 100644
--- a/src/r_plane.cpp
+++ b/src/r_plane.cpp
@@ -593,7 +593,7 @@ visplane_t *R_FindPlane (const secplane_t &height, FTextureID picnum, int lightl
 						check->viewz == stacked_viewz &&
 						(
 							// headache inducing logic... :(
-							(ib_compatflags & BCOMPATF_BADPORTALS) ||
+							(!(skybox->flags & MF_JUSTATTACKED)) ||
 							(
 								check->alpha == alpha &&
 								(alpha == 0 ||	// if alpha is > 0 everything needs to be checked
diff --git a/src/r_things.cpp b/src/r_things.cpp
index 6b2c3563ed..262330329b 100644
--- a/src/r_things.cpp
+++ b/src/r_things.cpp
@@ -19,6 +19,12 @@
 // DESCRIPTION:
 //		Refresh of things, i.e. objects represented by sprites.
 //
+// This file contains some code from the Build Engine.
+//
+// "Build Engine & Tools" Copyright (c) 1993-1997 Ken Silverman
+// Ken Silverman's official web site: "http://www.advsys.net/ken"
+// See the included license file "BUILDLIC.TXT" for license info.
+//
 //-----------------------------------------------------------------------------
 
 #include <stdio.h>
@@ -54,7 +60,6 @@
 #include "v_palette.h"
 #include "r_translate.h"
 
-
 extern fixed_t globaluclip, globaldclip;
 
 
@@ -62,7 +67,7 @@ extern fixed_t globaluclip, globaldclip;
 #define BASEYCENTER 	(100)
 
 EXTERN_CVAR (Bool, st_scale)
-CVAR (Bool, r_drawfuzz, true, CVAR_ARCHIVE)
+CVAR (Int, r_drawfuzz, 1, CVAR_ARCHIVE)
 
 
 //
@@ -95,6 +100,8 @@ short			screenheightarray[MAXWIDTH];
 
 CVAR (Bool, r_drawplayersprites, true, 0)	// [RH] Draw player sprites?
 
+CVAR (Bool, r_drawvoxels, true, 0)
+
 //
 // INITIALIZATION FUNCTIONS
 //
@@ -105,6 +112,13 @@ TArray<spritedef_t> sprites;
 TArray<spriteframe_t> SpriteFrames;
 DWORD			NumStdSprites;		// The first x sprites that don't belong to skins.
 
+TDeletingArray<FVoxel *> Voxels;	// used only to auto-delete voxels on exit.
+TDeletingArray<FVoxelDef *> VoxelDefs;
+
+int OffscreenBufferWidth, OffscreenBufferHeight;
+BYTE *OffscreenColorBuffer;
+FCoverageBuffer *OffscreenCoverageBuffer;
+
 struct spriteframewithrotate : public spriteframe_t
 {
 	int rotate;
@@ -113,6 +127,18 @@ sprtemp[MAX_SPRITE_FRAMES];
 int 			maxframe;
 char*			spritename;
 
+struct VoxelOptions
+{
+	VoxelOptions()
+	: DroppedSpin(0), PlacedSpin(0), Scale(FRACUNIT), AngleOffset(0)
+	{}
+
+	int			DroppedSpin;
+	int			PlacedSpin;
+	fixed_t		Scale;
+	angle_t		AngleOffset;
+};
+
 // [RH] skin globals
 FPlayerSkin		*skins;
 size_t			numskins;
@@ -291,7 +317,9 @@ static void R_InstallSprite (int num)
 	{
 		if (sprtemp[frame].rotate == -1)
 		{
-			memset (&sprtemp[frame], 0, sizeof(sprtemp[0]));
+			memset (&sprtemp[frame].Texture, 0, sizeof(sprtemp[0].Texture));
+			sprtemp[frame].Flip = 0;
+			sprtemp[frame].rotate = 0;
 		}
 	}
 	
@@ -302,6 +330,7 @@ static void R_InstallSprite (int num)
 	{
 		memcpy (SpriteFrames[framestart+frame].Texture, sprtemp[frame].Texture, sizeof(sprtemp[frame].Texture));
 		SpriteFrames[framestart+frame].Flip = sprtemp[frame].Flip;
+		SpriteFrames[framestart+frame].Voxel = sprtemp[frame].Voxel;
 	}
 
 	// Let the textures know about the rotations
@@ -339,41 +368,100 @@ void R_InitSpriteDefs ()
 	{
 		int Head, Next;
 	} *hashes;
-	unsigned int i, max;
+	struct VHasher
+	{
+		int Head, Next, Name, Spin;
+		char Frame;
+	} *vhashes;
+	unsigned int i, j, smax, vmax;
 	DWORD intname;
 
 	// Create a hash table to speed up the process
-	max = TexMan.NumTextures();
-	hashes = (Hasher *)alloca (sizeof(Hasher) * max);
-	for (i = 0; i < max; ++i)
-	{
-		hashes[i].Head = -1;
-	}
-	for (i = 0; i < max; ++i)
+	smax = TexMan.NumTextures();
+	hashes = new Hasher[smax];
+	clearbuf(hashes, sizeof(Hasher)*smax/4, -1);
+	for (i = 0; i < smax; ++i)
 	{
 		FTexture *tex = TexMan.ByIndex(i);
 		if (tex->UseType == FTexture::TEX_Sprite && strlen(tex->Name) >= 6)
 		{
-			DWORD bucket = tex->dwName % max;
+			size_t bucket = tex->dwName % smax;
 			hashes[i].Next = hashes[bucket].Head;
 			hashes[bucket].Head = i;
 		}
 	}
 
+	// Repeat, for voxels
+	vmax = Wads.GetNumLumps();
+	vhashes = new VHasher[vmax];
+	clearbuf(vhashes, sizeof(VHasher)*vmax/4, -1);
+	for (i = 0; i < vmax; ++i)
+	{
+		if (Wads.GetLumpNamespace(i) == ns_voxels)
+		{
+			char name[9];
+			size_t namelen;
+			int spin;
+			int sign;
+
+			Wads.GetLumpName(name, i);
+			name[8] = 0;
+			namelen = strlen(name);
+			if (namelen < 4)
+			{ // name is too short
+				continue;
+			}
+			if (name[4] != '\0' && name[4] != ' ' && (name[4] < 'A' || name[4] >= 'A' + MAX_SPRITE_FRAMES))
+			{ // frame char is invalid
+				continue;
+			}
+			spin = 0;
+			sign = 2;	// 2 to convert from deg/halfsec to deg/sec
+			j = 5;
+			if (j < namelen && name[j] == '-')
+			{ // a minus sign is okay, but only before any digits
+				j++;
+				sign = -2;
+			}
+			for (; j < namelen; ++j)
+			{ // the remainder to the end of the name must be digits
+				if (name[j] >= '0' && name[j] <= '9')
+				{
+					spin = spin * 10 + name[j] - '0';
+				}
+				else
+				{
+					break;
+				}
+			}
+			if (j < namelen)
+			{ // the spin part is invalid
+				continue;
+			}
+			memcpy(&vhashes[i].Name, name, 4);
+			vhashes[i].Frame = name[4];
+			vhashes[i].Spin = spin * sign;
+			size_t bucket = vhashes[i].Name % vmax;
+			vhashes[i].Next = vhashes[bucket].Head;
+			vhashes[bucket].Head = i;
+		}
+	}
+
 	// scan all the lump names for each of the names, noting the highest frame letter.
 	for (i = 0; i < sprites.Size(); ++i)
 	{
 		memset (sprtemp, 0xFF, sizeof(sprtemp));
-		for (int j = 0; j < MAX_SPRITE_FRAMES; ++j)
+		for (j = 0; j < MAX_SPRITE_FRAMES; ++j)
 		{
 			sprtemp[j].Flip = 0;
+			sprtemp[j].Voxel = NULL;
 		}
 				
 		maxframe = -1;
 		intname = sprites[i].dwName;
 
 		// scan the lumps, filling in the frames for whatever is found
-		int hash = hashes[intname % max].Head;
+		int hash = hashes[intname % smax].Head;
 		while (hash != -1)
 		{
 			FTexture *tex = TexMan[hash];
@@ -386,9 +474,345 @@ void R_InitSpriteDefs ()
 			}
 			hash = hashes[hash].Next;
 		}
+
+		// repeat, for voxels
+		hash = vhashes[intname % vmax].Head;
+		while (hash != -1)
+		{
+			VHasher *vh = &vhashes[hash];
+			if (vh->Name == intname)
+			{
+				FVoxel *vox = R_LoadKVX(hash);
+				if (vox == NULL)
+				{
+					Printf("%s is not a valid voxel file\n", Wads.GetLumpFullName(hash));
+				}
+				else
+				{
+					FVoxelDef *voxdef = new FVoxelDef;
+
+					voxdef->Voxel = vox;
+					voxdef->Scale = FRACUNIT;
+					voxdef->DroppedSpin = voxdef->PlacedSpin = vh->Spin;
+					voxdef->AngleOffset = 0;
+
+					Voxels.Push(vox);
+					VoxelDefs.Push(voxdef);
+
+					if (vh->Frame == ' ' || vh->Frame == '\0')
+					{ // voxel applies to every sprite frame
+						for (j = 0; j < MAX_SPRITE_FRAMES; ++j)
+						{
+							if (sprtemp[j].Voxel == NULL)
+							{
+								sprtemp[j].Voxel = voxdef;
+							}
+						}
+						maxframe = MAX_SPRITE_FRAMES-1;
+					}
+					else
+					{ // voxel applies to a specific frame
+						j = vh->Frame - 'A';
+						sprtemp[j].Voxel = voxdef;
+						maxframe = MAX<int>(maxframe, j);
+					}
+				}
+			}
+			hash = vh->Next;
+		}
 		
 		R_InstallSprite ((int)i);
 	}
+
+	delete[] hashes;
+	delete[] vhashes;
+}
+
+//==========================================================================
+//
+// R_ExtendSpriteFrames
+//
+// Extends a sprite so that it can hold the desired frame.
+//
+//==========================================================================
+
+static void R_ExtendSpriteFrames(spritedef_t &spr, int frame)
+{
+	unsigned int i, newstart;
+
+	if (spr.numframes >= ++frame)
+	{ // The sprite already has enough frames, so do nothing.
+		return;
+	}
+
+	if (spr.numframes == 0 || (spr.spriteframes + spr.numframes == SpriteFrames.Size()))
+	{ // Sprite's frames are at the end of the array, or it has no frames
+	  // at all, so we can tack the new frames directly on to the end
+	  // of the SpriteFrames array.
+		newstart = SpriteFrames.Reserve(frame - spr.numframes);
+	}
+	else
+	{ // We need to allocate space for all the sprite's frames and copy
+	  // the existing ones over to the new space. The old space will be
+	  // lost.
+		newstart = SpriteFrames.Reserve(frame);
+		for (i = 0; i < spr.numframes; ++i)
+		{
+			SpriteFrames[newstart + i] = SpriteFrames[spr.spriteframes + i];
+		}
+		spr.spriteframes = WORD(newstart);
+		newstart += i;
+	}
+	// Initialize all new frames to 0.
+	memset(&SpriteFrames[newstart], 0, sizeof(spriteframe_t)*(frame - spr.numframes));
+	spr.numframes = frame;
+}
+
+//==========================================================================
+//
+// VOX_ReadSpriteNames
+//
+// Reads a list of sprite names from a VOXELDEF lump.
+//
+//==========================================================================
+
+static bool VOX_ReadSpriteNames(FScanner &sc, TArray<DWORD> &vsprites)
+{
+	unsigned int i;
+
+	vsprites.Clear();
+	while (sc.GetString())
+	{
+		// A sprite name list is terminated by an '=' character.
+		if (sc.String[0] == '=')
+		{
+			if (vsprites.Size() == 0)
+			{
+				sc.ScriptMessage("No sprites specified for voxel.\n");
+			}
+			return true;
+		}
+		if (sc.StringLen != 4 && sc.StringLen != 5)
+		{
+			sc.ScriptMessage("Sprite name \"%s\" is wrong size.\n", sc.String);
+		}
+		else if (sc.StringLen == 5 && (sc.String[4] = toupper(sc.String[4]), sc.String[4] < 'A' || sc.String[4] >= 'A' + MAX_SPRITE_FRAMES))
+		{
+			sc.ScriptMessage("Sprite frame %s is invalid.\n", sc.String[4]);
+		}
+		else
+		{
+			int frame = (sc.StringLen == 4) ? 255 : sc.String[4] - 'A';
+			int spritename;
+
+			for (i = 0; i < 4; ++i)
+			{
+				sc.String[i] = toupper(sc.String[i]);
+			}
+			spritename = *(int *)sc.String;
+			for (i = 0; i < sprites.Size(); ++i)
+			{
+				if (sprites[i].dwName == spritename)
+				{
+					break;
+				}
+			}
+			if (i != sprites.Size())
+			{
+				vsprites.Push((frame << 24) | i);
+			}
+		}
+	}
+	if (vsprites.Size() != 0)
+	{
+		sc.ScriptMessage("Unexpected end of file\n");
+	}
+	return false;
+}
+
+//==========================================================================
+//
+// VOX_ReadOptions
+//
+// Reads a list of options from a VOXELDEF lump, terminated with a '}'
+// character. The leading '{' must already be consumed
+//
+//==========================================================================
+
+static void VOX_ReadOptions(FScanner &sc, VoxelOptions &opts)
+{
+	while (sc.GetToken())
+	{
+		if (sc.TokenType == '}')
+		{
+			return;
+		}
+		sc.TokenMustBe(TK_Identifier);
+		if (sc.Compare("scale"))
+		{
+			sc.MustGetToken('=');
+			sc.MustGetToken(TK_FloatConst);
+			opts.Scale = FLOAT2FIXED(sc.Float);
+		}
+		else if (sc.Compare("spin"))
+		{
+			sc.MustGetToken('=');
+			sc.MustGetToken(TK_IntConst);
+			opts.DroppedSpin = opts.PlacedSpin = sc.Number;
+		}
+		else if (sc.Compare("placedspin"))
+		{
+			sc.MustGetToken('=');
+			sc.MustGetToken(TK_IntConst);
+			opts.PlacedSpin = sc.Number;
+		}
+		else if (sc.Compare("droppedspin"))
+		{
+			sc.MustGetToken('=');
+			sc.MustGetToken(TK_IntConst);
+			opts.DroppedSpin = sc.Number;
+		}
+		else if (sc.Compare("angleoffset"))
+		{
+			sc.MustGetToken('=');
+			sc.MustGetAnyToken();
+			if (sc.TokenType == TK_IntConst)
+			{
+				sc.Float = sc.Number;
+			}
+			else
+			{
+				sc.TokenMustBe(TK_FloatConst);
+			}
+			opts.AngleOffset = angle_t(sc.Float * ANGLE_180 / 180.0);
+		}
+		else
+		{
+			sc.ScriptMessage("Unknown voxel option '%s'\n", sc.String);
+			if (sc.CheckToken('='))
+			{
+				sc.MustGetAnyToken();
+			}
+		}
+	}
+	sc.ScriptMessage("Unterminated voxel option block\n");
+}
+
+//==========================================================================
+//
+// VOX_GetVoxel
+//
+// Returns a voxel object for the given lump or NULL if it is not a valid
+// voxel. If the voxel has already been loaded, it will be reused.
+//
+//==========================================================================
+
+static FVoxel *VOX_GetVoxel(int lumpnum)
+{
+	// Is this voxel already loaded? If so, return it.
+	for (unsigned i = 0; i < Voxels.Size(); ++i)
+	{
+		if (Voxels[i]->LumpNum == lumpnum)
+		{
+			return Voxels[i];
+		}
+	}
+	FVoxel *vox = R_LoadKVX(lumpnum);
+	if (vox != NULL)
+	{
+		Voxels.Push(vox);
+	}
+	return vox;
+}
+
+//==========================================================================
+//
+// VOX_AddVoxel
+//
+// Sets a voxel for a single sprite frame.
+//
+//==========================================================================
+
+static void VOX_AddVoxel(int sprnum, int frame, FVoxelDef *def)
+{
+	R_ExtendSpriteFrames(sprites[sprnum], frame);
+	SpriteFrames[sprites[sprnum].spriteframes + frame].Voxel = def;
+}
+
+//==========================================================================
+//
+// R_InitVoxels
+//
+// Process VOXELDEF lumps for defining voxel options that cannot be
+// condensed neatly into a sprite name format.
+//
+//==========================================================================
+
+void R_InitVoxels()
+{
+	int lump, lastlump = 0;
+	
+	while ((lump = Wads.FindLump("VOXELDEF", &lastlump)) != -1)
+	{
+		FScanner sc(lump);
+		TArray<DWORD> vsprites;
+
+		while (VOX_ReadSpriteNames(sc, vsprites))
+		{
+			FVoxel *voxeldata = NULL;
+			int voxelfile;
+			VoxelOptions opts;
+
+			sc.SetCMode(true);
+			sc.MustGetToken(TK_StringConst);
+			voxelfile = Wads.CheckNumForFullName(sc.String, true, ns_voxels);
+			if (voxelfile < 0)
+			{
+				sc.ScriptMessage("Voxel \"%s\" not found.\n", sc.String);
+			}
+			else
+			{
+				voxeldata = VOX_GetVoxel(voxelfile);
+				if (voxeldata == NULL)
+				{
+					sc.ScriptMessage("\"%s\" is not a valid voxel file.\n", sc.String);
+				}
+			}
+			if (sc.CheckToken('{'))
+			{
+				VOX_ReadOptions(sc, opts);
+			}
+			sc.SetCMode(false);
+			if (voxeldata != NULL && vsprites.Size() != 0)
+			{
+				FVoxelDef *def = new FVoxelDef;
+
+				def->Voxel = voxeldata;
+				def->Scale = opts.Scale;
+				def->DroppedSpin = opts.DroppedSpin;
+				def->PlacedSpin = opts.PlacedSpin;
+				def->AngleOffset = opts.AngleOffset;
+				VoxelDefs.Push(def);
+
+				for (unsigned i = 0; i < vsprites.Size(); ++i)
+				{
+					int sprnum = int(vsprites[i] & 0xFFFFFF);
+					int frame = int(vsprites[i] >> 24);
+					if (frame == 255)
+					{ // Apply voxel to all frames.
+						for (int j = MAX_SPRITE_FRAMES - 1; j >= 0; --j)
+						{
+							VOX_AddVoxel(sprnum, j, def);
+						}
+					}
+					else
+					{ // Apply voxel to only one frame.
+						VOX_AddVoxel(sprnum, frame, def);
+					}
+				}
+			}
+		}
+	}
 }
 
 // [RH]
@@ -883,6 +1307,7 @@ void R_InitSprites ()
 	}
 
 	R_InitSpriteDefs ();
+	R_InitVoxels();		// [RH] Parse VOXELDEF
 	NumStdSprites = sprites.Size();
 	R_InitSkins ();		// [RH] Finish loading skin data
 
@@ -957,6 +1382,19 @@ void R_DeinitSprites()
 		spritesortersize = 0;
 		spritesorter = NULL;
 	}
+
+	// Free offscreen buffer
+	if (OffscreenColorBuffer != NULL)
+	{
+		delete[] OffscreenColorBuffer;
+		OffscreenColorBuffer = NULL;
+	}
+	if (OffscreenCoverageBuffer != NULL)
+	{
+		delete OffscreenCoverageBuffer;
+		OffscreenCoverageBuffer = NULL;
+	}
+	OffscreenBufferHeight = OffscreenBufferWidth = 0;
 }
 
 //
@@ -992,7 +1430,7 @@ vissprite_t *R_NewVisSprite (void)
 			*p = new vissprite_t;
 		}
 	}
-	
+
 	vissprite_p++;
 	return *(vissprite_p-1);
 }
@@ -1172,6 +1610,75 @@ void R_DrawVisSprite (vissprite_t *vis)
 	NetUpdate ();
 }
 
+void R_DrawVisVoxel(vissprite_t *spr, int minslabz, int maxslabz, short *cliptop, short *clipbot)
+{
+	ESPSResult mode;
+	int flags = 0;
+
+	// Do setup for blending.
+	dc_colormap = spr->colormap;
+	mode = R_SetPatchStyle(spr->RenderStyle, spr->alpha, spr->Translation, spr->FillColor);
+
+	if (mode == DontDraw)
+	{
+		return;
+	}
+	if (colfunc == fuzzcolfunc || colfunc == R_FillColumnP)
+	{
+		flags = DVF_OFFSCREEN | DVF_SPANSONLY;
+	}
+	else if (colfunc != basecolfunc)
+	{
+		flags = DVF_OFFSCREEN;
+	}
+	if (flags != 0)
+	{
+		R_CheckOffscreenBuffer(RenderTarget->GetWidth(), RenderTarget->GetHeight(), !!(flags & DVF_SPANSONLY));
+	}
+
+	// Render the voxel, either directly to the screen or offscreen.
+	R_DrawVoxel(spr->gx, spr->gy, spr->gz, spr->angle, spr->xscale, spr->yscale, spr->voxel, spr->colormap, cliptop, clipbot,
+		minslabz, maxslabz, flags);
+
+	// Blend the voxel, if that's what we need to do.
+	if (flags != 0)
+	{
+		for (int x = 0; x < viewwidth; ++x)
+		{
+			if (!(flags & DVF_SPANSONLY) && (x & 3) == 0)
+			{
+				rt_initcols(OffscreenColorBuffer + x * OffscreenBufferHeight);
+			}
+			for (FCoverageBuffer::Span *span = OffscreenCoverageBuffer->Spans[x]; span != NULL; span = span->NextSpan)
+			{
+				if (flags & DVF_SPANSONLY)
+				{
+					dc_x = x;
+					dc_yl = span->Start;
+					dc_yh = span->Stop - 1;
+					dc_count = span->Stop - span->Start;
+					dc_dest = ylookup[span->Start] + x + dc_destorg;
+					colfunc();
+				}
+				else
+				{
+					unsigned int **tspan = &dc_ctspan[x & 3];
+					(*tspan)[0] = span->Start;
+					(*tspan)[1] = span->Stop - 1;
+					*tspan += 2;
+				}
+			}
+			if (!(flags & DVF_SPANSONLY) && (x & 3) == 3)
+			{
+				rt_draw4cols(x - 3);
+			}
+		}
+	}
+
+	R_FinishSetPatchStyle();
+	NetUpdate();
+}
+
 //
 // R_ProjectSprite
 // Generates a vissprite for a thing if it might be visible.
@@ -1187,13 +1694,14 @@ void R_ProjectSprite (AActor *thing, int fakeside)
 	fixed_t 			tx, tx2;
 	fixed_t 			tz;
 
-	fixed_t 			xscale;
+	fixed_t 			xscale, yscale;
 	
 	int 				x1;
 	int 				x2;
 
 	FTextureID			picnum;
 	FTexture			*tex;
+	FVoxelDef			*voxel;
 	
 	WORD 				flip;
 	
@@ -1222,26 +1730,8 @@ void R_ProjectSprite (AActor *thing, int fakeside)
 
 	tz = DMulScale20 (tr_x, viewtancos, tr_y, viewtansin);
 
-	// thing is behind view plane?
-	if (tz < MINZ)
-		return;
-
-	tx = DMulScale16 (tr_x, viewsin, -tr_y, viewcos);
-
-	// [RH] Flip for mirrors
-	if (MirrorFlags & RF_XFLIP)
-	{
-		tx = -tx;
-	}
-	tx2 = tx >> 4;
-
-	// too far off the side?
-	if ((abs (tx) >> 6) > tz)
-	{
-		return;
-	}
-
-	xscale = DivScale12 (centerxfrac, tz);
+	tex = NULL;
+	voxel = NULL;
 
 	if (thing->picnum.isValid())
 	{
@@ -1307,52 +1797,53 @@ void R_ProjectSprite (AActor *thing, int fakeside)
 			picnum = sprframe->Texture[rot];
 			flip = sprframe->Flip & (1 << rot);
 			tex = TexMan[picnum];	// Do not animate the rotation
+			if (r_drawvoxels)
+			{
+				voxel = sprframe->Voxel;
+			}
 		}
 	}
-	if (tex == NULL || tex->UseType == FTexture::TEX_Null)
+	if (voxel == NULL && (tex == NULL || tex->UseType == FTexture::TEX_Null))
 	{
 		return;
 	}
 
-	// [RH] Added scaling
-	int scaled_to = tex->GetScaledTopOffset();
-	int scaled_bo = scaled_to - tex->GetScaledHeight();
-	gzt = fz + thing->scaleY * scaled_to;
-	gzb = fz + thing->scaleY * scaled_bo;
+	// thing is behind view plane?
+	if (voxel == NULL && tz < MINZ)
+		return;
 
-	// [RH] Reject sprites that are off the top or bottom of the screen
-	if (MulScale12 (globaluclip, tz) > viewz - gzb ||
-		MulScale12 (globaldclip, tz) < viewz - gzt)
+	tx = DMulScale16 (tr_x, viewsin, -tr_y, viewcos);
+
+	// [RH] Flip for mirrors
+	if (MirrorFlags & RF_XFLIP)
+	{
+		tx = -tx;
+	}
+	tx2 = tx >> 4;
+
+	// too far off the side?
+	if ((abs(tx) >> 6) > abs(tz))
 	{
 		return;
 	}
 
-	// [RH] Flip for mirrors and renderflags
-	if ((MirrorFlags ^ thing->renderflags) & RF_XFLIP)
+	if (voxel == NULL)
 	{
-		flip = !flip;
+		// [RH] Added scaling
+		int scaled_to = tex->GetScaledTopOffset();
+		int scaled_bo = scaled_to - tex->GetScaledHeight();
+		gzt = fz + thing->scaleY * scaled_to;
+		gzb = fz + thing->scaleY * scaled_bo;
+	}
+	else
+	{
+		xscale = FixedMul(thing->scaleX, voxel->Scale);
+		yscale = FixedMul(thing->scaleY, voxel->Scale);
+		gzt = fz + MulScale8(yscale, voxel->Voxel->Mips[0].PivotZ) - thing->floorclip;
+		gzb = fz + MulScale8(yscale, voxel->Voxel->Mips[0].PivotZ - (voxel->Voxel->Mips[0].SizeZ << 8));
+		if (gzt <= gzb)
+			return;
 	}
-
-	// calculate edges of the shape
-	const fixed_t thingxscalemul = DivScale16(thing->scaleX, tex->xScale);
-
-	tx -= (flip ? (tex->GetWidth() - tex->LeftOffset - 1) : tex->LeftOffset) * thingxscalemul;
-	x1 = centerx + MulScale32 (tx, xscale);
-
-	// off the right side?
-	if (x1 > WindowRight)
-		return;
-
-	tx += tex->GetWidth() * thingxscalemul;
-	x2 = centerx + MulScale32 (tx, xscale);
-
-	// off the left side or too small?
-	if (x2 < WindowLeft || x2 <= x1)
-		return;
-
-	xscale = FixedDiv(FixedMul(thing->scaleX, xscale), tex->xScale);
-	iscale = (tex->GetWidth() << FRACBITS) / (x2 - x1);
-	x2--;
 
 	// killough 3/27/98: exclude things totally separated
 	// from the viewer, by either water or fake ceilings
@@ -1381,51 +1872,130 @@ void R_ProjectSprite (AActor *thing, int fakeside)
 		}
 	}
 
-	// store information in a vissprite
-	vis = R_NewVisSprite ();
+	if (voxel == NULL)
+	{
+		xscale = DivScale12 (centerxfrac, tz);
+
+		// [RH] Reject sprites that are off the top or bottom of the screen
+		if (MulScale12 (globaluclip, tz) > viewz - gzb ||
+			MulScale12 (globaldclip, tz) < viewz - gzt)
+		{
+			return;
+		}
+
+		// [RH] Flip for mirrors and renderflags
+		if ((MirrorFlags ^ thing->renderflags) & RF_XFLIP)
+		{
+			flip = !flip;
+		}
+
+		// calculate edges of the shape
+		const fixed_t thingxscalemul = DivScale16(thing->scaleX, tex->xScale);
+
+		tx -= (flip ? (tex->GetWidth() - tex->LeftOffset - 1) : tex->LeftOffset) * thingxscalemul;
+		x1 = centerx + MulScale32 (tx, xscale);
+
+		// off the right side?
+		if (x1 > WindowRight)
+			return;
+
+		tx += tex->GetWidth() * thingxscalemul;
+		x2 = centerx + MulScale32 (tx, xscale);
+
+		// off the left side or too small?
+		if ((x2 < WindowLeft || x2 <= x1))
+			return;
+
+		xscale = FixedDiv(FixedMul(thing->scaleX, xscale), tex->xScale);
+		iscale = (tex->GetWidth() << FRACBITS) / (x2 - x1);
+		x2--;
+
+		fixed_t yscale = SafeDivScale16(thing->scaleY, tex->yScale);
+
+		// store information in a vissprite
+		vis = R_NewVisSprite();
+
+		vis->xscale = xscale;
+		vis->yscale = Scale(InvZtoScale, yscale, tz << 4);
+		vis->idepth = (unsigned)DivScale32(1, tz) >> 1;	// tz is 20.12, so idepth ought to be 12.20, but signed math makes it 13.19
+		vis->floorclip = FixedDiv (thing->floorclip, yscale);
+		vis->texturemid = (tex->TopOffset << FRACBITS) - FixedDiv (viewz - fz + thing->floorclip, yscale);
+		vis->x1 = x1 < WindowLeft ? WindowLeft : x1;
+		vis->x2 = x2 > WindowRight ? WindowRight : x2;
+		vis->angle = thing->angle;
+
+		if (flip)
+		{
+			vis->startfrac = (tex->GetWidth() << FRACBITS) - 1;
+			vis->xiscale = -iscale;
+		}
+		else
+		{
+			vis->startfrac = 0;
+			vis->xiscale = iscale;
+		}
+
+		if (vis->x1 > x1)
+			vis->startfrac += vis->xiscale * (vis->x1 - x1);
+	}
+	else
+	{
+		vis = R_NewVisSprite();
+
+		vis->xscale = xscale;
+		vis->yscale = yscale;
+		vis->x1 = WindowLeft;
+		vis->x2 = WindowRight;
+		vis->idepth = (unsigned)DivScale32(1, MAX(tz, MINZ)) >> 1;
+		vis->floorclip = thing->floorclip;
+
+		fz -= thing->floorclip;
+
+		vis->angle = thing->angle + voxel->AngleOffset;
+
+		int voxelspin = (thing->flags & MF_DROPPED) ? voxel->DroppedSpin : voxel->PlacedSpin;
+		if (voxelspin != 0)
+		{
+			double ang = double(I_FPSTime()) * voxelspin / 1000;
+			vis->angle += angle_t(ang * (4294967296.f / 360));
+		}
+
+		// These are irrelevant for voxels.
+		vis->texturemid = 0x1CEDBEEF;
+		vis->startfrac	= 0x1CEDBEEF;
+		vis->xiscale	= 0x1CEDBEEF;
+	}
 
 	// killough 3/27/98: save sector for special clipping later
 	vis->heightsec = heightsec;
 	vis->sector = thing->Sector;
 
-	fixed_t yscale = DivScale16(thing->scaleY, tex->yScale);
+	vis->cx = tx2;
+	vis->depth = tz;
+	vis->gx = fx;
+	vis->gy = fy;
+	vis->gz = fz;
+	vis->gzb = gzb;		// [RH] use gzb, not thing->z
+	vis->gzt = gzt;		// killough 3/27/98
 	vis->renderflags = thing->renderflags;
 	if(thing->flags5 & MF5_BRIGHT) vis->renderflags |= RF_FULLBRIGHT; // kg3D
 	vis->RenderStyle = thing->RenderStyle;
 	vis->FillColor = thing->fillcolor;
-	vis->xscale = xscale;
-	vis->yscale = Scale (InvZtoScale, yscale, tz << 4);
-	vis->depth = tz;
-	vis->idepth = (DWORD)DivScale32 (1, tz) >> 1;	// tz is 20.12, so idepth ought to be 12.20, but
-	vis->cx = tx2;									// signed math makes it 13.19
-	vis->gx = fx;
-	vis->gy = fy;
-	vis->gz = gzb;		// [RH] use gzb, not thing->z
-	vis->gzt = gzt;		// killough 3/27/98
-	vis->floorclip = FixedDiv (thing->floorclip, yscale);
-	vis->texturemid = (tex->TopOffset << FRACBITS) - 
-		FixedDiv (viewz-fz+thing->floorclip, yscale);
-	vis->x1 = x1 < WindowLeft ? WindowLeft : x1;
-	vis->x2 = x2 > WindowRight ? WindowRight : x2;
 	vis->Translation = thing->Translation;		// [RH] thing translation table
 	vis->FakeFlatStat = fakeside;
 	vis->alpha = thing->alpha;
-	vis->pic = tex;
 
-	if (flip)
+	if (voxel != NULL)
 	{
-		vis->startfrac = (tex->GetWidth() << FRACBITS) - 1;
-		vis->xiscale = -iscale;
+		vis->voxel = voxel->Voxel;
+		vis->bIsVoxel = true;
 	}
 	else
 	{
-		vis->startfrac = 0;
-		vis->xiscale = iscale;
+		vis->pic = tex;
+		vis->bIsVoxel = false;
 	}
 
-	if (vis->x1 > x1)
-		vis->startfrac += vis->xiscale*(vis->x1-x1);
-
 	// The software renderer cannot invert the source without inverting the overlay
 	// too. That means if the source is inverted, we need to do the reverse of what
 	// the invert overlay flag says to do.
@@ -1479,7 +2049,7 @@ void R_ProjectSprite (AActor *thing, int fakeside)
 		else
 		{ // diminished light
 			vis->colormap = mybasecolormap->Maps + (GETPALOOKUP (
-				(fixed_t)DivScale12 (r_SpriteVisibility, tz), spriteshade) << COLORMAPSHIFT);
+				(fixed_t)DivScale12 (r_SpriteVisibility, MAX(tz, MINZ)), spriteshade) << COLORMAPSHIFT);
 		}
 	}
 }
@@ -2099,6 +2669,7 @@ void R_DrawSprite (vissprite_t *spr)
 	static short cliptop[MAXWIDTH];
 	drawseg_t *ds;
 	int i;
+	int x1, x2;
 	int r1, r2;
 	short topclip, botclip;
 	short *clip1, *clip2;
@@ -2106,7 +2677,7 @@ void R_DrawSprite (vissprite_t *spr)
 	F3DFloor *rover;
 
 	// [RH] Check for particles
-	if (spr->pic == NULL)
+	if (!spr->bIsVoxel && spr->pic == NULL)
 	{
 		// kg3D - reject invisible parts
 		if(fake3D & 1 && spr->texturemid <= sclipBottom) return;
@@ -2115,8 +2686,11 @@ void R_DrawSprite (vissprite_t *spr)
 		return;
 	}
 
+	x1 = spr->x1;
+	x2 = spr->x2;
+
 	// [RH] Quickly reject sprites with bad x ranges.
-	if (spr->x1 > spr->x2)
+	if (x1 > x2)
 		return;
 
 	// [RH] Sprites split behind a one-sided line can also be discarded.
@@ -2128,21 +2702,27 @@ void R_DrawSprite (vissprite_t *spr)
 	if(fake3D & 2 && spr->gz >= sclipTop) return;
 
 	// kg3D - correct colors now
-	if(!fixedcolormap && fixedlightlev < 0 && spr->sector->e && spr->sector->e->XFloor.lightlist.Size()) {
+	if(!fixedcolormap && fixedlightlev < 0 && spr->sector->e && spr->sector->e->XFloor.lightlist.Size()) 
+	{
 		if(!(fake3D & 2)) sclipTop = spr->sector->ceilingplane.ZatPoint(viewx, viewy);
 		sector_t *sec = NULL;
 		for(i = spr->sector->e->XFloor.lightlist.Size() - 1; i >= 0; i--)
-			if(sclipTop <= spr->sector->e->XFloor.lightlist[i].plane.Zat0()) {
+		{
+			if(sclipTop <= spr->sector->e->XFloor.lightlist[i].plane.Zat0()) 
+			{
 				rover = spr->sector->e->XFloor.lightlist[i].caster;
-				if(rover) {
+				if(rover) 
+				{
 					if(rover->flags & FF_DOUBLESHADOW && sclipTop <= rover->bottom.plane->Zat0())
 						break;
 					sec = rover->model;
 				}
 				break;
 			}
+		}
 		// found new values, recalculate
-		if(sec) {
+		if(sec) 
+		{
 			INTBOOL invertcolormap = (spr->RenderStyle.Flags & STYLEF_InvertOverlay);
 
 			if (spr->RenderStyle.Flags & STYLEF_InvertSource)
@@ -2204,54 +2784,62 @@ void R_DrawSprite (vissprite_t *spr)
 	// [RH] rewrote this to be based on which part of the sector is really visible
 
 	fixed_t scale = MulScale19 (InvZtoScale, spr->idepth);
+	fixed_t hzb = FIXED_MIN, hzt = FIXED_MAX;
 
-	if (spr->heightsec &&
-		!(spr->heightsec->MoreFlags & SECF_IGNOREHEIGHTSEC))
+	if (spr->bIsVoxel && spr->floorclip != 0)
+	{
+		hzb = spr->gzb;
+	}
+
+	if (spr->heightsec && !(spr->heightsec->MoreFlags & SECF_IGNOREHEIGHTSEC))
 	{ // only things in specially marked sectors
 		if (spr->FakeFlatStat != FAKED_AboveCeiling)
 		{
-			fixed_t h = spr->heightsec->floorplane.ZatPoint (spr->gx, spr->gy);
-			//h = (centeryfrac - FixedMul (h-viewz, spr->yscale)) >> FRACBITS;
-			h = (centeryfrac - FixedMul (h-viewz, scale)) >> FRACBITS;
+			fixed_t hz = spr->heightsec->floorplane.ZatPoint (spr->gx, spr->gy);
+			fixed_t h = (centeryfrac - FixedMul (hz-viewz, scale)) >> FRACBITS;
 
 			if (spr->FakeFlatStat == FAKED_BelowFloor)
 			{ // seen below floor: clip top
-				if (h > topclip)
+				if (!spr->bIsVoxel && h > topclip)
 				{
 					topclip = MIN<short> (h, viewheight);
 				}
+				hzt = MIN(hzt, hz);
 			}
 			else
 			{ // seen in the middle: clip bottom
-				if (h < botclip)
+				if (!spr->bIsVoxel && h < botclip)
 				{
 					botclip = MAX<short> (0, h);
 				}
+				hzb = MAX(hzb, hz);
 			}
 		}
 		if (spr->FakeFlatStat != FAKED_BelowFloor)
 		{
-			fixed_t h = spr->heightsec->ceilingplane.ZatPoint (spr->gx, spr->gy);
-			h = (centeryfrac - FixedMul (h-viewz, scale)) >> FRACBITS;
+			fixed_t hz = spr->heightsec->ceilingplane.ZatPoint (spr->gx, spr->gy);
+			fixed_t h = (centeryfrac - FixedMul (hz-viewz, scale)) >> FRACBITS;
 
 			if (spr->FakeFlatStat == FAKED_AboveCeiling)
 			{ // seen above ceiling: clip bottom
-				if (h < botclip)
+				if (!spr->bIsVoxel && h < botclip)
 				{
 					botclip = MAX<short> (0, h);
 				}
+				hzb = MAX(hzb, hz);
 			}
 			else
 			{ // seen in the middle: clip top
-				if (h > topclip)
+				if (!spr->bIsVoxel && h > topclip)
 				{
 					topclip = MIN<short> (h, viewheight);
 				}
+				hzt = MIN(hzt, hz);
 			}
 		}
 	}
 	// killough 3/27/98: end special clipping for deep water / fake ceilings
-	else if (spr->floorclip)
+	else if (!spr->bIsVoxel && spr->floorclip)
 	{ // [RH] Move floorclip stuff from R_DrawVisSprite to here
 		int clip = ((centeryfrac - FixedMul (spr->texturemid -
 			(spr->pic->GetHeight() << FRACBITS) +
@@ -2295,9 +2883,14 @@ void R_DrawSprite (vissprite_t *spr)
 	}
 #endif
 
-	i = spr->x2 - spr->x1 + 1;
-	clip1 = clipbot + spr->x1;
-	clip2 = cliptop + spr->x1;
+	if (topclip >= botclip)
+	{
+		return;
+	}
+
+	i = x2 - x1 + 1;
+	clip1 = clipbot + x1;
+	clip2 = cliptop + x1;
 	do
 	{
 		*clip1++ = botclip;
@@ -2318,7 +2911,7 @@ void R_DrawSprite (vissprite_t *spr)
 		// kg3D - no clipping on fake segs
 		if(ds->fake) continue;
 		// determine if the drawseg obscures the sprite
-		if (ds->x1 > spr->x2 || ds->x2 < spr->x1 ||
+		if (ds->x1 > x2 || ds->x2 < x1 ||
 			(!(ds->silhouette & SIL_BOTH) && ds->maskedtexturecol == -1 &&
 			 !ds->bFogBoundary) )
 		{
@@ -2326,8 +2919,8 @@ void R_DrawSprite (vissprite_t *spr)
 			continue;
 		}
 
-		r1 = MAX<int> (ds->x1, spr->x1);
-		r2 = MIN<int> (ds->x2, spr->x2);
+		r1 = MAX<int> (ds->x1, x1);
+		r2 = MIN<int> (ds->x2, x2);
 
 		fixed_t neardepth, fardepth;
 		if (ds->sz1 < ds->sz2)
@@ -2385,9 +2978,33 @@ void R_DrawSprite (vissprite_t *spr)
 
 	// all clipping has been performed, so draw the sprite
 
-	mfloorclip = clipbot;
-	mceilingclip = cliptop;
-	R_DrawVisSprite (spr);
+	if (!spr->bIsVoxel)
+	{
+		mfloorclip = clipbot;
+		mceilingclip = cliptop;
+		R_DrawVisSprite (spr);
+	}
+	else
+	{
+		// If it is completely clipped away, don't bother drawing it.
+		if (cliptop[x2] >= clipbot[x2])
+		{
+			for (i = x1; i < x2; ++i)
+			{
+				if (cliptop[i] < clipbot[i])
+				{
+					break;
+				}
+			}
+			if (i == x2)
+			{
+				return;
+			}
+		}
+		int minvoxely = spr->gzt <= hzt ? 0 : (spr->gzt - hzt) / spr->yscale;
+		int maxvoxely = spr->gzb > hzb ? INT_MAX : (spr->gzt - hzb) / spr->yscale;
+		R_DrawVisVoxel(spr, minvoxely, maxvoxely, cliptop, clipbot);
+	}
 	spr->colormap = colormap;
 }
 
@@ -2698,13 +3315,14 @@ void R_ProjectParticle (particle_t *particle, const sector_t *sector, int shade,
 	vis->gx = particle->x;
 	vis->gy = particle->y;
 	vis->texturemid = particle->z; // kg3D
-	vis->gz = y1;
+	vis->gzb = y1;
 	vis->gzt = y2;
 	vis->x1 = x1;
 	vis->x2 = x2;
 	vis->Translation = 0;
 	vis->startfrac = particle->color;
 	vis->pic = NULL;
+	vis->bIsVoxel = false;
 	vis->renderflags = particle->trans;
 	vis->FakeFlatStat = fakeside;
 	vis->floorclip = 0;
@@ -2756,7 +3374,7 @@ void R_DrawParticle (vissprite_t *vis)
 	BYTE *dest;
 	DWORD fg;
 	BYTE color = vis->colormap[vis->startfrac];
-	int yl = vis->gz;
+	int yl = vis->gzb;
 	int ycount = vis->gzt - yl + 1;
 	int x1 = vis->x1;
 	int countbase = vis->x2 - x1 + 1;
@@ -2790,3 +3408,480 @@ void R_DrawParticle (vissprite_t *vis)
 		dest += spacing;
 	} while (--ycount);
 }
+
+static fixed_t distrecip(fixed_t y)
+{
+	y >>= 3;
+	return y == 0 ? 0 : SafeDivScale32(centerxwide, y);
+}
+
+extern fixed_t baseyaspectmul;
+
+void R_DrawVoxel(fixed_t dasprx, fixed_t daspry, fixed_t dasprz, angle_t dasprang,
+	fixed_t daxscale, fixed_t dayscale, FVoxel *voxobj,
+	lighttable_t *colormap, short *daumost, short *dadmost, int minslabz, int maxslabz, int flags)
+{
+	int i, j, k, x, y, syoff, ggxstart, ggystart, nxoff;
+	fixed_t cosang, sinang, sprcosang, sprsinang;
+	int backx, backy, gxinc, gyinc;
+	int daxscalerecip, dayscalerecip, cnt, gxstart, gystart, dazscale;
+	int lx, rx, nx, ny, x1=0, y1=0, x2=0, y2=0, yplc, yinc=0;
+	int yoff, xs=0, ys=0, xe, ye, xi=0, yi=0, cbackx, cbacky, dagxinc, dagyinc;
+	kvxslab_t *voxptr, *voxend;
+	FVoxelMipLevel *mip;
+
+	const int nytooclose = centerxwide * 2100, nytoofar = 32768*32768 - 1048576;
+	const int xdimenscale = Scale(centerxwide, yaspectmul, 160);
+	const fixed_t globalposx =  viewx >> 12;
+	const fixed_t globalposy = -viewy >> 12;
+	const fixed_t globalposz = -viewz >> 8;
+
+	dasprx =  dasprx >> 12;
+	daspry = -daspry >> 12;
+	dasprz = -dasprz >> 8;
+	daxscale >>= 10;
+	dayscale >>= 10;
+
+	cosang = viewcos >> 2;
+	sinang = -viewsin >> 2;
+	sprcosang = finecosine[dasprang >> ANGLETOFINESHIFT] >> 2;
+	sprsinang = -finesine[dasprang >> ANGLETOFINESHIFT] >> 2;
+
+	R_SetupDrawSlab(colormap);
+
+	// Select mip level
+	i = abs(DMulScale8(dasprx - globalposx, viewcos, daspry - globalposy, -viewsin));
+	i = DivScale6(i, MIN(daxscale, dayscale));
+	j = FocalLengthX >> 3;
+	for (k = 0; k < voxobj->NumMips; ++k)
+	{
+		if (i < j) { break; }
+		i >>= 1;
+	}
+	if (k >= voxobj->NumMips) k = voxobj->NumMips - 1;
+
+	mip = &voxobj->Mips[k];		if (mip->SlabData == NULL) return;
+
+	minslabz >>= k;
+	maxslabz >>= k;
+
+	daxscale <<= (k+8); dayscale <<= (k+8);
+	dazscale = FixedDiv(dayscale, baseyaspectmul);
+	daxscale = FixedDiv(daxscale, yaspectmul);
+	daxscale = Scale(daxscale, xdimenscale, centerxwide << 9);
+	dayscale = Scale(dayscale, FixedMul(xdimenscale, viewingrangerecip), centerxwide << 9);
+
+	daxscalerecip = (1<<30) / daxscale;
+	dayscalerecip = (1<<30) / dayscale;
+
+	x = FixedMul(globalposx - dasprx, daxscalerecip);
+	y = FixedMul(globalposy - daspry, daxscalerecip);
+	backx = (DMulScale10(x, sprcosang, y,  sprsinang) + mip->PivotX) >> 8;
+	backy = (DMulScale10(y, sprcosang, x, -sprsinang) + mip->PivotY) >> 8;
+	cbackx = clamp(backx, 0, mip->SizeX - 1);
+	cbacky = clamp(backy, 0, mip->SizeY - 1);
+
+	sprcosang = MulScale14(daxscale, sprcosang);
+	sprsinang = MulScale14(daxscale, sprsinang);
+
+	x = (dasprx - globalposx) - DMulScale18(mip->PivotX, sprcosang, mip->PivotY, -sprsinang);
+	y = (daspry - globalposy) - DMulScale18(mip->PivotY, sprcosang, mip->PivotX,  sprsinang);
+
+	cosang = FixedMul(cosang, dayscalerecip);
+	sinang = FixedMul(sinang, dayscalerecip);
+
+	gxstart = y*cosang - x*sinang;
+	gystart = x*cosang + y*sinang;
+	gxinc = DMulScale10(sprsinang, cosang, sprcosang, -sinang);
+	gyinc = DMulScale10(sprcosang, cosang, sprsinang,  sinang);
+	if ((abs(globalposz - dasprz) >> 10) >= abs(dazscale)) return;
+
+	x = 0; y = 0; j = MAX(mip->SizeX, mip->SizeY);
+	fixed_t *ggxinc = (fixed_t *)alloca((j + 1) * sizeof(fixed_t) * 2);
+	fixed_t *ggyinc = ggxinc + (j + 1);
+	for (i = 0; i <= j; i++)
+	{
+		ggxinc[i] = x; x += gxinc;
+		ggyinc[i] = y; y += gyinc;
+	}
+
+	syoff = DivScale21(globalposz - dasprz, dazscale) + (mip->PivotZ << 7);
+	yoff = (abs(gxinc) + abs(gyinc)) >> 1;
+
+	for (cnt = 0; cnt < 8; cnt++)
+	{
+		switch (cnt)
+		{
+			case 0: xs = 0;				ys = 0;				xi =  1; yi =  1; break;
+			case 1: xs = mip->SizeX-1;	ys = 0;				xi = -1; yi =  1; break;
+			case 2: xs = 0;				ys = mip->SizeY-1;	xi =  1; yi = -1; break;
+			case 3: xs = mip->SizeX-1;	ys = mip->SizeY-1;	xi = -1; yi = -1; break;
+			case 4: xs = 0;				ys = cbacky;		xi =  1; yi =  2; break;
+			case 5: xs = mip->SizeX-1;	ys = cbacky;		xi = -1; yi =  2; break;
+			case 6: xs = cbackx;		ys = 0;				xi =  2; yi =  1; break;
+			case 7: xs = cbackx;		ys = mip->SizeY-1;	xi =  2; yi = -1; break;
+		}
+		xe = cbackx; ye = cbacky;
+		if (cnt < 4)
+		{
+			if ((xi < 0) && (xe >= xs)) continue;
+			if ((xi > 0) && (xe <= xs)) continue;
+			if ((yi < 0) && (ye >= ys)) continue;
+			if ((yi > 0) && (ye <= ys)) continue;
+		}
+		else
+		{
+			if ((xi < 0) && (xe > xs)) continue;
+			if ((xi > 0) && (xe < xs)) continue;
+			if ((yi < 0) && (ye > ys)) continue;
+			if ((yi > 0) && (ye < ys)) continue;
+			xe += xi; ye += yi;
+		}
+
+		i = ksgn(ys-backy)+ksgn(xs-backx)*3+4;
+		switch(i)
+		{
+			case 6: case 7: x1 = 0;				y1 = 0;				break;
+			case 8: case 5: x1 = gxinc;			y1 = gyinc;			break;
+			case 0: case 3: x1 = gyinc;			y1 = -gxinc;		break;
+			case 2: case 1: x1 = gxinc+gyinc;	y1 = gyinc-gxinc;	break;
+		}
+		switch(i)
+		{
+			case 2: case 5: x2 = 0;				y2 = 0;				break;
+			case 0: case 1: x2 = gxinc;			y2 = gyinc;			break;
+			case 8: case 7: x2 = gyinc;			y2 = -gxinc;		break;
+			case 6: case 3: x2 = gxinc+gyinc;	y2 = gyinc-gxinc;	break;
+		}
+		BYTE oand = (1 << int(xs<backx)) + (1 << (int(ys<backy)+2));
+		BYTE oand16 = oand + 16;
+		BYTE oand32 = oand + 32;
+
+		if (yi > 0) { dagxinc =  gxinc; dagyinc =  FixedMul(gyinc, viewingrangerecip); }
+			   else { dagxinc = -gxinc; dagyinc = -FixedMul(gyinc, viewingrangerecip); }
+
+			/* Fix for non 90 degree viewing ranges */
+		nxoff = FixedMul(x2 - x1, viewingrangerecip);
+		x1 = FixedMul(x1, viewingrangerecip);
+
+		ggxstart = gxstart + ggyinc[ys];
+		ggystart = gystart - ggxinc[ys];
+
+		for (x = xs; x != xe; x += xi)
+		{
+			BYTE *slabxoffs = &mip->SlabData[mip->OffsetX[x]];
+			short *xyoffs = &mip->OffsetXY[x * (mip->SizeY + 1)];
+
+			nx = FixedMul(ggxstart + ggxinc[x], viewingrangerecip) + x1;
+			ny = ggystart + ggyinc[x];
+			for (y = ys; y != ye; y += yi, nx += dagyinc, ny -= dagxinc)
+			{
+				if ((ny <= nytooclose) || (ny >= nytoofar)) continue;
+				voxptr = (kvxslab_t *)(slabxoffs + xyoffs[y]);
+				voxend = (kvxslab_t *)(slabxoffs + xyoffs[y+1]);
+				if (voxptr >= voxend) continue;
+
+				lx = MulScale32(nx >> 3, distrecip(ny+y1)) + centerx;
+				if (lx < 0) lx = 0;
+				rx = MulScale32((nx + nxoff) >> 3, distrecip(ny+y2)) + centerx;
+				if (rx > viewwidth) rx = viewwidth;
+				if (rx <= lx) continue;
+				rx -= lx;
+
+				fixed_t l1 = distrecip(ny-yoff);
+				fixed_t l2 = distrecip(ny+yoff);
+				for (; voxptr < voxend; voxptr = (kvxslab_t *)((BYTE *)voxptr + voxptr->zleng + 3))
+				{
+					const BYTE *col = voxptr->col;
+					int zleng = voxptr->zleng;
+					int ztop = voxptr->ztop;
+					fixed_t z1, z2;
+
+					if (ztop < minslabz)
+					{
+						int diff = minslabz - ztop;
+						ztop = minslabz;
+						col += diff;
+						zleng -= diff;
+					}
+					if (ztop + zleng > maxslabz)
+					{
+						int diff = ztop + zleng - maxslabz;
+						zleng -= diff;
+					}
+					if (zleng <= 0) continue;
+
+					j = (ztop << 15) - syoff;
+					if (j < 0)
+					{
+						k = j + (zleng << 15);
+						if (k < 0)
+						{
+							if ((voxptr->backfacecull & oand32) == 0) continue;
+							z2 = MulScale32(l2, k) + centery;					/* Below slab */
+						}
+						else
+						{
+							if ((voxptr->backfacecull & oand) == 0) continue;	/* Middle of slab */
+							z2 = MulScale32(l1, k) + centery;
+						}
+						z1 = MulScale32(l1, j) + centery;
+					}
+					else
+					{
+						if ((voxptr->backfacecull & oand16) == 0) continue;
+						z1 = MulScale32(l2, j) + centery;						/* Above slab */
+						z2 = MulScale32(l1, j + (zleng << 15)) + centery;
+					}
+
+					if (zleng == 1)
+					{
+						yplc = 0; yinc = 0;
+						if (z1 < daumost[lx]) z1 = daumost[lx];
+					}
+					else
+					{
+						if (z2-z1 >= 1024) yinc = FixedDiv(zleng, z2 - z1);
+						else if (z2 > z1) yinc = (((1 << 24) - 1) / (z2 - z1)) * zleng >> 8;
+						if (z1 < daumost[lx]) { yplc = yinc*(daumost[lx]-z1); z1 = daumost[lx]; } else yplc = 0;
+					}
+					if (z2 > dadmost[lx]) z2 = dadmost[lx];
+					z2 -= z1; if (z2 <= 0) continue;
+
+					if (!(flags & DVF_OFFSCREEN))
+					{
+						// Draw directly to the screen.
+						R_DrawSlab(rx, yplc, z2, yinc, col, ylookup[z1] + lx + dc_destorg);
+					}
+					else
+					{
+						// Record the area covered and possibly draw to an offscreen buffer.
+						dc_yl = z1;
+						dc_yh = z1 + z2 - 1;
+						dc_count = z2;
+						dc_iscale = yinc;
+						for (int x = 0; x < rx; ++x)
+						{
+							OffscreenCoverageBuffer->InsertSpan(lx + x, z1, z1 + z2);
+							if (!(flags & DVF_SPANSONLY))
+							{
+								dc_x = lx + x;
+								rt_initcols(OffscreenColorBuffer + (dc_x & ~3) * OffscreenBufferHeight);
+								dc_source = col;
+								dc_texturefrac = yplc;
+								hcolfunc_pre();
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+//==========================================================================
+//
+// FCoverageBuffer Constructor
+//
+//==========================================================================
+
+FCoverageBuffer::FCoverageBuffer(int lists)
+	: Spans(NULL), FreeSpans(NULL)
+{
+	NumLists = lists;
+	Spans = new Span *[lists];
+	memset(Spans, 0, sizeof(Span*)*lists);
+}
+
+//==========================================================================
+//
+// FCoverageBuffer Destructor
+//
+//==========================================================================
+
+FCoverageBuffer::~FCoverageBuffer()
+{
+	if (Spans != NULL)
+	{
+		delete[] Spans;
+	}
+}
+
+//==========================================================================
+//
+// FCoverageBuffer :: Clear
+//
+//==========================================================================
+
+void FCoverageBuffer::Clear()
+{
+	SpanArena.FreeAll();
+	memset(Spans, 0, sizeof(Span*)*NumLists);
+	FreeSpans = NULL;
+}
+
+//==========================================================================
+//
+// FCoverageBuffer :: InsertSpan
+//
+// start is inclusive.
+// stop is exclusive.
+//
+//==========================================================================
+
+void FCoverageBuffer::InsertSpan(int listnum, int start, int stop)
+{
+	assert(unsigned(listnum) < NumLists);
+	assert(start < stop);
+
+	Span **span_p = &Spans[listnum];
+	Span *span;
+
+	if (*span_p == NULL || (*span_p)->Start > stop)
+	{ // This list is empty or the first entry is after this one, so we can just insert the span.
+		goto addspan;
+	}
+
+	// Insert the new span in order, merging with existing ones.
+	while (*span_p != NULL)
+	{
+		if ((*span_p)->Stop < start)							// =====		(existing span)
+		{ // Span ends before this one starts.					//		  ++++	(new span)
+			span_p = &(*span_p)->NextSpan;
+			continue;
+		}
+
+		// Does the new span overlap or abut the existing one?
+		if ((*span_p)->Start <= start)
+		{
+			if ((*span_p)->Stop >= stop)						// =============
+			{ // The existing span completely covers this one.	//     +++++
+				return;
+			}
+			// Extend the existing span with the new one.		// ======
+			span = *span_p;										//     +++++++
+			span->Stop = stop;									// (or)  +++++
+
+			// Free up any spans we just covered up.
+			span_p = &(*span_p)->NextSpan;
+			while (*span_p != NULL && (*span_p)->Start <= stop && (*span_p)->Stop <= stop)
+			{
+				Span *span = *span_p;							// ======  ======
+				*span_p = span->NextSpan;						//     +++++++++++++
+				span->NextSpan = FreeSpans;
+				FreeSpans = span;
+			}
+			if (*span_p != NULL && (*span_p)->Start <= stop)	// =======         ========
+			{ // Our new span connects two existing spans.		//     ++++++++++++++
+			  // They should all be collapsed into a single span.
+				span->Stop = (*span_p)->Stop;
+				span = *span_p;
+				*span_p = span->NextSpan;
+				span->NextSpan = FreeSpans;
+				FreeSpans = span;
+			}
+			goto check;
+		}
+		else if ((*span_p)->Start <= stop)						//        =====
+		{ // The new span extends the existing span from		//    ++++
+		  // the beginning.										// (or) ++++
+			(*span_p)->Start = start;
+			goto check;
+		}
+		else													//         ======
+		{ // No overlap, so insert a new span.					// +++++
+			goto addspan;
+		}
+	}
+	// Append a new span to the end of the list.
+addspan:
+	span = AllocSpan();
+	span->NextSpan = *span_p;
+	span->Start = start;
+	span->Stop = stop;
+	*span_p = span;
+check:
+#ifdef _DEBUG
+	// Validate the span list: Spans must be in order, and there must be
+	// at least one pixel between spans.
+	for (span = Spans[listnum]; span != NULL; span = span->NextSpan)
+	{
+		assert(span->Start < span->Stop);
+		if (span->NextSpan != NULL)
+		{
+			assert(span->Stop < span->NextSpan->Start);
+		}
+	}
+#endif
+	;
+}
+
+//==========================================================================
+//
+// FCoverageBuffer :: AllocSpan
+//
+//==========================================================================
+
+FCoverageBuffer::Span *FCoverageBuffer::AllocSpan()
+{
+	Span *span;
+
+	if (FreeSpans != NULL)
+	{
+		span = FreeSpans;
+		FreeSpans = span->NextSpan;
+	}
+	else
+	{
+		span = (Span *)SpanArena.Alloc(sizeof(Span));
+	}
+	return span;
+}
+
+//==========================================================================
+//
+// R_CheckOffscreenBuffer
+//
+// Allocates the offscreen coverage buffer and optionally the offscreen
+// color buffer. If they already exist but are the wrong size, they will
+// be reallocated.
+//
+//==========================================================================
+
+void R_CheckOffscreenBuffer(int width, int height, bool spansonly)
+{
+	if (OffscreenCoverageBuffer == NULL)
+	{
+		assert(OffscreenColorBuffer == NULL && "The color buffer cannot exist without the coverage buffer");
+		OffscreenCoverageBuffer = new FCoverageBuffer(width);
+	}
+	else if (OffscreenCoverageBuffer->NumLists != width)
+	{
+		delete OffscreenCoverageBuffer;
+		OffscreenCoverageBuffer = new FCoverageBuffer(width);
+		if (OffscreenColorBuffer != NULL)
+		{
+			delete[] OffscreenColorBuffer;
+			OffscreenColorBuffer = NULL;
+		}
+	}
+	else
+	{
+		OffscreenCoverageBuffer->Clear();
+	}
+
+	if (!spansonly)
+	{
+		if (OffscreenColorBuffer == NULL)
+		{
+			OffscreenColorBuffer = new BYTE[width * height];
+		}
+		else if (OffscreenBufferWidth != width || OffscreenBufferHeight != height)
+		{
+			delete[] OffscreenColorBuffer;
+			OffscreenColorBuffer = new BYTE[width * height];
+		}
+	}
+	OffscreenBufferWidth = width;
+	OffscreenBufferHeight = height;
+}
diff --git a/src/r_things.h b/src/r_things.h
index 9ae796ce90..da31daf79d 100644
--- a/src/r_things.h
+++ b/src/r_things.h
@@ -104,6 +104,14 @@ void R_ClearSprites ();
 void R_DrawMasked ();
 void R_DrawRemainingPlayerSprites ();
 
+void R_CheckOffscreenBuffer(int width, int height, bool spansonly);
+
+enum { DVF_OFFSCREEN = 1, DVF_SPANSONLY = 2 };
+
+void R_DrawVoxel(fixed_t dasprx, fixed_t daspry, fixed_t dasprz, angle_t dasprang,
+	fixed_t daxscale, fixed_t dayscale, FVoxel *voxobj,
+	lighttable_t *colormap, short *daumost, short *dadmost, int minslabz, int maxslabz, int flags);
+
 void R_ClipVisSprite (vissprite_t *vis, int xl, int xh);
 
 
diff --git a/src/resourcefiles/file_wad.cpp b/src/resourcefiles/file_wad.cpp
index ffa9c85e86..3a6de70eab 100644
--- a/src/resourcefiles/file_wad.cpp
+++ b/src/resourcefiles/file_wad.cpp
@@ -113,6 +113,7 @@ bool FWadFile::Open(bool quiet)
 		SetNamespace("TX_START", "TX_END", ns_newtextures);
 		SetNamespace("V_START", "V_END", ns_strifevoices);
 		SetNamespace("HI_START", "HI_END", ns_hires);
+		SetNamespace("VX_START", "VX_END", ns_voxels);
 		SkinHack();
 	}
 	delete [] fileinfo;
diff --git a/src/resourcefiles/resourcefile.cpp b/src/resourcefiles/resourcefile.cpp
index c5bde5712b..866605d14d 100644
--- a/src/resourcefiles/resourcefile.cpp
+++ b/src/resourcefiles/resourcefile.cpp
@@ -116,6 +116,7 @@ void FResourceLump::LumpNameSetup(const char *iname)
 				!strncmp(iname, "textures/", 9)		? ns_newtextures :
 				!strncmp(iname, "hires/", 6)		? ns_hires :
 				!strncmp(iname, "sprites/", 8)		? ns_sprites :
+				!strncmp(iname, "voxels/", 7)		? ns_voxels :
 				!strncmp(iname, "colormaps/", 10)	? ns_colormaps :
 				!strncmp(iname, "acs/", 4)			? ns_acslibrary :
 				!strncmp(iname, "voices/", 7)		? ns_strifevoices :
@@ -137,7 +138,7 @@ void FResourceLump::LumpNameSetup(const char *iname)
 	// Since '\' can't be used as a file name's part inside a ZIP
 	// we have to work around this for sprites because it is a valid
 	// frame character.
-	else if (Namespace == ns_sprites)
+	else if (Namespace == ns_sprites || Namespace == ns_voxels)
 	{
 		char *c;
 
diff --git a/src/sdl/crashcatcher.c b/src/sdl/crashcatcher.c
index 7dc928407e..73fa4b0361 100644
--- a/src/sdl/crashcatcher.c
+++ b/src/sdl/crashcatcher.c
@@ -4,21 +4,39 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
+#include <sys/param.h>
+#include <sys/ucontext.h>
 #include <string.h>
 #include <errno.h>
-#include <sys/ucontext.h>
 
-// Solaris doesn't have SA_ONESHOT
-// According to the Linux header this is the same.
-#ifndef SA_ONESHOT
-#define SA_ONESHOT SA_RESETHAND
+#ifdef __linux__
+#include <sys/prctl.h>
+#ifndef PR_SET_PTRACER
+#define PR_SET_PTRACER 0x59616d61
+#endif
 #endif
 
-static const char *cc_logfile = NULL;
 
-static char respfile[256];
-static char buf[256];
-static char user_info_buf[1024];
+static const char crash_switch[] = "--cc-handle-crash";
+
+static const char fatal_err[] = "\n\n*** Fatal Error ***\n";
+static const char pipe_err[] = "!!! Failed to create pipe\n";
+static const char fork_err[] = "!!! Failed to fork debug process\n";
+static const char exec_err[] = "!!! Failed to exec debug process\n";
+
+static char argv0[PATH_MAX];
+
+static char altstack[SIGSTKSZ];
+
+
+static struct {
+	int signum;
+	pid_t pid;
+	int has_siginfo;
+	siginfo_t siginfo;
+	char buf[1024];
+} crash_info;
+
 
 static const struct {
 	const char *name;
@@ -88,16 +106,19 @@ static const struct {
 
 static int (*cc_user_info)(char*, char*);
 
+
 static void gdb_info(pid_t pid)
 {
+	char respfile[64];
+	char cmd_buf[128];
 	FILE *f;
 	int fd;
 
 	/* Create a temp file to put gdb commands into */
 	strcpy(respfile, "gdb-respfile-XXXXXX");
-	if((fd = mkstemp(respfile)) >= 0 && (f = fdopen(fd, "w")))
+	if((fd=mkstemp(respfile)) >= 0 && (f=fdopen(fd, "w")) != NULL)
 	{
-		fprintf(f, "signal SIGCHLD\n"
+		fprintf(f, "attach %d\n"
 		           "shell echo \"\"\n"
 		           "shell echo \"* Loaded Libraries\"\n"
 		           "info sharedlibrary\n"
@@ -111,49 +132,18 @@ static void gdb_info(pid_t pid)
 		           "shell echo \"* Registers\"\n"
 		           "info registers\n"
 		           "shell echo \"\"\n"
-		           "shell echo \"* Bytes near %%eip:\"\n"
-		           "x/x $eip-3\nx/x $eip\n"
-		           "shell echo \"\"\n"
 		           "shell echo \"* Backtrace\"\n"
-		           "backtrace full\n"
-#if 0 /* This sorta works to print out the core, but is too slow and skips 0's.. */
-		           "shell echo \"\"\n"
-		           "shell echo \"* Stack\"\n"
-		           "set var $_sp = $esp\n"
-		           "while $_sp <= $ebp - 12\n"
-		           " printf \"%%08x: \", $_sp\n"
-		           "  set var $_i = $_sp\n"
-		           "  while $_i < $_sp + 16\n"
-		           "    printf \"%%08x \", {int} $_i\n"
-		           "    set $_i += 4\n"
-		           "  end\n"
-		           "  set var $_i = $_sp\n"
-		           "  while $_i < $_sp + 16\n"
-		           "    printf \"%%c\", {int} $_i\n"
-		           "    set ++$_i\n"
-		           "  end\n"
-		           "  set var $_sp += 16\n"
-		           "  printf \"\\n\"\n"
-		           "end\n"
-		           "if $_sp <= $ebp\n"
-		           "  printf \"%%08x: \", $esp\n"
-		           "  while $_sp <= $ebp\n"
-		           "    printf \"%%08x \", {int} $_i\n"
-		           "    set $_sp += 4\n"
-		           "  end\n"
-		           "  printf \"\\n\"\n"
-		           "end\n"
-#endif
-		           "kill\n"
-		           "quit\n");
+		           "thread apply all backtrace full\n"
+		           "detach\n"
+		           "quit\n", pid);
 		fclose(f);
 
 		/* Run gdb and print process info. */
-		snprintf(buf, sizeof(buf), "gdb --quiet --batch --command=%s --pid=%i", respfile, pid);
-		printf("Executing: %s\n", buf);
+		snprintf(cmd_buf, sizeof(cmd_buf), "gdb --quiet --batch --command=%s", respfile);
+		printf("Executing: %s\n", cmd_buf);
 		fflush(stdout);
-		system(buf);
 
+		system(cmd_buf);
 		/* Clean up */
 		remove(respfile);
 	}
@@ -165,55 +155,137 @@ static void gdb_info(pid_t pid)
 			close(fd);
 			remove(respfile);
 		}
-		printf("Could not create gdb command file\n");
+		printf("!!! Could not create gdb command file\n");
 	}
 	fflush(stdout);
 }
 
-
-/* Generic system info */
 static void sys_info(void)
 {
-#if (defined __unix__)
+#ifdef __unix__
 	system("echo \"System: `uname -a`\"");
-#endif
-	system("echo \"GCC version: `gcc -dumpversion`\"");
 	putchar('\n');
 	fflush(stdout);
+#endif
+}
+
+
+static size_t safe_write(int fd, const void *buf, size_t len)
+{
+	size_t ret = 0;
+	while(ret < len)
+	{
+		ssize_t rem;
+		if((rem=write(fd, (const char*)buf+ret, len-ret)) == -1)
+		{
+			if(errno == EINTR)
+				continue;
+			break;
+		}
+		ret += rem;
+	}
+	return ret;
 }
 
 static void crash_catcher(int signum, siginfo_t *siginfo, void *context)
 {
 	ucontext_t *ucontext = (ucontext_t*)context;
-	const char *sigdesc = NULL;
-	pid_t pid, dbg_pid;
-	struct stat sbuf;
-#ifndef __FreeBSD__
-	struct rlimit rl;
+	pid_t dbg_pid;
+	int fd[2];
+
+	/* Make sure the effective uid is the real uid */
+	if(getuid() != geteuid())
+	{
+		raise(signum);
+		return;
+	}
+
+	safe_write(STDERR_FILENO, fatal_err, sizeof(fatal_err)-1);
+	if(pipe(fd) == -1)
+	{
+		safe_write(STDERR_FILENO, pipe_err, sizeof(pipe_err)-1);
+		raise(signum);
+		return;
+	}
+
+	crash_info.signum = signum;
+	crash_info.pid = getpid();
+	crash_info.has_siginfo = !!siginfo;
+	if(siginfo)
+		crash_info.siginfo = *siginfo;
+	if(cc_user_info)
+		cc_user_info(crash_info.buf, crash_info.buf+sizeof(crash_info.buf));
+
+	/* Fork off to start a crash handler */
+	switch((dbg_pid=fork()))
+	{
+		/* Error */
+		case -1:
+			safe_write(STDERR_FILENO, fork_err, sizeof(fork_err)-1);
+			raise(signum);
+			return;
+
+		case 0:
+			dup2(fd[0], STDIN_FILENO);
+			close(fd[0]);
+			close(fd[1]);
+
+			execl(argv0, argv0, crash_switch, NULL);
+
+			safe_write(STDERR_FILENO, exec_err, sizeof(exec_err)-1);
+			_exit(1);
+
+		default:
+#ifdef __linux__
+			prctl(PR_SET_PTRACER, dbg_pid, 0, 0, 0);
 #endif
-	int status, i;
-	FILE *f;
+			safe_write(fd[1], &crash_info, sizeof(crash_info));
+			close(fd[0]);
+			close(fd[1]);
+
+			/* Wait; we'll be killed when gdb is done */
+			do {
+				int status;
+				if(waitpid(dbg_pid, &status, 0) == dbg_pid &&
+				   (WIFEXITED(status) || WIFSIGNALED(status)))
+				{
+					/* The debug process died before it could kill us */
+					raise(signum);
+					break;
+				}
+			} while(1);
+	}
+}
+
+static void crash_handler(const char *logfile)
+{
+	const char *sigdesc = "";
+	int i;
+
+	if(fread(&crash_info, sizeof(crash_info), 1, stdin) != 1)
+	{
+		fprintf(stderr, "!!! Failed to retrieve info from crashed process\n");
+		exit(1);
+	}
 
 	/* Get the signal description */
-	if(!siginfo)
+	for(i = 0;signals[i].name;++i)
 	{
-		for(i = 0;signals[i].name;++i)
+		if(signals[i].signum == crash_info.signum)
 		{
-			if(signals[i].signum == signum)
-			{	
-				sigdesc = signals[i].name;
-				break;
-			}
+			sigdesc = signals[i].name;
+			break;
 		}
 	}
-	else
+
+	if(crash_info.has_siginfo)
 	{
-		switch(signum)
+		switch(crash_info.signum)
 		{
 			case SIGSEGV:
 				for(i = 0;sigsegv_codes[i].name;++i)
 				{
-					if(sigsegv_codes[i].code == siginfo->si_code)
+					if(sigsegv_codes[i].code == crash_info.siginfo.si_code)
 					{
 						sigdesc = sigsegv_codes[i].name;
 						break;
@@ -224,7 +296,7 @@ static void crash_catcher(int signum, siginfo_t *siginfo, void *context)
 			case SIGFPE:
 				for(i = 0;sigfpe_codes[i].name;++i)
 				{
-					if(sigfpe_codes[i].code == siginfo->si_code)
+					if(sigfpe_codes[i].code == crash_info.siginfo.si_code)
 					{
 						sigdesc = sigfpe_codes[i].name;
 						break;
@@ -235,7 +307,7 @@ static void crash_catcher(int signum, siginfo_t *siginfo, void *context)
 			case SIGILL:
 				for(i = 0;sigill_codes[i].name;++i)
 				{
-					if(sigill_codes[i].code == siginfo->si_code)
+					if(sigill_codes[i].code == crash_info.siginfo.si_code)
 					{
 						sigdesc = sigill_codes[i].name;
 						break;
@@ -246,7 +318,7 @@ static void crash_catcher(int signum, siginfo_t *siginfo, void *context)
 			case SIGBUS:
 				for(i = 0;sigbus_codes[i].name;++i)
 				{
-					if(sigbus_codes[i].code == siginfo->si_code)
+					if(sigbus_codes[i].code == crash_info.siginfo.si_code)
 					{
 						sigdesc = sigbus_codes[i].name;
 						break;
@@ -255,149 +327,91 @@ static void crash_catcher(int signum, siginfo_t *siginfo, void *context)
 				break;
 		}
 	}
+	fprintf(stderr, "%s (signal %i)\n", sigdesc, crash_info.signum);
+	if(crash_info.has_siginfo)
+		fprintf(stderr, "Address: %p\n", crash_info.siginfo.si_addr);
+	fputc('\n', stderr);
 
-	if(!sigdesc)
+	if(logfile)
 	{
-		/* Unknown signal, let the default handler deal with it */
-		raise(signum);
-		return;
-	}
-
-#if 0 /* Do we need this? */
-	/* Make sure the effective uid is the real uid */
-	if (getuid() != geteuid())
-	{
-		fprintf(stderr, "%s (signal %i)\ngetuid() does not match geteuid().\n", sigdesc, signum);
-		_exit(-1);
-	}
-#endif
-
-	/* Create crash log file */
-	if(cc_logfile)
-	{
-		f = fopen(cc_logfile, "w");
-		if(!f)
+		/* Create crash log file and redirect shell output to it */
+		if(freopen(logfile, "wa", stdout) != stdout)
 		{
-			fprintf(stderr, "Could not create %s following signal.\n", cc_logfile);
-			raise(signum);
-			return;
+			fprintf(stderr, "!!! Could not create %s following signal\n", logfile);
+			exit(1);
 		}
-	}
-	else
-		f = stderr;
+		fprintf(stderr, "Generating %s and killing process %d, please wait... ", logfile, crash_info.pid);
 
-	/* Get current process id and fork off */
-	pid = getpid();
-	switch ((dbg_pid = fork()))
+		printf("*** Fatal Error ***\n"
+		       "%s (signal %i)\n", sigdesc, crash_info.signum);
+		if(crash_info.has_siginfo)
+			printf("Address: %p\n", crash_info.siginfo.si_addr);
+		fputc('\n', stdout);
+		fflush(stdout);
+	}
+
+	sys_info();
+
+	crash_info.buf[sizeof(crash_info.buf)-1] = '\0';
+	printf("%s\n", crash_info.buf);
+	fflush(stdout);
+
+	if(crash_info.pid > 0)
 	{
-		/* Error */
-		case -1:
-			break;
-
-		case 0:
-			fprintf(stderr, "\n\n*** Fatal Error ***\n"
-			                "%s (signal %i)\n", sigdesc, signum);
-
-			/* Redirect shell output */
-			close(STDOUT_FILENO);
-			dup2(fileno(f), STDOUT_FILENO);
-
-			if(f != stderr)
-			{
-				fprintf(stderr, "\nGenerating %s and killing process %i, please wait... ", cc_logfile, pid);
-				fprintf(f, "*** Fatal Error ***\n"
-				           "%s (signal %i)\n", sigdesc, signum);
-			}
-			if(siginfo)
-				fprintf(f, "Address: %p\n", siginfo->si_addr);
-			fputc('\n', f);
-			fflush(f);
-
-			/* Get info */
-			sys_info();
-			if(cc_user_info)
-			{
-				if(cc_user_info(user_info_buf, user_info_buf+sizeof(user_info_buf)) > 0)
-				{
-					fprintf(f, "%s\n", user_info_buf);
-					fflush(f);
-				}
-			}
-			gdb_info(pid);
-
-#if 0 /* Why won't this work? */
-			if(ucontext)
-			{
-				unsigned char *ptr = ucontext->uc_stack.ss_sp;
-				size_t len;
-
-				fprintf(f, "\n* Stack\n");
-				for(len = ucontext->uc_stack.ss_size/4;len > 0; len -= 4)
-				{
-					fprintf(f, "0x%08x:", (int)ptr);
-					for(i = 0;i < ((len < 4) ? len : 4);++i)
-					{
-						fprintf(f, " %02x%02x%02x%02x", ptr[i*4 + 0], ptr[i*4 + 1],
-						                                ptr[i*4 + 2], ptr[i*4 + 3]);
-					}
-					fputc(' ', f);
-					fflush(f);
-					for(i = 0;i < ((len < 4) ? len : 4);++i)
-					{
-						fprintf(f, "%c", *(ptr++));
-						fprintf(f, "%c", *(ptr++));
-						fprintf(f, "%c", *(ptr++));
-						fprintf(f, "%c", *(ptr++));
-					}
-					fputc('\n', f);
-					fflush(f);
-				}
-			}
-#endif
-
-			if(f != stderr)
-			{
-				fclose(f);
-#if (defined __unix__)
-				if(cc_logfile)
-				{
-					char buf[256];
-					snprintf(buf, sizeof(buf),
-					         "if (which gxmessage > /dev/null 2>&1);"
-					             "then gxmessage -buttons \"Damn it:0\" -center -title \"Very Fatal Error\" -file %s;"
-					         "elif (which xmessage > /dev/null 2>&1);"
-					             "then xmessage -buttons \"Damn it:0\" -center -file %s -geometry 600x400;"
-					         "fi", cc_logfile, cc_logfile);
-					system(buf);
-				}
-#endif
-			}
-
-			_exit(0);
-
-		default:
-			/* Wait and let the child attach gdb */
-			waitpid(dbg_pid, NULL, 0);
+		gdb_info(crash_info.pid);
+		kill(crash_info.pid, SIGKILL);
 	}
+
+	if(logfile)
+	{
+		const char *str;
+		char buf[512];
+
+		if((str=getenv("KDE_FULL_SESSION")) && strcmp(str, "true") == 0)
+			snprintf(buf, sizeof(buf), "kdialog --title \"Very Fatal Error\" --textbox \"%s\" 800 600", logfile);
+		else if((str=getenv("GNOME_DESKTOP_SESSION_ID")) && str[0] != '\0')
+			snprintf(buf, sizeof(buf), "gxmessage -buttons \"Okay:0\" -geometry 800x600 -title \"Very Fatal Error\" -center -file \"%s\"", logfile);
+		else
+			snprintf(buf, sizeof(buf), "xmessage -buttons \"Okay:0\" -center -file \"%s\"", logfile);
+
+		system(buf);
+	}
+	exit(0);
 }
 
-int cc_install_handlers(int num_signals, int *signals, const char *logfile, int (*user_info)(char*, char*))
+int cc_install_handlers(int argc, char **argv, int num_signals, int *signals, const char *logfile, int (*user_info)(char*, char*))
 {
-	int retval = 0;
 	struct sigaction sa;
-	memset(&sa, 0, sizeof(sa));
+	stack_t altss;
+	int retval;
 
-	sa.sa_sigaction = crash_catcher;
-	
-#if !defined(__FreeBSD__) && !defined(__APPLE__)
-	sa.sa_flags = SA_ONESHOT | SA_NODEFER | SA_SIGINFO;
-#else
-	sa.sa_flags = SA_NODEFER | SA_SIGINFO;
-#endif
+	if(argc == 2 && strcmp(argv[1], crash_switch) == 0)
+		crash_handler(logfile);
 
-	cc_logfile = logfile;
 	cc_user_info = user_info;
 
+	if(argv[0][0] == '/')
+		snprintf(argv0, sizeof(argv0), "%s", argv[0]);
+	else
+	{
+		getcwd(argv0, sizeof(argv0));
+		retval = strlen(argv0);
+		snprintf(argv0+retval, sizeof(argv0)-retval, "/%s", argv[0]);
+	}
+
+	/* Set an alternate signal stack so SIGSEGVs caused by stack overflows
+	 * still run */
+	altss.ss_sp = altstack;
+	altss.ss_flags = 0;
+	altss.ss_size = sizeof(altstack);
+	sigaltstack(&altss, NULL);
+
+	memset(&sa, 0, sizeof(sa));
+	sa.sa_sigaction = crash_catcher;
+	sa.sa_flags = SA_RESETHAND | SA_NODEFER | SA_SIGINFO | SA_ONSTACK;
+	sigemptyset(&sa.sa_mask);
+
+	retval = 0;
 	while(num_signals--)
 	{
 		if((*signals != SIGSEGV && *signals != SIGILL && *signals != SIGFPE &&
@@ -408,6 +422,5 @@ int cc_install_handlers(int num_signals, int *signals, const char *logfile, int
 		}
 		++signals;
 	}
-
 	return retval;
 }
diff --git a/src/sdl/i_main.cpp b/src/sdl/i_main.cpp
index dc1dbfa055..dc5b82e0cf 100644
--- a/src/sdl/i_main.cpp
+++ b/src/sdl/i_main.cpp
@@ -73,7 +73,7 @@
 
 // EXTERNAL FUNCTION PROTOTYPES --------------------------------------------
 
-extern "C" int cc_install_handlers(int, int*, const char*, int(*)(char*, char*));
+extern "C" int cc_install_handlers(int, char**, int, int*, const char*, int(*)(char*, char*));
 
 // PUBLIC FUNCTION PROTOTYPES ----------------------------------------------
 
@@ -156,13 +156,14 @@ static void STACK_ARGS NewFailure ()
 static int DoomSpecificInfo (char *buffer, char *end)
 {
 	const char *arg;
-	int size = end-buffer;
+	int size = end-buffer-2;
 	int i, p;
 
-	SDL_Quit();
-
 	p = 0;
 	p += snprintf (buffer+p, size-p, GAMENAME" version " DOTVERSIONSTR " (" __DATE__ ")\n");
+#ifdef __VERSION__
+	p += snprintf (buffer+p, size-p, "Compiler version: %s\n", __VERSION__);
+#endif
 	p += snprintf (buffer+p, size-p, "\nCommand line:");
 	for (i = 0; i < Args->NumArgs(); ++i)
 	{
@@ -250,14 +251,14 @@ void I_ShutdownJoysticks();
 
 int main (int argc, char **argv)
 {
-	printf(GAMENAME" v%s - SVN revision %s - SDL version\nCompiled on %s\n\n",
-		DOTVERSIONSTR_NOREV,SVN_REVISION_STRING,__DATE__);
-
 	{
 		int s[4] = { SIGSEGV, SIGILL, SIGFPE, SIGBUS };
-		cc_install_handlers(4, s, "zdoom-crash.log", DoomSpecificInfo);
+		cc_install_handlers(argc, argv, 4, s, "zdoom-crash.log", DoomSpecificInfo);
 	}
 
+	printf(GAMENAME" v%s - SVN revision %s - SDL version\nCompiled on %s\n\n",
+		DOTVERSIONSTR_NOREV,SVN_REVISION_STRING,__DATE__);
+
 	seteuid (getuid ());
     std::set_new_handler (NewFailure);
 
diff --git a/src/sdl/i_system.cpp b/src/sdl/i_system.cpp
index 6fc29665ce..af717324e1 100644
--- a/src/sdl/i_system.cpp
+++ b/src/sdl/i_system.cpp
@@ -608,6 +608,57 @@ int I_PickIWad (WadStuff *wads, int numwads, bool showwin, int defaultiwad)
 		return defaultiwad;
 	}
 
+#if !defined(__APPLE__)
+	const char *str;
+	if((str=getenv("KDE_FULL_SESSION")) && strcmp(str, "true") == 0)
+	{
+		FString cmd("kdialog --title \""GAMESIG" "DOTVERSIONSTR": Select an IWAD to use\""
+		            " --menu \"ZDoom found more than one IWAD\n"
+		            "Select from the list below to determine which one to use:\"");
+
+		for(i = 0; i < numwads; ++i)
+		{
+			const char *filepart = strrchr(wads[i].Path, '/');
+			if(filepart == NULL)
+				filepart = wads[i].Path;
+			else
+				filepart++;
+			// Menu entries are specified in "tag" "item" pairs, where when a
+			// particular item is selected (and the Okay button clicked), its
+			// corresponding tag is printed to stdout for identification.
+			cmd.AppendFormat(" \"%d\" \"%s (%s)\"", i, wads[i].Name.GetChars(), filepart);
+		}
+
+		if(defaultiwad >= 0 && defaultiwad < numwads)
+		{
+			const char *filepart = strrchr(wads[defaultiwad].Path, '/');
+			if(filepart == NULL)
+				filepart = wads[defaultiwad].Path;
+			else
+				filepart++;
+			cmd.AppendFormat(" --default \"%s (%s)\"", wads[defaultiwad].Name.GetChars(), filepart);
+		}
+
+		FILE *f = popen(cmd, "r");
+		if(f != NULL)
+		{
+			char gotstr[16];
+
+			if(fgets(gotstr, sizeof(gotstr), f) == NULL ||
+			   sscanf(gotstr, "%d", &i) != 1)
+				i = -1;
+
+			// Exit status = 1 means the selection was canceled (either by
+			// Cancel/Esc or the X button), not that there was an error running
+			// the program. In that case, nothing was printed so fgets will
+			// have failed. Other values can indicate an error running the app,
+			// so fall back to whatever else can be used.
+			int status = pclose(f);
+			if(WIFEXITED(status) && (WEXITSTATUS(status) == 0 || WEXITSTATUS(status) == 1))
+				return i;
+		}
+	}
+#endif
 #ifndef NO_GTK
 	if (GtkAvailable)
 	{
diff --git a/src/sound/fmodsound.cpp b/src/sound/fmodsound.cpp
index 3993220619..182ba488da 100644
--- a/src/sound/fmodsound.cpp
+++ b/src/sound/fmodsound.cpp
@@ -2555,7 +2555,7 @@ void FMODSoundRenderer::DrawWaveDebug(int mode)
 	// 16 pixels of padding between each window.
 	window_size = (screen->GetWidth() - 16) / numoutchans - 16;
 
-	float *wavearray = (float*)alloca(window_size*sizeof(float));
+	float *wavearray = (float*)alloca(MAX(SPECTRUM_SIZE,window_size)*sizeof(float));
 
 	y = 16;
 	y = DrawChannelGroupOutput(SfxGroup, wavearray, window_size, window_height, y, mode);
diff --git a/src/tables.h b/src/tables.h
index 72a79383dd..aeb2c6991d 100644
--- a/src/tables.h
+++ b/src/tables.h
@@ -60,7 +60,7 @@ extern	fixed_t 		finesine[5*FINEANGLES/4];
 // (encapsulated in a struct so that we can still use array accesses).
 struct cosine_inline
 {
-	fixed_t operator[] (unsigned int x)
+	fixed_t operator[] (unsigned int x) const
 	{
 		return finesine[x+FINEANGLES/4];
 	}
diff --git a/src/textures/buildtexture.cpp b/src/textures/buildtexture.cpp
index 2a3d1809f9..836cc2daa7 100644
--- a/src/textures/buildtexture.cpp
+++ b/src/textures/buildtexture.cpp
@@ -234,6 +234,7 @@ void FTextureManager::AddTiles (void *tiles)
 			rot.Texture[8] =
 			rot.Texture[9] = texnum.GetIndex() + 4;
 			rot.Flip = 0x00FC;
+			rot.Voxel = NULL;
 			tex->Rotations = SpriteFrames.Push (rot);
 		}
 		else if (rotType == 2)
@@ -247,6 +248,7 @@ void FTextureManager::AddTiles (void *tiles)
 				rot.Texture[17-j*2] = texnum.GetIndex() + j;
 			}
 			rot.Flip = 0;
+			rot.Voxel = NULL;
 			tex->Rotations = SpriteFrames.Push (rot);
 		}
 	}
diff --git a/src/thingdef/thingdef_properties.cpp b/src/thingdef/thingdef_properties.cpp
index d41d79891a..f7221c4350 100644
--- a/src/thingdef/thingdef_properties.cpp
+++ b/src/thingdef/thingdef_properties.cpp
@@ -2070,6 +2070,15 @@ DEFINE_CLASS_PROPERTY_PREFIX(player, morphweapon, S, PlayerPawn)
 	defaults->MorphWeapon = FName(z);
 }
 
+//==========================================================================
+//
+//==========================================================================
+DEFINE_CLASS_PROPERTY_PREFIX(player, flechettetype, S, PlayerPawn)
+{
+	PROP_STRING_PARM(str, 0);
+	defaults->FlechetteType = FindClassTentative(str, "ArtiPoisonBag");
+}
+
 //==========================================================================
 //
 //==========================================================================
diff --git a/src/v_video.cpp b/src/v_video.cpp
index 450650f53b..1986a2a971 100644
--- a/src/v_video.cpp
+++ b/src/v_video.cpp
@@ -1313,6 +1313,21 @@ void DFrameBuffer::RenderView(player_t *player)
 	FCanvasTextureInfo::UpdateAll ();
 }
 
+//==========================================================================
+//
+//
+//
+//==========================================================================
+extern TDeletingArray<FVoxel *> Voxels;
+
+void DFrameBuffer::RemapVoxels()
+{
+	for (unsigned i=0; i<Voxels.Size(); i++)
+	{
+		Voxels[i]->Remap();
+	}
+}
+
 //===========================================================================
 //
 // Render the view to a savegame picture
@@ -1689,6 +1704,7 @@ void V_Init2()
 		Printf ("Resolution: %d x %d\n", SCREENWIDTH, SCREENHEIGHT);
 
 	screen->SetGamma (gamma);
+	screen->RemapVoxels();
 	FBaseCVar::ResetColors ();
 	C_NewModeAdjust();
 	M_InitVideoModesMenu();
@@ -1733,43 +1749,61 @@ CUSTOM_CVAR (Int, vid_aspect, 0, CVAR_GLOBALCONFIG|CVAR_ARCHIVE)
 // 1: 16:9
 // 2: 16:10
 // 4: 5:4
-int CheckRatio (int width, int height)
+int CheckRatio (int width, int height, int *trueratio)
 {
+	int fakeratio = -1;
+	int ratio;
+
 	if ((vid_aspect >=1) && (vid_aspect <=4))
 	{
 		// [SP] User wants to force aspect ratio; let them.
-		return vid_aspect == 3? 0: int(vid_aspect);
+		fakeratio = vid_aspect == 3? 0: int(vid_aspect);
 	}
 	if (vid_nowidescreen)
 	{
 		if (!vid_tft)
 		{
-			return 0;
+			fakeratio = 0;
+		}
+		else
+		{
+			fakeratio = (height * 5/4 == width) ? 4 : 0;
 		}
-		return (height * 5/4 == width) ? 4 : 0;
 	}
 	// If the size is approximately 16:9, consider it so.
 	if (abs (height * 16/9 - width) < 10)
 	{
-		return 1;
+		ratio = 1;
 	}
 	// 16:10 has more variance in the pixel dimensions. Grr.
-	if (abs (height * 16/10 - width) < 60)
+	else if (abs (height * 16/10 - width) < 60)
 	{
 		// 320x200 and 640x400 are always 4:3, not 16:10
 		if ((width == 320 && height == 200) || (width == 640 && height == 400))
 		{
-			return 0;
+			ratio = 0;
+		}
+		else
+		{
+			ratio = 2;
 		}
-		return 2;
 	}
 	// Unless vid_tft is set, 1280x1024 is 4:3, not 5:4.
-	if (height * 5/4 == width && vid_tft)
+	else if (height * 5/4 == width && vid_tft)
 	{
-		return 4;
+		ratio = 4;
 	}
 	// Assume anything else is 4:3.
-	return 0;
+	else
+	{
+		ratio = 0;
+	}
+
+	if (trueratio != NULL)
+	{
+		*trueratio = ratio;
+	}
+	return (fakeratio >= 0) ? fakeratio : ratio;
 }
 
 // First column: Base width (unused)
diff --git a/src/v_video.h b/src/v_video.h
index 0fb9eaf8aa..b56a4d2895 100644
--- a/src/v_video.h
+++ b/src/v_video.h
@@ -364,6 +364,9 @@ public:
 	// Set the rect defining the area affected by blending.
 	virtual void SetBlendingRect (int x1, int y1, int x2, int y2);
 
+	// Remap voxel palette
+	virtual void RemapVoxels();
+
 	// render 3D view
 	virtual void RenderView(player_t *player);
 
@@ -500,7 +503,7 @@ void V_DrawFrame (int left, int top, int width, int height);
 extern "C" void ASM_PatchPitch (void);
 #endif
 
-int CheckRatio (int width, int height);
+int CheckRatio (int width, int height, int *trueratio=NULL);
 static inline int CheckRatio (double width, double height) { return CheckRatio(int(width), int(height)); }
 extern const int BaseRatioSizes[5][4];
 
diff --git a/src/version.h b/src/version.h
index 32cd44b398..5edcb71087 100644
--- a/src/version.h
+++ b/src/version.h
@@ -64,7 +64,7 @@
 // Protocol version used in demos.
 // Bump it if you change existing DEM_ commands or add new ones.
 // Otherwise, it should be safe to leave it alone.
-#define DEMOGAMEVERSION 0x213
+#define DEMOGAMEVERSION 0x214
 
 // Minimum demo version we can play.
 // Bump it whenever you change or remove existing DEM_ commands.
@@ -75,7 +75,7 @@
 // SAVESIG should match SAVEVER.
 
 // MINSAVEVER is the minimum level snapshot version that can be loaded.
-#define MINSAVEVER 3030
+#define MINSAVEVER 3085
 
 #if SVN_REVISION_NUMBER < MINSAVEVER
 // If we don't know the current revision write something very high to ensure that
diff --git a/src/w_wad.h b/src/w_wad.h
index dc1ea7794c..76d94959d6 100644
--- a/src/w_wad.h
+++ b/src/w_wad.h
@@ -62,6 +62,7 @@ typedef enum {
 	ns_bloodmisc,
 	ns_strifevoices,
 	ns_hires,
+	ns_voxels,
 
 	// These namespaces are only used to mark lumps in special subdirectories
 	// so that their contents doesn't interfere with the global namespace.
diff --git a/src/win32/fb_d3d9.cpp b/src/win32/fb_d3d9.cpp
index cc036d5401..b0f25bbe1b 100644
--- a/src/win32/fb_d3d9.cpp
+++ b/src/win32/fb_d3d9.cpp
@@ -3677,6 +3677,14 @@ bool D3DFB::SetStyle(D3DTex *tex, DrawParms &parms, D3DCOLOR &color0, D3DCOLOR &
 		alpha = clamp<fixed_t> (parms.alpha, 0, FRACUNIT) / 65536.f;
 	}
 
+	style.CheckFuzz();
+	if (style.BlendOp == STYLEOP_Shadow)
+	{
+		style = LegacyRenderStyles[STYLE_TranslucentStencil];
+		alpha = 0.3f;
+		parms.fillcolor = 0;
+	}
+
 	// FIXME: Fuzz effect is not written
 	if (style.BlendOp == STYLEOP_FuzzOrAdd || style.BlendOp == STYLEOP_Fuzz)
 	{
diff --git a/wadsrc/static/actors/hexen/clericplayer.txt b/wadsrc/static/actors/hexen/clericplayer.txt
index 73276e9815..6e16585942 100644
--- a/wadsrc/static/actors/hexen/clericplayer.txt
+++ b/wadsrc/static/actors/hexen/clericplayer.txt
@@ -28,6 +28,7 @@ ACTOR ClericPlayer : PlayerPawn
 	Player.WeaponSlot 2, CWeapStaff
 	Player.WeaponSlot 3, CWeapFlame
 	Player.WeaponSlot 4, CWeapWraithverge
+	Player.FlechetteType "ArtiPoisonBag1"
 	
 	Player.ColorRange 146, 163
 	Player.Colorset		0, "Blue",			146, 163,    161
diff --git a/wadsrc/static/actors/hexen/mageplayer.txt b/wadsrc/static/actors/hexen/mageplayer.txt
index d843b00a9c..1690cbf729 100644
--- a/wadsrc/static/actors/hexen/mageplayer.txt
+++ b/wadsrc/static/actors/hexen/mageplayer.txt
@@ -30,6 +30,7 @@ ACTOR MagePlayer : PlayerPawn
 	Player.WeaponSlot 2, MWeapFrost
 	Player.WeaponSlot 3, MWeapLightning
 	Player.WeaponSlot 4, MWeapBloodscourge
+	Player.FlechetteType "ArtiPoisonBag2"
 	
 	Player.ColorRange 146, 163
 	Player.Colorset		0, "Blue",			146, 163,    161
diff --git a/wadsrc/static/actors/shared/player.txt b/wadsrc/static/actors/shared/player.txt
index 194e58048f..2752412e7d 100644
--- a/wadsrc/static/actors/shared/player.txt
+++ b/wadsrc/static/actors/shared/player.txt
@@ -28,6 +28,7 @@ Actor PlayerPawn : Actor native
 	Player.SoundClass "player"
 	Player.DamageScreenColor "ff 00 00"
 	Player.MugShotMaxHealth 0
+	Player.FlechetteType "ArtiPoisonBag3"
 }
 
 Actor PlayerChunk : PlayerPawn native
diff --git a/wadsrc/static/iwadinfo.txt b/wadsrc/static/iwadinfo.txt
index 7a94f244ad..efdf836a59 100644
--- a/wadsrc/static/iwadinfo.txt
+++ b/wadsrc/static/iwadinfo.txt
@@ -26,7 +26,6 @@ IWad
 	Game = "Doom"
 	Config = "UrbanBrawl"
 	Mapinfo = "mapinfo/urbanbrawl.txt"
-	Compatibility = "Portals"
 	MustContain = "MAP01", "AD2LIB"
 	BannerColors = "a8 a8 00", "a8 00 00"
 }
diff --git a/wadsrc/static/menudef.txt b/wadsrc/static/menudef.txt
index 6233294287..746b68ed29 100644
--- a/wadsrc/static/menudef.txt
+++ b/wadsrc/static/menudef.txt
@@ -640,6 +640,13 @@ OptionValue Contrast
 	2.0, "Smooth"
 }
 
+OptionValue Fuzziness
+{
+	0.0, "Translucent"
+	1.0, "Fuzz"
+	2.0, "Shadow"
+}
+
 OptionMenu "VideoOptions"
 {
 	Title "DISPLAY OPTIONS"
@@ -662,7 +669,7 @@ OptionMenu "VideoOptions"
 	}
 	
 	Option "Stretch short skies",		"r_stretchsky", "OnOff"
-	Option "Use fuzz effect",			"r_drawfuzz", "YesNo"
+	Option "Use fuzz effect",			"r_drawfuzz", "Fuzziness"
 	Slider "Lost Soul translucency",	"transsouls", 0.25, 1.0, 0.05, 2
 	Option "Use fake contrast",			"r_fakecontrast", "Contrast"
 	Option "Rocket Trails",				"cl_rockettrails", "RocketTrailTypes"
diff --git a/wadsrc/static/sbarinfo/hexen.txt b/wadsrc/static/sbarinfo/hexen.txt
index 635cb650f8..e7a4c6c40e 100755
--- a/wadsrc/static/sbarinfo/hexen.txt
+++ b/wadsrc/static/sbarinfo/hexen.txt
@@ -114,29 +114,26 @@ statusbar Normal
 	drawimage "ARMCLS", 255, 178;
 	drawnumber 2, HUDFONT_RAVEN, untranslated, armorclass, 275, 176, 1;
 
-	playerclass Cleric
+	playertype ClericPlayer
 	{
 		drawimage "WPSLOT1", 190, 162;
-		hasweaponpiece CWeapWraithverge, 1
+		ininventory CWeapWraithverge
 		{
-			drawimage "WPIECEC1", 190, 162;
+			drawimage "WPFULL1", 190, 162;
 		}
-		hasweaponpiece CWeapWraithverge, 2
-		{
-			drawimage "WPIECEC2", 212, 162;
-		}
-		hasweaponpiece CWeapWraithverge, 3
-		{
-			drawimage "WPIECEC3", 225, 162;
-		}
-		hasweaponpiece CWeapWraithverge, 1
+		else
 		{
+			hasweaponpiece CWeapWraithverge, 1
+			{
+				drawimage "WPIECEC1", 190, 162;
+			}
 			hasweaponpiece CWeapWraithverge, 2
 			{
-				hasweaponpiece CWeapWraithverge, 3
-				{
-					drawimage "WPFULL1", 190, 162;
-				}
+				drawimage "WPIECEC2", 212, 162;
+			}
+			hasweaponpiece CWeapWraithverge, 3
+			{
+				drawimage "WPIECEC3", 225, 162;
 			}
 		}
 
@@ -145,29 +142,26 @@ statusbar Normal
 		else
 			drawgem translatable, interpolate(6), "CHAIN2", "LIFEGMC2", -23, 49, 15, 30, 193;
 	}
-	else playerclass Mage
+	else playertype MagePlayer
 	{
 		drawimage "WPSLOT2", 190, 162;
-		hasweaponpiece MWeapBloodscourge, 1
+		ininventory MWeapBloodscourge
 		{
-			drawimage "WPIECEM1", 190, 162;
+			drawimage "WPFULL2", 190, 162;
 		}
-		hasweaponpiece MWeapBloodscourge, 2
-		{
-			drawimage "WPIECEM2", 205, 162;
-		}
-		hasweaponpiece MWeapBloodscourge, 3
-		{
-			drawimage "WPIECEM3", 224, 162;
-		}
-		hasweaponpiece MWeapBloodscourge, 1
+		else
 		{
+			hasweaponpiece MWeapBloodscourge, 1
+			{
+				drawimage "WPIECEM1", 190, 162;
+			}
 			hasweaponpiece MWeapBloodscourge, 2
 			{
-				hasweaponpiece MWeapBloodscourge, 3
-				{
-					drawimage "WPFULL2", 190, 162;
-				}
+				drawimage "WPIECEM2", 205, 162;
+			}
+			hasweaponpiece MWeapBloodscourge, 3
+			{
+				drawimage "WPIECEM3", 224, 162;
 			}
 		}
 
@@ -179,26 +173,23 @@ statusbar Normal
 	else
 	{
 		drawimage "WPSLOT0", 190, 162;
-		hasweaponpiece FWeapQuietus, 1
+		ininventory FWeapQuietus
 		{
-			drawimage "WPIECEF1", 190, 162;
+			drawimage "WPFULL0", 190, 162;
 		}
-		hasweaponpiece FWeapQuietus, 2
-		{
-			drawimage "WPIECEF2", 225, 162;
-		}
-		hasweaponpiece FWeapQuietus, 3
-		{
-			drawimage "WPIECEF3", 234, 162;
-		}
-		hasweaponpiece FWeapQuietus, 1
+		else
 		{
+			hasweaponpiece FWeapQuietus, 1
+			{
+				drawimage "WPIECEF1", 190, 162;
+			}
 			hasweaponpiece FWeapQuietus, 2
 			{
-				hasweaponpiece FWeapQuietus, 3
-				{
-					drawimage "WPFULL0", 190, 162;
-				}
+				drawimage "WPIECEF2", 225, 162;
+			}
+			hasweaponpiece FWeapQuietus, 3
+			{
+				drawimage "WPIECEF3", 234, 162;
 			}
 		}
 
@@ -222,21 +213,21 @@ statusbar Automap
 	drawimage hexenarmor amulet, "ARMSLOT4", 243, 164;
 
 	// Also draw the life gem here
-	playerclass Fighter
+	playertype FighterPlayer
 	{
 		gamemode singleplayer
 			drawgem interpolate(6), "CHAIN", "LIFEGMF2", -23, 49, 15, 30, 193;
 		else
 			drawgem translatable, interpolate(6), "CHAIN", "LIFEGMF2", -23, 49, 15, 30, 193;
 	}
-	else playerclass Cleric
+	else playertype ClericPlayer
 	{
 		gamemode singleplayer
 			drawgem interpolate(6), "CHAIN2", "LIFEGMC2", -23, 49, 15, 30, 193;
 		else
 			drawgem translatable, interpolate(6), "CHAIN2", "LIFEGMC2", -23, 49, 15, 30, 193;
 	}
-	else playerclass Mage
+	else playertype MagePlayer
 	{
 		gamemode singleplayer
 			drawgem interpolate(6), "CHAIN3", "LIFEGMM2", -23, 49, 15, 30, 193;
diff --git a/zdoom.vcproj b/zdoom.vcproj
index d50e8b4f6e..ce28343243 100644
--- a/zdoom.vcproj
+++ b/zdoom.vcproj
@@ -704,6 +704,10 @@
 				RelativePath=".\src\md5.cpp"
 				>
 			</File>
+			<File
+				RelativePath=".\src\memarena.cpp"
+				>
+			</File>
 			<File
 				RelativePath=".\src\name.cpp"
 				>
@@ -1353,6 +1357,10 @@
 				RelativePath=".\src\md5.h"
 				>
 			</File>
+			<File
+				RelativePath=".\src\memarena.h"
+				>
+			</File>
 			<File
 				RelativePath=".\src\mscinlines.h"
 				>