Removed more unused stuff.

Finally finished ingame OpenGL code (I hope).

Fixed another mistake in mathline.c.

17 files changed, 600 insertions, 1378 deletions

diff --git a/TODO b/TODO
index cceb0f8..1039560 100644
--- a/TODO
+++ b/TODO
@@ -1,2 +1,28 @@
+[DONE] [08/24/01] Finish OpenGL code.
+* Fix sound code.
+* See if RGT will respond.
+* Menus.
+* Proper file loading/saving (ignore case, search certain directories) and
+  config handling (~/.avp/{ge, re, ad, md, pd}/?)
+* Command line options.
+* CD Audio.
+* Try to get demos and regular edition to work.
+* See what FOX/Rebellion has to say (if anything) about redistribution of the
+  demos and if its possible to create an installer for regular/gold edition
+  CDs.
+* Put together a workaround if RGT plan fails.
+* See if the build process can be made easier for those who download the
+  source.
+* Write documentation.
+* Prep for a release.  Get someone who has a saner system to build binaries.
+  Look into loki_setup.
+* "Beta test."  Play through the game at least once starting with a clean
+  install.
+* Release. And the crowd goes wild.
+* Fix any bugs found after previous release.
+* Add networking and everything related (dedicated server, master server,
+  etc.)
+* Release new version. And fix bugs, and release new version, and so on.
+----
 * Debug, verify, and reimplant the inline functions in mathline.c to
   inline.h
diff --git a/src/avp/bh_agun.c b/src/avp/bh_agun.c
index b0471bc..2926df5 100644
--- a/src/avp/bh_agun.c
+++ b/src/avp/bh_agun.c
@@ -44,8 +44,6 @@
 #include "sfx.h"
 #include "bh_marin.h"
 #include "bh_far.h"
-#include "pldghost.h"
-#include "pheromon.h"
 #include "targeting.h"
 #include "dxlog.h"
 #include "los.h"
diff --git a/src/avp/bh_debri.c b/src/avp/bh_debri.c
index c7bbc73..b3c1bf4 100644
--- a/src/avp/bh_debri.c
+++ b/src/avp/bh_debri.c
@@ -1711,7 +1711,6 @@ void SaveStrategy_HierarchicalDebris(STRATEGYBLOCK* sbPtr)
 /*------------------**
 ** Load/Save Debris **
 **------------------*/
-#include "savegame.h"
 
 typedef struct debris_save_block
 {
@@ -1864,4 +1863,4 @@ void SaveStrategy_Debris(STRATEGYBLOCK* sbPtr)
 	block->integrity = sbPtr->integrity;
 	block->SBDamageBlock = sbPtr->SBDamageBlock;
 
-}
\ No newline at end of file
+}
diff --git a/src/avp/bh_dummy.c b/src/avp/bh_dummy.c
index cf363f6..4fc2803 100644
--- a/src/avp/bh_dummy.c
+++ b/src/avp/bh_dummy.c
@@ -43,8 +43,6 @@
 #include "bh_marin.h"
 #include "bh_dummy.h"
 #include "bh_far.h"
-#include "pldghost.h"
-#include "pheromon.h"
 #include "targeting.h"
 #include "dxlog.h"
 #include "los.h"
diff --git a/src/avp/bh_gener.c b/src/avp/bh_gener.c
index 3e6fc30..2477248 100644
--- a/src/avp/bh_gener.c
+++ b/src/avp/bh_gener.c
@@ -15,7 +15,6 @@
 #include "pvisible.h"
 #include "pheromon.h"
 #include "bh_far.h"
-#include "bh_marin.h"
 #include "pldghost.h"
 
 #include "load_shp.h" 
@@ -59,47 +58,6 @@ int ShowHiveState=0;
 FILE *logFile;
 #endif
 
-/* load generator parameters: pc only*/
-//paramaters now got from rif file
-#define LOAD_PC_GENERATORPARAMS 0
-#if LOAD_PC_GENERATORPARAMS
-	static void LoadGeneratorParams(void);	
-
-
-/* Level hive/generator parameters -----------------------------
-
-Format:	max npcs, initial npcs per minute, 
-		change in npcs per minute (per minute, approx)
---------------------------------------------------------------*/ 
-HIVELEVELPARAMS hiveLevelData[] = 
-{
-{25,4,2,(ONE_FIXED*60)},	/* gen 1 : */
-{25,4,2,(ONE_FIXED*90)},	/* gen 2 : */
-{25,4,2,(ONE_FIXED*120)},	/* gen 3 : */
-{25,4,2,(ONE_FIXED*60)},	/* gen 4 : */
-{25,4,2,(ONE_FIXED*60)},	/* Medlab : */
-{25,4,2,(ONE_FIXED*60)},	/* cmc 1 : */
-{25,4,2,(ONE_FIXED*60)},	/* cmc 2 : */
-{25,4,2,(ONE_FIXED*60)},	/* cmc 3 : */
-{25,4,2,(ONE_FIXED*120)},	/* cmc 4 : */
-{25,4,2,(ONE_FIXED*60)},	/* cmc 5 : */
-{25,4,2,(ONE_FIXED*90)},	/* cmc 6 : */
-{25,4,2,(ONE_FIXED*60)},	/* sp 1 : */
-{25,4,2,(ONE_FIXED*60)},	/* sp 2 : */
-{25,4,2,(ONE_FIXED*60)},	/* sp 3 : */
-{25,4,2,(ONE_FIXED*60)},	/* r&d 1 : */
-{25,4,2,(ONE_FIXED*60)},	/* r&d 2 : */
-{25,4,2,(ONE_FIXED*60)},	/* r&d 3 : */
-{25,4,2,(ONE_FIXED*90)},	/* r&d 4 : */
-{25,4,2,(ONE_FIXED*60)},	/* mps 1 : */
-{25,4,2,(ONE_FIXED*120)},	/* mps 2 : */
-{25,4,2,(ONE_FIXED*60)},	/* mps 3 : */
-{25,4,2,(ONE_FIXED*120)},	/* mps 4 : */
-{25,4,2,(ONE_FIXED*60)},	/* surface : */
-{25,2,1,(ONE_FIXED*120)},	/* entrance : */
-};
-#endif
-
 
 /*
 Stuff for adjusting difficulty level according to player's performance
@@ -919,154 +877,6 @@ void ForceAGenerator(void)
 }
 
 
-#if (SupportWindows95 && LOAD_PC_GENERATORPARAMS)
-static char genFileLine[128];
-static void LoadGeneratorParams(void)
-{
-	FILE* genParamsFile;
-	int numValsRead = 0;
-	
-	genParamsFile = fopen("GENPARAM.TXT","r");
-	
-	/* do nothing if we can't load the file */
-	if(!genParamsFile) return;
-
-	while(fgets((char*)genFileLine,128,genParamsFile))
-	{
-		if(!(strncmp((char*)genFileLine,"#",1))) continue; /* a comment line */
-		if(strlen((char*)genFileLine) > 4) continue; /* too long */
-
-		/* should be a data line... 
-		convert to an int and set appropriate value in hiveData[] */
-		{
-			int thisValue;
-			I_AVP_ENVIRONMENTS thisLevel = 0;
-		
-			thisValue = atoi(genFileLine);
-			switch(numValsRead/3)
-			{
-				case(0):
-				{
-					thisLevel = I_Gen1;
-					break;
-				}
-				case(1):
-				{
-					thisLevel = I_Gen2;
-					break;
-				}
-				case(2):
-				{
-					thisLevel = I_Gen3;
-					break;
-				}
-				case(3):
-				{
-					thisLevel = I_Medlab;
-					break;
-				}
-				case(4):
-				{
-					thisLevel = I_Cmc2;
-					break;
-				}
-				case(5):
-				{
-					thisLevel = I_Cmc4;
-					break;
-				}
-				case(6):
-				{
-					thisLevel = I_Cmc6;
-					break;
-				}
-				case(7):
-				{
-					thisLevel = I_Sp2;
-					break;
-				}
-				case(8):
-				{
-					thisLevel = I_Sp3;
-					break;
-				}
-				case(9):
-				{
-					thisLevel = I_Rnd2;
-					break;
-				}
-				case(10):
-				{
-					thisLevel = I_Rnd3;
-					break;
-				}
-				case(11):
-				{
-					thisLevel = I_Rnd4;
-					break;
-				}
-				case(12):
-				{
-					thisLevel = I_Mps2;
-					break;
-				}
-				case(13):
-				{
-					thisLevel = I_Mps4;
-					break;
-				}
-				case(14):
-				{
-					thisLevel = I_Surface;
-					break;
-				}
-				case(15):
-				{
-					thisLevel = I_Entrance;
-					break;
-				}
-				default:
-				{
-					/* there should only be 16 levels in the file */
-					LOCALASSERT(1==0);
-					continue;
-					break;
-				}
-			}
-
-			switch(numValsRead%3)
-			{
-				case(0):
-				{
-					hiveLevelData[thisLevel].maxGeneratorNPCs = thisValue;
-					break;
-				}
-				case(1):
-				{
-					hiveLevelData[thisLevel].generatorNPCsPerMinute = thisValue;
-					break;
-				}
-				case(2):
-				{
-					hiveLevelData[thisLevel].deltaGeneratorNPCsPerMinute = thisValue;
-					break;
-				}
-				default:
-				{
-					/* there should only be 16 levels in the file */
-					LOCALASSERT(1==0);
-					break;
-				}			
-			}
-		}
-		numValsRead++;
-	}
- 	fclose(genParamsFile);
-}	
-#endif
-
-
-
 void SetHiveParamaters(int enemytype,int max,int genpermin,int deltagenpermin,int time)
 {
 	LoadedHiveData.maxGeneratorNPCs=max;
diff --git a/src/avp/bh_rubberduck.c b/src/avp/bh_rubberduck.c
index afec36b..3e8cdba 100644
--- a/src/avp/bh_rubberduck.c
+++ b/src/avp/bh_rubberduck.c
@@ -6,10 +6,8 @@
 #include "gamedef.h"
 
 #include "bh_types.h"
-//#include "comp_shp.h"
 #include "dynblock.h"
 #include "dynamics.h"
-//#include "lighting.h"
 
 #include "pfarlocs.h"
 
@@ -17,7 +15,6 @@
 #include "load_shp.h"
 #include "particle.h"
 
-#include "bh_types.h"
 #include "bh_rubberduck.h"			   
 #include "bh_weap.h"
 #include "sfx.h"
@@ -339,4 +336,3 @@ void CreateRubberDucks(void)
 		while(--i);
 	}
 }
-	
diff --git a/src/avp/cconvars.cpp b/src/avp/cconvars.cpp
index 38342a9..0ecaa8c 100644
--- a/src/avp/cconvars.cpp
+++ b/src/avp/cconvars.cpp
@@ -18,9 +18,6 @@
 #include "consvar.hpp"
 #include "conscmnd.hpp"
 #include "equipmnt.h"
-#include "inline.h"
-#include "module.h"
-#include "stratdef.h"
 #include "weapons.h"
 #include "bh_queen.h"
 #include "bh_gener.h"
diff --git a/src/avp/game.c b/src/avp/game.c
index 6467de4..11a12eb 100644
--- a/src/avp/game.c
+++ b/src/avp/game.c
@@ -60,7 +60,6 @@
 
 #define	VERSION_DisableStartupMenus 	Yes
 #define VERSION_DisableStartupCredits	Yes
-#include "avp_menus.h"
 
 /******************
 Extern Engine Varibles
diff --git a/src/avp/hud.c b/src/avp/hud.c
index 6f6f02a..e395474 100644
--- a/src/avp/hud.c
+++ b/src/avp/hud.c
@@ -46,7 +46,6 @@
 #include "avp_menus.h"
 #include "showcmds.h"
 #include "game_statistics.h"
-#include "psndplat.h"
 #include "pldnet.h"
 #include "avp_userprofile.h"
 
@@ -311,11 +310,8 @@ void MaintainHUD(void)
 	}
 	RenderGrapplingHook();
 	
-	#if SOFTWARE_RENDERER
-	FlushSoftwareZBuffer();
-	#else
 	SecondFlushD3DZBuffer();
-	#endif
+
 	//DrawFontTest();
 	if (Observer)
 	{
diff --git a/src/avp/messagehistory.c b/src/avp/messagehistory.c
index 3ab3696..d53528c 100644
--- a/src/avp/messagehistory.c
+++ b/src/avp/messagehistory.c
@@ -1,5 +1,4 @@
 #include "3dc.h"
-#include "3dc.h"
 #include "module.h"
 #include "inline.h"
 #include "stratdef.h"
diff --git a/src/avp/win95/d3d_hud.cpp b/src/avp/win95/d3d_hud.cpp
index 854e8e4..3b0f1b4 100644
--- a/src/avp/win95/d3d_hud.cpp
+++ b/src/avp/win95/d3d_hud.cpp
@@ -61,8 +61,6 @@ extern "C++"
 ( \
 		RGBA_MAKE(rr,gg,bb,aa) \
 )
-#include "kshape.h"
-
 
 
 void D3D_DrawHUDFontCharacter(HUDCharDesc *charDescPtr);
@@ -695,17 +693,6 @@ void D3D_BLTGunSightToHUD(int screenX, int screenY, enum GUNSIGHT_SHAPE gunsight
 	Draw_HUDImage(&imageDesc);
 }
 
-void LoadBackdropImage(void)
-{
-#if 1
-	extern int BackdropImage;
-	extern char LevelName[];
-	if (!strcmp(LevelName,"pred03"))
-	  	BackdropImage = CL_LoadImageOnce("Envrnmts\\Pred03\\backdrop.RIM",LIO_D3DTEXTURE|LIO_RELATIVEPATH|LIO_RESTORABLE);
-#endif
-}
-
-
 void Render_HealthAndArmour(unsigned int health, unsigned int armour)
 {
 	HUDCharDesc charDesc;
diff --git a/src/avp/win95/projload.cpp b/src/avp/win95/projload.cpp
index 85a52f5..5bb7277 100644
--- a/src/avp/win95/projload.cpp
+++ b/src/avp/win95/projload.cpp
@@ -52,7 +52,6 @@
 #include "pldnet.h"
 
 extern "C" {
-#include "3dc.h"
 #include "inventry.h"
 
 extern int VideoMode;
diff --git a/src/avp/win95/system.c b/src/avp/win95/system.c
index 7914c4c..d6fcfdd 100644
--- a/src/avp/win95/system.c
+++ b/src/avp/win95/system.c
@@ -778,8 +778,8 @@ void LoadRifFile()
 	#endif
 	copy_rif_data(env_rif,CCF_ENVIRONMENT,PBAR_LEVEL_START+PBAR_LEVEL_INTERVAL*.4,PBAR_LEVEL_INTERVAL*.6);
 	//setup_shading_tables();
-	//LoadBackdropImage();
 }
+
 int Destroy_CurrentEnvironment(void)
 {
 	// RWH destroys all en specific data
diff --git a/src/genparam.txt b/src/genparam.txt
deleted file mode 100644
index 988f67e..0000000
--- a/src/genparam.txt
+++ /dev/null
@@ -1,140 +0,0 @@
-# AVP ALIEN GENERATOR DATA FILE
-#
-# This file contains level parameters for alien/marine generation.
-# There are three parameters defined for each level:
-# 1. Maximum number of aliens/marines in the level
-# 2. Number of aliens/marines generated per minute
-# 3. The increase in number generated per minute, per minute
-# 
-# For an example of how these parameters work: if the initial
-# number of aliens generated per minute is 3, and the increase
-# in number per minute is 2, then during the first minute of
-# play time 3 aliens will be generated, during the second minute
-# 5 more will be generated, and during the third minute another
-# 7 will be generated.
-#
-# The format of this file is: comment lines start with a hash,
-# and each data item sits a new line. Each data item is preceeded
-# with a comment, stating what it is 
-# 
-# CHANGING THIS FILE
-# ------------------
-# You may change any parameter for any level in this file. Save the
-# file, and the next time you run the game the new parameter value
-# will be used... however, you must follow these rules:
-#
-# 1. Stick to the format conventions described above
-# 2. Do not insert comment lines longer than 80 characters
-# 3. Do not change the order of the data items in this file
-# 4. Do not save the file as anything other than a ASCII text file
-# If you just edit the particular data item you are interested in,
-# and then save the file, you shouldn't get any problems.
-#  
-# Value Ranges
-# ------------
-# Maximum number of aliens should be between 0 and 255:
-# 25 is a typical value.
-# Aliens per minute should be between 0 and 255:
-# 3 is a typical value
-# Increase in aliens per minute should be between 0 and 255
-# 2 is a typical value
-#
-# Patrick.
-# -----------------------------------------------------------------
-#
-# GEN 1 (GENERAL ACCESS) : MAX ALIENS
-25
-# GEN 1 (GENERAL ACCESS) : ALIENS PER MINUTE
-3
-# GEN 1 (GENERAL ACCESS) : INCREASE IN ALIENS PER MINUTE
-2
-# GEN 2 (LIVING QUARTERS) : MAX ALIENS
-25
-# GEN 2 (LIVING QUARTERS) : ALIENS PER MINUTE
-4
-# GEN 2 (LIVING QUARTERS) : INCREASE IN ALIENS PER MINUTE
-2
-# GEN 3 (HANGER1) : MAX ALIENS
-25
-# GEN 3 (HANGER1) : ALIENS PER MINUTE
-4
-# GEN 3 (HANGER1) : INCREASE IN ALIENS PER MINUTE
-2
-# MEDLAB : MAX ALIENS
-25
-# MEDLAB : ALIENS PER MINUTE
-3
-# MEDLAB : INCREASE IN ALIENS PER MINUTE
-2
-# CMC 2 (HANGER 2) : MAX ALIENS
-25
-# CMC 2 (HANGER 2) : ALIENS PER MINUTE
-3
-# CMC 2 (HANGER 2) : INCREASE IN ALIENS PER MINUTE
-2
-# CMC 4 (MAIN ARMOURY) : MAX ALIENS
-25
-# CMC 4 (MAIN ARMOURY) : ALIENS PER MINUTE
-3
-# CMC 4 (MAIN ARMOURY) : INCREASE IN ALIENS PER MINUTE
-2
-# CMC 6 (MAIN CONTROL) : MAX ALIENS
-25
-# CMC 6 (MAIN CONTROL) : ALIENS PER MINUTE
-3
-# CMC 6 (MAIN CONTROL) : INCREASE IN ALIENS PER MINUTE
-2
-# SP2 (SECURITY POINT 2) : MAX ALIENS
-10
-# SP2 (SECURITY POINT 2) : ALIENS PER MINUTE
-1
-# SP2 (SECURITY POINT 2) : INCREASE IN ALIENS PER MINUTE
-1
-# SP3 (SECURITY POINT 3) : MAX ALIENS
-10
-# SP3 (SECURITY POINT 3) : ALIENS PER MINUTE
-1
-# SP3 (SECURITY POINT 3) : INCREASE IN ALIENS PER MINUTE
-1
-# R&D 2 (BIOWEAPONS RESEARCH) : MAX ALIENS
-25
-# R&D 2 (BIOWEAPONS RESEARCH) : ALIENS PER MINUTE
-3
-# R&D 2 (BIOWEAPONS RESEARCH) : INCREASE IN ALIENS PER MINUTE
-2
-# R&D 3 (CYBERNETIC AUGMENTATION) : MAX ALIENS
-25
-# R&D 3 (CYBERNETIC AUGMENTATION) : ALIENS PER MINUTE
-3
-# R&D 3 (CYBERNETIC AUGMENTATION) : INCREASE IN ALIENS PER MINUTE
-2
-# R&D 4 (NON-TERRESTRIAL TECH) : MAX ALIENS
-25
-# R&D 4 (NON-TERRESTRIAL TECH) : ALIENS PER MINUTE
-3
-# R&D 4 (NON-TERRESTRIAL TECH) : INCREASE IN ALIENS PER MINUTE
-2
-# MPS 2 (POWER SITE MAINTAINANCE) : MAX ALIENS
-25
-# MPS 2 (POWER SITE MAINTAINANCE) : ALIENS PER MINUTE
-3
-# MPS 2 (POWER SITE MAINTAINANCE) : INCREASE IN ALIENS PER MINUTE
-2
-# MPS 4 (MAIN REACTOR / NEST) : MAX ALIENS
-10
-# MPS 4 (MAIN REACTOR / NEST) : ALIENS PER MINUTE
-1
-# MPS 4 (MAIN REACTOR / NEST) : INCREASE IN ALIENS PER MINUTE
-1
-# SURFACE : MAX ALIENS
-25
-# SURFACE : ALIENS PER MINUTE
-5
-# SURFACE : INCREASE IN ALIENS PER MINUTE
-4
-# ENTRANCE : MAX ALIENS
-10
-# ENTRANCE : ALIENS PER MINUTE
-2
-# ENTRANCE : INCREASE IN ALIENS PER MINUTE
-1 
\ No newline at end of file
diff --git a/src/main.c b/src/main.c
index f7bc518..1a2efb1 100644
--- a/src/main.c
+++ b/src/main.c
@@ -461,8 +461,6 @@ void CheckForWindowsMessages()
 					handle_keypress(KeySymToKey(event.key.keysym.sym), 0, 0);
 					break;
 				case SDL_QUIT:
-//					SDL_Quit();
-//					exit(17); /* TODO tempy! */
 					AvP.MainLoopRunning = 0; /* TODO */
 					break;
 			}
@@ -595,6 +593,9 @@ int main(int argc, char *argv[])
 		
 	LoadKeyConfiguration();
 	
+	CheatMode_Active = CHEATMODE_NONACTIVE;
+	
+	
 	SoundSys_Start();
 	CDDA_Start();
 	
@@ -626,12 +627,13 @@ int main(int argc, char *argv[])
 //	SetLevelToLoad(AVP_ENVIRONMENT_TEMPLE); /* starting alien level */
 //	SetLevelToLoad(AVP_ENVIRONMENT_INVASION_A);
 	
-	AvP.PlayerType = I_Marine;
+//	AvP.PlayerType = I_Marine;
 //	SetLevelToLoad(AVP_ENVIRONMENT_DERELICT); /* starting marine level */
-	SetLevelToLoad(AVP_ENVIRONMENT_COLONY);
+//	SetLevelToLoad(AVP_ENVIRONMENT_COLONY);
 	
-//	AvP.PlayerType = I_Predator;
-//	SetLevelToLoad(AVP_ENVIRONMENT_WATERFALL); /* starting predator level */
+	AvP.PlayerType = I_Predator;
+	SetLevelToLoad(AVP_ENVIRONMENT_WATERFALL); /* starting predator level */
+//	SetLevelToLoad(AVP_ENVIRONMENT_TEMPLE_P);
 
 //	SetLevelToLoad(AVP_ENVIRONMENT_LEADWORKS_MP); /* multiplayer */
 //	SetLevelToLoad(AVP_ENVIRONMENT_SUBWAY_MP);
diff --git a/src/mathline.c b/src/mathline.c
index cd45967..69b9250 100644
--- a/src/mathline.c
+++ b/src/mathline.c
@@ -494,7 +494,6 @@ __asm__("movl	0(%%esi), %%eax		\n\t"
 
 int WideMulNarrowDiv(int a, int b, int c)
 {
-#if 0 /* TODO: broken? */
 	int retval;
 /*
 	_asm
@@ -505,16 +504,13 @@ int WideMulNarrowDiv(int a, int b, int c)
 		mov retval,eax
 	}
 */
-/* TODO */
-__asm__("imull	%2			\n\t"
-	"idivl	%3			\n\t"
+__asm__("imull	%%ebx			\n\t"
+	"idivl	%%ecx			\n\t"
 	: "=a" (retval)
-	: "a" (a), "q" (b), "q" (c)
-	: "cc"
+	: "a" (a), "b" (b), "c" (c)
+	: "%edx", "cc"
 	);	
 	return retval;
-#endif
-	return (a * b) / c;	
 }
 
 /*
diff --git a/src/opengl.c b/src/opengl.c
index 7403e1f..1201895 100644
--- a/src/opengl.c
+++ b/src/opengl.c
@@ -48,16 +48,180 @@ extern int CloakingPhase;
 static D3DTexture *CurrTextureHandle;
 
 
-static enum TRANSLUCENCY_TYPE CurrentTranslucencyMode = TRANSLUCENCY_OFF; /* opengl state variable */
+static enum TRANSLUCENCY_TYPE CurrentTranslucencyMode = TRANSLUCENCY_OFF;
 static enum FILTERING_MODE_ID CurrentFilteringMode = FILTERING_BILINEAR_OFF;
+static D3DTexture *CurrentlyBoundTexture = NULL;
 
-static D3DTexture *CurrentlyBoundTexture = NULL; /* opengl state variable (->id) */
+#define TA_MAXVERTICES		2048
+#define TA_MAXTRIANGLES		2048
+
+typedef struct VertexArray
+{
+	GLfloat v[4];
+	
+	GLfloat t[3]; /* 3rd float is padding */
+	
+	GLubyte c[4];
+} VertexArray;
+
+typedef struct TriangleArray
+{
+	int a;
+	int b;
+	int c;
+} TriangleArray;
+
+static VertexArray varr[TA_MAXVERTICES*2];
+static TriangleArray tarr[TA_MAXTRIANGLES*2];
+static VertexArray *varrp = varr;
+static TriangleArray *tarrp = tarr;
+static int varrc, tarrc;
+
+static VertexArray *svarr = &varr[TA_MAXVERTICES], *svarrp = &varr[TA_MAXVERTICES];
+static TriangleArray *starr = &tarr[TA_MAXTRIANGLES], *starrp = &tarr[TA_MAXTRIANGLES];
+static int svarrc, starrc;
+
+static int haslocked = 0;
+
+/* Do not call this directly! */
+static void SetTranslucencyMode(enum TRANSLUCENCY_TYPE mode)
+{		
+	switch(mode) {
+		case TRANSLUCENCY_OFF:
+			if (TRIPTASTIC_CHEATMODE||MOTIONBLUR_CHEATMODE) {
+				glBlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA);
+			} else {
+				//glDisable(GL_BLEND);
+				glBlendFunc(GL_ONE, GL_ZERO); /* this *should* be optimized */
+			}
+			break;
+		case TRANSLUCENCY_NORMAL:
+			glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+			break;
+		case TRANSLUCENCY_COLOUR:
+			glBlendFunc(GL_ZERO, GL_SRC_COLOR);
+			break;
+		case TRANSLUCENCY_INVCOLOUR:
+			glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
+			break;
+		case TRANSLUCENCY_GLOWING:
+			glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+			break;
+		case TRANSLUCENCY_DARKENINGCOLOUR:
+			glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO);
+			break;
+		case TRANSLUCENCY_JUSTSETZ:
+			glBlendFunc(GL_ZERO, GL_ONE);
+			break;
+		default:
+			fprintf(stderr, "RenderPolygon.TranslucencyMode: invalid %d\n", RenderPolygon.TranslucencyMode);
+			return;
+	}
+	
+	//if (mode != TRANSLUCENCY_OFF && CurrentTranslucencyMode == TRANSLUCENCY_OFF)
+	//	glEnable(GL_BLEND);		
+}
+
+/* 
+A few things:
+- Vertices with a specular color are done twice.
+  Might want to try spitting apart the three arrays and using the same vertex
+  array for both passes.
+*/
+
+static void FlushTriangleBuffers(int backup)
+{
+	int i;
+	
+	if (haslocked == 0) {
+		glEnableClientState(GL_VERTEX_ARRAY);
+		glVertexPointer(4, GL_FLOAT, sizeof(varr[0]), varr[0].v);
+		
+		glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+		glTexCoordPointer(2, GL_FLOAT, sizeof(varr[0]), varr[0].t);
+		
+		glEnableClientState(GL_COLOR_ARRAY);
+		glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(varr[0]), varr[0].c);
+		
+		haslocked = 1;
+	}
+	
+	if (tarrc) {
+#if 1
+		glBegin(GL_TRIANGLES);
+		for (i = 0; i < tarrc; i++) {
+			glArrayElement(tarr[i].a);
+			glArrayElement(tarr[i].b);
+			glArrayElement(tarr[i].c);
+		}
+		glEnd();
+#else		
+		glDrawElements(GL_TRIANGLES, tarrc*3, GL_UNSIGNED_INT, tarr);
+#endif
+		
+		tarrc = 0;
+		tarrp = tarr;
+		
+		varrc = 0;
+		varrp = varr;
+	}
+	
+	if (starrc) {
+		if (CurrentlyBoundTexture != NULL) {
+			if (!backup) CurrentlyBoundTexture = NULL;
+			glBindTexture(GL_TEXTURE_2D, 0);
+		}
+		
+		if (CurrentTranslucencyMode != TRANSLUCENCY_GLOWING) {
+			if (!backup) CurrentTranslucencyMode = TRANSLUCENCY_GLOWING;
+			SetTranslucencyMode(TRANSLUCENCY_GLOWING);
+			//if (CurrentTranslucencyMode == TRANSLUCENCY_OFF)
+			//	glEnable(GL_BLEND);
+			//glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+		}
+
+		glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+
+#if 1		
+		glBegin(GL_TRIANGLES);
+		for (i = 0; i < starrc; i++) {
+			glArrayElement(starr[i].a);
+			glArrayElement(starr[i].b);
+			glArrayElement(starr[i].c);
+		}
+		glEnd();
+#else
+		glDrawElements(GL_TRIANGLES, starrc*3, GL_UNSIGNED_INT, starr);
+#endif
+		
+		glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+		
+		if (backup) {
+			if (CurrentlyBoundTexture)
+				glBindTexture(GL_TEXTURE_2D, CurrentlyBoundTexture->id);
+			if (CurrentTranslucencyMode != TRANSLUCENCY_GLOWING)
+				SetTranslucencyMode(CurrentTranslucencyMode);
+		} else {
+			CurrentlyBoundTexture = NULL;
+			CurrentTranslucencyMode = TRANSLUCENCY_GLOWING;
+		}
+
+		starrc = 0;
+		starrp = starr;
+		
+		svarrc = 0;
+		svarrp = svarr;
+	}	
+		
+}
 
 static void CheckBoundTextureIsCorrect(D3DTexture *tex)
 {
 	if (tex == CurrentlyBoundTexture)
 		return;
 
+	FlushTriangleBuffers(1);
+	
 	if (tex == NULL) {
 		glBindTexture(GL_TEXTURE_2D, 0);
 		
@@ -92,6 +256,8 @@ static void CheckFilteringModeIsCorrect(enum FILTERING_MODE_ID filter)
 	CurrentFilteringMode = filter;
 	
 	if (CurrentlyBoundTexture && CurrentlyBoundTexture->filter != CurrentFilteringMode) {
+		FlushTriangleBuffers(1);
+		
 		switch(CurrentFilteringMode) {
 			case FILTERING_BILINEAR_OFF:
 				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
@@ -113,229 +279,120 @@ static void CheckTranslucencyModeIsCorrect(enum TRANSLUCENCY_TYPE mode)
 	if (CurrentTranslucencyMode == mode)
 		return;
 
-	switch(mode) {
-		case TRANSLUCENCY_OFF:
-			if (TRIPTASTIC_CHEATMODE||MOTIONBLUR_CHEATMODE) {
-			//	glBlendMode(GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA);
-			/* TODO: this may not be properly set... */
-			} else {
-				glDisable(GL_BLEND);
-				glBlendFunc(GL_ONE, GL_ZERO);
-			}
-			break;
-		case TRANSLUCENCY_NORMAL:
-			glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-			break;
-		case TRANSLUCENCY_COLOUR:
-			glBlendFunc(GL_ZERO, GL_SRC_COLOR);
-			break;
-		case TRANSLUCENCY_INVCOLOUR:
-			glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
-			break;
-		case TRANSLUCENCY_GLOWING:
-			glBlendFunc(GL_SRC_ALPHA, GL_ONE);
-			break;
-		case TRANSLUCENCY_DARKENINGCOLOUR:
-			glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO);
-			break;
-		case TRANSLUCENCY_JUSTSETZ:
-			glBlendFunc(GL_ZERO, GL_ONE);
-			break;
-		default:
-			fprintf(stderr, "RenderPolygon.TranslucencyMode: invalid %d\n", RenderPolygon.TranslucencyMode);
-			return;
-	}
+	FlushTriangleBuffers(1);
 	
-	if (mode != TRANSLUCENCY_OFF && CurrentTranslucencyMode == TRANSLUCENCY_OFF)
-		glEnable(GL_BLEND);
+	SetTranslucencyMode(mode);
 		
 	CurrentTranslucencyMode = mode;
 }
 
-#define TA_MAXVERTICES		500
-#define TA_MAXTRIANGLES		500
-
-typedef struct VertexArray
-{
-	GLfloat v[4];
-	
-	GLfloat t[3]; /* 3rd float is padding */
-	
-	GLubyte c[4];
-} VertexArray;
-
-typedef struct TriangleArray
+static void CheckTriangleBuffer(int rver, int sver, int rtri, int stri, D3DTexture *tex, enum TRANSLUCENCY_TYPE mode, enum FILTERING_MODE_ID filter)
 {
-	int a;
-	int b;
-	int c;
-} TriangleArray;
+	if ((rver+varrc) >= TA_MAXVERTICES) {
+		FlushTriangleBuffers(0);
+	} else if ((sver+svarrc) >= TA_MAXVERTICES) {
+		FlushTriangleBuffers(0);
+	} else if (rtri == 0 && ((rver-2+tarrc) >= TA_MAXTRIANGLES)) {
+		FlushTriangleBuffers(0);
+	} else if (rtri && ((rtri+tarrc) >= TA_MAXTRIANGLES)) {
+		FlushTriangleBuffers(0);
+	} else if (stri == 0 && ((sver-2+starrc) >= TA_MAXTRIANGLES)) {
+		FlushTriangleBuffers(0);
+	} else if (stri && ((stri+starrc) >= TA_MAXTRIANGLES)) {
+		FlushTriangleBuffers(0);
+	}
 
-static VertexArray tarr[TA_MAXVERTICES];
-static TriangleArray tris[TA_MAXTRIANGLES];
+	if ((int)tex != -1)
+		CheckBoundTextureIsCorrect(tex);
+	if (mode != -1)
+		CheckTranslucencyModeIsCorrect(mode);
+	if (filter != -1)
+		CheckFilteringModeIsCorrect(filter);
 
-static void DrawTriangleArray_T2F_C4UB_V4F(int len)
-{	
-	int i;
-	
-#define OUTPUT_VERTEX(d) \
-{ \
-	glColor4ubv	(tarr[(d)].c);	\
-	glTexCoord2fv	(tarr[(d)].t);	\
-	glVertex4fv	(tarr[(d)].v);	\
-}
-#define OUTPUT_TRIANGLE(a, b, c) \
+#define OUTPUT_TRIANGLE(x, y, z) \
 { \
-	OUTPUT_VERTEX((a));	\
-	OUTPUT_VERTEX((b));	\
-	OUTPUT_VERTEX((c));	\
+	tarrp->a = varrc+(x);	\
+	tarrp->b = varrc+(y);	\
+	tarrp->c = varrc+(z);	\
+				\
+	tarrp++;		\
+	tarrc++; 		\
 }
-
-	glBegin(GL_TRIANGLES);
-	for (i = 0; i < len; i++) {
-		OUTPUT_TRIANGLE(tris[i].a, tris[i].b, tris[i].c);
-	}
-	glEnd();
 	
-#undef OUTPUT_TRIANGLE	
-#undef OUTPUT_VERTEX
-}
-
-static void DrawTriangles_T2F_C4UB_V4F(int vertices)
-{	
-#define OUTPUT_VERTEX(d) \
-{ \
-	glColor4ubv	(tarr[(d)].c);	\
-	glTexCoord2fv	(tarr[(d)].t);	\
-	glVertex4fv	(tarr[(d)].v);	\
-}
-#define OUTPUT_TRIANGLE(a, b, c) \
-{ \
-	OUTPUT_VERTEX((a));	\
-	OUTPUT_VERTEX((b));	\
-	OUTPUT_VERTEX((c));	\
-}
-
-	glBegin(GL_TRIANGLES);
-	switch(vertices) {
-		case 3:
-			OUTPUT_TRIANGLE(0, 2, 1);
-			break;
-		case 5:
-			OUTPUT_TRIANGLE(0, 1, 4);
-			OUTPUT_TRIANGLE(1, 3, 4);
-			OUTPUT_TRIANGLE(1, 2, 3);
-			break;
-		case 8:
-			OUTPUT_TRIANGLE(0, 6, 7);
-		case 7:
-			OUTPUT_TRIANGLE(0, 5, 6);
-		case 6:
-			OUTPUT_TRIANGLE(0, 4, 5);
-			OUTPUT_TRIANGLE(0, 3, 4);
-		case 4:
-			OUTPUT_TRIANGLE(0, 2, 3);
-			OUTPUT_TRIANGLE(0, 1, 2);			
-			break;
-		default:
-			fprintf(stderr, "DrawTriangles_T2F_C4UB_V4F: vertices = %d\n", vertices);
-	}
-	glEnd();
+	if (rtri == 0) {
+		switch(rver) {
+			case 0:
+				break;
+			case 3:
+				OUTPUT_TRIANGLE(0, 2, 1);
+				break;
+			case 5:
+				OUTPUT_TRIANGLE(0, 1, 4);
+				OUTPUT_TRIANGLE(1, 3, 4);
+				OUTPUT_TRIANGLE(1, 2, 3);
+				break;
+			case 8:
+				OUTPUT_TRIANGLE(0, 6, 7);
+			case 7:
+				OUTPUT_TRIANGLE(0, 5, 6);
+			case 6:
+				OUTPUT_TRIANGLE(0, 4, 5);
+				OUTPUT_TRIANGLE(0, 3, 4);
+			case 4:
+				OUTPUT_TRIANGLE(0, 2, 3);
+				OUTPUT_TRIANGLE(0, 1, 2);			
+				break;
+			default:
+				fprintf(stderr, "DrawTriangles_T2F_C4UB_V4F: vertices = %d\n", rver);
+		}
+	}	
+#undef OUTPUT_TRIANGLE
 	
-#undef OUTPUT_TRIANGLE	
-#undef OUTPUT_VERTEX
-}
-
-static void DrawTriangles_T2F_V4F(int vertices)
-{	
-#define OUTPUT_VERTEX(d) \
+#define OUTPUT_TRIANGLE(x, y, z) \
 { \
-	glTexCoord2fv	(tarr[(d)].t);	\
-	glVertex4fv	(tarr[(d)].v);	\
+	starrp->a = TA_MAXVERTICES+svarrc+(x);	\
+	starrp->b = TA_MAXVERTICES+svarrc+(y);	\
+	starrp->c = TA_MAXVERTICES+svarrc+(z);	\
+						\
+	starrp++;				\
+	starrc++; 				\
 }
-#define OUTPUT_TRIANGLE(a, b, c) \
-{ \
-	OUTPUT_VERTEX((a));	\
-	OUTPUT_VERTEX((b));	\
-	OUTPUT_VERTEX((c));	\
-}
-
-	glBegin(GL_TRIANGLES);
-	switch(vertices) {
-		case 3:
-			OUTPUT_TRIANGLE(0, 2, 1);
-			break;
-		case 5:
-			OUTPUT_TRIANGLE(0, 1, 4);
-			OUTPUT_TRIANGLE(1, 3, 4);
-			OUTPUT_TRIANGLE(1, 2, 3);
-			break;
-		case 8:
-			OUTPUT_TRIANGLE(0, 6, 7);
-		case 7:
-			OUTPUT_TRIANGLE(0, 5, 6);
-		case 6:
-			OUTPUT_TRIANGLE(0, 4, 5);
-			OUTPUT_TRIANGLE(0, 3, 4);
-		case 4:
-			OUTPUT_TRIANGLE(0, 2, 3);
-			OUTPUT_TRIANGLE(0, 1, 2);			
-			break;
-		default:
-			fprintf(stderr, "DrawTriangles_T2F_V4F: vertices = %d\n", vertices);
+	if (stri == 0) {
+		switch(sver) {
+			case 0:
+				break;
+			case 3:
+				OUTPUT_TRIANGLE(0, 2, 1);
+				break;
+			case 5:
+				OUTPUT_TRIANGLE(0, 1, 4);
+				OUTPUT_TRIANGLE(1, 3, 4);
+				OUTPUT_TRIANGLE(1, 2, 3);
+				break;
+			case 8:
+				OUTPUT_TRIANGLE(0, 6, 7);
+			case 7:
+				OUTPUT_TRIANGLE(0, 5, 6);
+			case 6:
+				OUTPUT_TRIANGLE(0, 4, 5);
+				OUTPUT_TRIANGLE(0, 3, 4);
+			case 4:
+				OUTPUT_TRIANGLE(0, 2, 3);
+				OUTPUT_TRIANGLE(0, 1, 2);
+				break;
+			default:
+				fprintf(stderr, "DrawTriangles_T2F_C4UB_V4F: vertices = %d\n", sver);
+		}
 	}
-	glEnd();
-	
-#undef OUTPUT_TRIANGLE	
-#undef OUTPUT_VERTEX
-}
+#undef OUTPUT_TRIANGLE
 
-static void DrawTriangles_C4UB_V4F(int vertices)
-{	
-#define OUTPUT_VERTEX(d) \
-{ \
-	glColor4ubv	(tarr[(d)].c);	\
-	glVertex4fv	(tarr[(d)].v);	\
-}
-#define OUTPUT_TRIANGLE(a, b, c) \
-{ \
-	OUTPUT_VERTEX((a));	\
-	OUTPUT_VERTEX((b));	\
-	OUTPUT_VERTEX((c));	\
 }
 
-	glBegin(GL_TRIANGLES);
-	switch(vertices) {
-		case 3:
-			OUTPUT_TRIANGLE(0, 2, 1);
-			break;
-		case 5:
-			OUTPUT_TRIANGLE(0, 1, 4);
-			OUTPUT_TRIANGLE(1, 3, 4);
-			OUTPUT_TRIANGLE(1, 2, 3);
-			break;
-		case 8:
-			OUTPUT_TRIANGLE(0, 6, 7);
-		case 7:
-			OUTPUT_TRIANGLE(0, 5, 6);
-		case 6:
-			OUTPUT_TRIANGLE(0, 4, 5);
-			OUTPUT_TRIANGLE(0, 3, 4);
-		case 4:
-			OUTPUT_TRIANGLE(0, 2, 3);
-			OUTPUT_TRIANGLE(0, 1, 2);			
-			break;
-		default:
-			fprintf(stderr, "DrawTriangles_C4UB_V4F: vertices = %d\n", vertices);
-	}
-	glEnd();
-	
-#undef OUTPUT_TRIANGLE	
-#undef OUTPUT_VERTEX
-}
-		
 static void SelectPolygonBeginType(int points)
 {
+	if (tarrc || starrc)
+		FlushTriangleBuffers(1);
+		
 	switch(points) {
 		case 3:
 			glBegin(GL_TRIANGLES);
@@ -357,9 +414,10 @@ GLuint CreateOGLTexture(D3DTexture *tex, unsigned char *buf)
 {
 	GLuint h;
 	
+	FlushTriangleBuffers(1);
+	
 	glGenTextures(1, &h);
 
-/* TODO: d3d code doesn't explicitly enable repeating but some levels (namely predator beginning level waterfall) have clamped textures */
 	glBindTexture(GL_TEXTURE_2D, h);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
@@ -389,9 +447,9 @@ void ThisFramesRenderingHasBegun()
 
 void ThisFramesRenderingHasFinished()
 {
-/* This is where the queued drawing commands' execution takes place */
-
 	LightBlockDeallocation();
+	
+	FlushTriangleBuffers(0);
 }
         
 /* ** */
@@ -403,11 +461,15 @@ void FlushD3DZBuffer()
 
 void SecondFlushD3DZBuffer()
 {
+	FlushTriangleBuffers(0);
+	
 	glClear(GL_DEPTH_BUFFER_BIT);
 }
 
 void D3D_DecalSystem_Setup()
 {
+	FlushTriangleBuffers(0);
+	
 	glDepthMask(GL_FALSE);
 
 	/* this does stop zfighting with bulletmarks on walls... */
@@ -417,6 +479,8 @@ void D3D_DecalSystem_Setup()
 
 void D3D_DecalSystem_End()
 {
+	FlushTriangleBuffers(0);
+	
 	glDepthMask(GL_TRUE);
 	
 	glDisable(GL_POLYGON_OFFSET_FILL);
@@ -478,7 +542,6 @@ void D3D_ZBufferedGouraudTexturedPolygon_Output(POLYHEADER *inputPolyPtr, RENDER
 	int i;
 	GLfloat ZNear;
 	float RecipW, RecipH;
-
 		
 	ZNear = (GLfloat) (Global_VDB_Ptr->VDB_ClipZ * GlobalScale);
 	
@@ -491,8 +554,6 @@ void D3D_ZBufferedGouraudTexturedPolygon_Output(POLYHEADER *inputPolyPtr, RENDER
 		TextureHandle = CurrTextureHandle;
 	}
 	
-	CheckTranslucencyModeIsCorrect(RenderPolygon.TranslucencyMode);
-
 	if (TextureHandle->w == 128) {
 		RecipW = (1.0f / 128.0f) / 65536.0f;
 	} else {
@@ -506,12 +567,11 @@ void D3D_ZBufferedGouraudTexturedPolygon_Output(POLYHEADER *inputPolyPtr, RENDER
 		RecipH = (1.0f / height) / 65536.0f;
 	}
 	
-	CheckBoundTextureIsCorrect(TextureHandle);
+	CheckTriangleBuffer(RenderPolygon.NumberOfVertices, RenderPolygon.NumberOfVertices, 0, 0, TextureHandle, RenderPolygon.TranslucencyMode, -1);
 	
 	for (i = 0; i < RenderPolygon.NumberOfVertices; i++) {
 		RENDERVERTEX *vertices = &renderVerticesPtr[i];
 		GLfloat x, y, z;
-		int x1, y1;
 		GLfloat s, t;
 		GLfloat rhw = 1.0/(float)vertices->Z, zvalue;
 		
@@ -521,60 +581,35 @@ void D3D_ZBufferedGouraudTexturedPolygon_Output(POLYHEADER *inputPolyPtr, RENDER
 //		if (s < 0.0 || t < 0.0 || s >= 1.0 || t >= 1.0)
 //			fprintf(stderr, "HEY! s = %f, t = %f (%d, %d)\n", s, t, vertices->U, vertices->V);
 
-		x1 = (vertices->X*(Global_VDB_Ptr->VDB_ProjX+1))/vertices->Z+Global_VDB_Ptr->VDB_CentreX;
-		y1 = (vertices->Y*(Global_VDB_Ptr->VDB_ProjY+1))/vertices->Z+Global_VDB_Ptr->VDB_CentreY;
-
-		if (x1<Global_VDB_Ptr->VDB_ClipLeft) {
-			x1=Global_VDB_Ptr->VDB_ClipLeft;
-		} else if (x1>Global_VDB_Ptr->VDB_ClipRight) {
-			x1=Global_VDB_Ptr->VDB_ClipRight;
-		}
+		x =  ((float)vertices->X*((float)Global_VDB_Ptr->VDB_ProjX+1.0f))/((float)vertices->Z*(float)ScreenDescriptorBlock.SDB_CentreX);
+		y = -((float)vertices->Y*((float)Global_VDB_Ptr->VDB_ProjY+1.0f))/((float)vertices->Z*(float)ScreenDescriptorBlock.SDB_CentreY);
 		
-		if (y1<Global_VDB_Ptr->VDB_ClipUp) {
-			y1=Global_VDB_Ptr->VDB_ClipUp;
-		} else if (y1>Global_VDB_Ptr->VDB_ClipDown) {
-			y1=Global_VDB_Ptr->VDB_ClipDown;
-		}
-
-		x = x1;
-		y = y1;
-						
-		x =  (x - (float)ScreenDescriptorBlock.SDB_CentreX - 0.5f) / ((float)ScreenDescriptorBlock.SDB_CentreX - 0.5f);
-		y = -(y - (float)ScreenDescriptorBlock.SDB_CentreY - 0.5f) / ((float)ScreenDescriptorBlock.SDB_CentreY - 0.5f);
-
 		zvalue = vertices->Z+HeadUpDisplayZOffset;
-		z = 1.0 - 2*ZNear/zvalue;
-
+		z = 1.0f - 2.0f*ZNear/zvalue;
 		
-		tarr[i].v[0] = x/rhw;
-		tarr[i].v[1] = y/rhw;
-		tarr[i].v[2] = z/rhw;
-		tarr[i].v[3] = 1/rhw;
+		varrp->v[0] = svarrp->v[0] = x/rhw;
+		varrp->v[1] = svarrp->v[1] = y/rhw;
+		varrp->v[2] = svarrp->v[2] = z/rhw;
+		varrp->v[3] = svarrp->v[3] = 1/rhw;
 		
-		tarr[i].t[0] = s;
-		tarr[i].t[1] = t;
+		varrp->t[0] = /**/ svarrp->t[0] = /**/ s;
+		varrp->t[1] = /**/ svarrp->t[1] = /**/ t;
 		
-		tarr[i].c[0] = GammaValues[vertices->R];
-		tarr[i].c[1] = GammaValues[vertices->G];
-		tarr[i].c[2] = GammaValues[vertices->B];
-		tarr[i].c[3] = vertices->A;
-	}
-
-	DrawTriangles_T2F_C4UB_V4F(RenderPolygon.NumberOfVertices);
-
-	CheckBoundTextureIsCorrect(NULL);
+		varrp->c[0] = GammaValues[vertices->R];
+		varrp->c[1] = GammaValues[vertices->G];
+		varrp->c[2] = GammaValues[vertices->B];
+		varrp->c[3] = vertices->A;
 		
-	CheckTranslucencyModeIsCorrect(TRANSLUCENCY_GLOWING);
-	
-	for (i = 0; i < RenderPolygon.NumberOfVertices; i++) {
-		RENDERVERTEX *vertices = &renderVerticesPtr[i];
+		svarrp->c[0] = GammaValues[vertices->SpecularR];
+		svarrp->c[1] = GammaValues[vertices->SpecularG];
+		svarrp->c[2] = GammaValues[vertices->SpecularB];
+		svarrp->c[3] = 255;
 		
-		tarr[i].c[0] = GammaValues[vertices->SpecularR];
-		tarr[i].c[1] = GammaValues[vertices->SpecularG];
-		tarr[i].c[2] = GammaValues[vertices->SpecularB];
-		tarr[i].c[3] = 255;
+		varrp++;
+		varrc++;
+		svarrp++;
+		svarrc++;
 	}
-	DrawTriangles_C4UB_V4F(RenderPolygon.NumberOfVertices);
 }
 
 void D3D_SkyPolygon_Output(POLYHEADER *inputPolyPtr, RENDERVERTEX *renderVerticesPtr)
@@ -588,7 +623,6 @@ void D3D_SkyPolygon_Output(POLYHEADER *inputPolyPtr, RENDERVERTEX *renderVertice
 	TextureHandle = (void *)ImageHeaderArray[texoffset].D3DTexture;		
 	CurrTextureHandle = TextureHandle;
 	
-	
 	if (TextureHandle->w == 128) {
 		RecipW = (1.0f / 128.0f) / 65536.0f;
 	} else {
@@ -602,60 +636,44 @@ void D3D_SkyPolygon_Output(POLYHEADER *inputPolyPtr, RENDERVERTEX *renderVertice
 		RecipH = (1.0f / height) / 65536.0f;
 	}
 	
-	CheckTranslucencyModeIsCorrect(RenderPolygon.TranslucencyMode);
-	CheckBoundTextureIsCorrect(TextureHandle);
+	CheckTriangleBuffer(RenderPolygon.NumberOfVertices, 0, 0, 0, TextureHandle, RenderPolygon.TranslucencyMode, -1);
 	
 	for (i = 0; i < RenderPolygon.NumberOfVertices; i++) {
 		RENDERVERTEX *vertices = &renderVerticesPtr[i];
 		GLfloat x, y, z;
-		int x1, y1;
 		GLfloat s, t;
-		GLfloat rhw = 1.0/(float)vertices->Z;
+		GLfloat rhw;
+		
+		rhw = 1.0 / (float)vertices->Z;
 		
 		s = ((float)vertices->U) * RecipW + (1.0f/256.0f);
 		t = ((float)vertices->V) * RecipH + (1.0f/256.0f);
 
 //		if (s < 0.0 || t < 0.0 || s >= 1.0 || t >= 1.0)
 //			fprintf(stderr, "HEY! s = %f, t = %f (%d, %d)\n", s, t, vertices->U, vertices->V);
-			
-		x1 = (vertices->X*(Global_VDB_Ptr->VDB_ProjX+1))/vertices->Z+Global_VDB_Ptr->VDB_CentreX;
-		y1 = (vertices->Y*(Global_VDB_Ptr->VDB_ProjY+1))/vertices->Z+Global_VDB_Ptr->VDB_CentreY;
 
-		if (x1<Global_VDB_Ptr->VDB_ClipLeft) {
-			x1=Global_VDB_Ptr->VDB_ClipLeft;
-		} else if (x1>Global_VDB_Ptr->VDB_ClipRight) {
-			x1=Global_VDB_Ptr->VDB_ClipRight;
-		}
 		
-		if (y1<Global_VDB_Ptr->VDB_ClipUp) {
-			y1=Global_VDB_Ptr->VDB_ClipUp;
-		} else if (y1>Global_VDB_Ptr->VDB_ClipDown) {
-			y1=Global_VDB_Ptr->VDB_ClipDown;
-		}
-
-		x = x1;
-		y = y1;
-						
-		x =  (x - (float)ScreenDescriptorBlock.SDB_CentreX - 0.5f) / ((float)ScreenDescriptorBlock.SDB_CentreX - 0.5f);
-		y = -(y - (float)ScreenDescriptorBlock.SDB_CentreY - 0.5f) / ((float)ScreenDescriptorBlock.SDB_CentreY - 0.5f);
+		x =  ((float)vertices->X*((float)Global_VDB_Ptr->VDB_ProjX+1.0f))/((float)vertices->Z*(float)ScreenDescriptorBlock.SDB_CentreX);
+		y = -((float)vertices->Y*((float)Global_VDB_Ptr->VDB_ProjY+1.0f))/((float)vertices->Z*(float)ScreenDescriptorBlock.SDB_CentreY);
 
 		z = 1.0f;
 
-		tarr[i].v[0] = x/rhw;
-		tarr[i].v[1] = y/rhw;
-		tarr[i].v[2] = z/rhw;
-		tarr[i].v[3] = 1/rhw;
+		varrp->v[0] = x/rhw;
+		varrp->v[1] = y/rhw;
+		varrp->v[2] = z/rhw;
+		varrp->v[3] = 1/rhw;
 		
-		tarr[i].t[0] = s;
-		tarr[i].t[1] = t;
+		varrp->t[0] = s;
+		varrp->t[1] = t;
 		
-		tarr[i].c[0] = vertices->R;
-		tarr[i].c[1] = vertices->G;
-		tarr[i].c[2] = vertices->B;
-		tarr[i].c[3] = vertices->A;		
+		varrp->c[0] = vertices->R;
+		varrp->c[1] = vertices->G;
+		varrp->c[2] = vertices->B;
+		varrp->c[3] = vertices->A;
+		
+		varrp++;
+		varrc++;
 	}
-
-	DrawTriangles_T2F_C4UB_V4F(RenderPolygon.NumberOfVertices);	
 }
 
 void D3D_ZBufferedCloakedPolygon_Output(POLYHEADER *inputPolyPtr, RENDERVERTEX *renderVerticesPtr)
@@ -676,9 +694,6 @@ void D3D_ZBufferedCloakedPolygon_Output(POLYHEADER *inputPolyPtr, RENDERVERTEX *
 	TextureHandle = ImageHeaderArray[texoffset].D3DTexture;
 	CurrTextureHandle = TextureHandle;
 	
-	CheckBoundTextureIsCorrect(TextureHandle);
-	CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
-	
 	if (TextureHandle->w == 128) {
 		RecipW = 1.0f / 128.0f;
 	} else {
@@ -693,60 +708,47 @@ void D3D_ZBufferedCloakedPolygon_Output(POLYHEADER *inputPolyPtr, RENDERVERTEX *
 		RecipH = 1.0f / height;
 	}
 	
+	CheckTriangleBuffer(RenderPolygon.NumberOfVertices, 0, 0, 0, TextureHandle, TRANSLUCENCY_NORMAL, -1);
+	
 	for (i = 0; i < RenderPolygon.NumberOfVertices; i++) {
 		RENDERVERTEX *vertices = &renderVerticesPtr[i];
 		
 		GLfloat x, y, z;
-		int x1, y1;
 		GLfloat s, t;
-		GLfloat rhw = 1.0/(float)vertices->Z;
+		GLfloat rhw;
 		GLfloat zvalue;
 		
-		s = ((float)(vertices->U>>16)+0.5) * RecipW;
-		t = ((float)(vertices->V>>16)+0.5) * RecipH;
+		rhw = 1.0 / (float)vertices->Z;
+		
+		s = (((float)vertices->U/65536.0f)+0.5) * RecipW;
+		t = (((float)vertices->V/65536.0f)+0.5) * RecipH;
 		
 //		if (s < 0.0 || t < 0.0 || s >= 1.0 || t >= 1.0)
 //			fprintf(stderr, "HEY! s = %f, t = %f (%d, %d)\n", s, t, vertices->U, vertices->V);
-			
-		x1 = (vertices->X*(Global_VDB_Ptr->VDB_ProjX+1))/vertices->Z+Global_VDB_Ptr->VDB_CentreX;
-		y1 = (vertices->Y*(Global_VDB_Ptr->VDB_ProjY+1))/vertices->Z+Global_VDB_Ptr->VDB_CentreY;
-
-		if (x1<Global_VDB_Ptr->VDB_ClipLeft) {
-			x1=Global_VDB_Ptr->VDB_ClipLeft;
-		} else if (x1>Global_VDB_Ptr->VDB_ClipRight) {
-			x1=Global_VDB_Ptr->VDB_ClipRight;
-		}
-		
-		if (y1<Global_VDB_Ptr->VDB_ClipUp) {
-			y1=Global_VDB_Ptr->VDB_ClipUp;
-		} else if (y1>Global_VDB_Ptr->VDB_ClipDown) {
-			y1=Global_VDB_Ptr->VDB_ClipDown;
-		}
 
-		x = x1;
-		y = y1;
-						
-		x =  (x - ScreenDescriptorBlock.SDB_CentreX)/ScreenDescriptorBlock.SDB_CentreX;
-		y = -(y - ScreenDescriptorBlock.SDB_CentreY)/ScreenDescriptorBlock.SDB_CentreY;
 
+		x =  ((float)vertices->X*((float)Global_VDB_Ptr->VDB_ProjX+1.0f))/((float)vertices->Z*(float)ScreenDescriptorBlock.SDB_CentreX);
+		y = -((float)vertices->Y*((float)Global_VDB_Ptr->VDB_ProjY+1.0f))/((float)vertices->Z*(float)ScreenDescriptorBlock.SDB_CentreY);
+		
 		zvalue = vertices->Z+HeadUpDisplayZOffset;
 		z = 1.0 - 2*ZNear/zvalue;
 
-		tarr[i].v[0] = x/rhw;
-		tarr[i].v[1] = y/rhw;
-		tarr[i].v[2] = z/rhw;
-		tarr[i].v[3] = 1/rhw;
+		varrp->v[0] = x/rhw;
+		varrp->v[1] = y/rhw;
+		varrp->v[2] = z/rhw;
+		varrp->v[3] = 1/rhw;
 		
-		tarr[i].t[0] = s;
-		tarr[i].t[1] = t;
+		varrp->t[0] = s;
+		varrp->t[1] = t;
 		
-		tarr[i].c[0] = vertices->R;
-		tarr[i].c[1] = vertices->G;
-		tarr[i].c[2] = vertices->B;
-		tarr[i].c[3] = vertices->A;
+		varrp->c[0] = vertices->R;
+		varrp->c[1] = vertices->G;
+		varrp->c[2] = vertices->B;
+		varrp->c[3] = vertices->A;
+		
+		varrp++;
+		varrc++;
 	}
-
-	DrawTriangles_T2F_C4UB_V4F(RenderPolygon.NumberOfVertices);
 }
 
 void D3D_Decal_Output(DECAL *decalPtr, RENDERVERTEX *renderVerticesPtr)
@@ -762,13 +764,12 @@ void D3D_Decal_Output(DECAL *decalPtr, RENDERVERTEX *renderVerticesPtr)
 	
 	ZNear = (float) (Global_VDB_Ptr->VDB_ClipZ * GlobalScale);
 
-	CheckTranslucencyModeIsCorrect(decalDescPtr->TranslucencyType);
-	
+		
 	if (decalPtr->DecalID == DECAL_FMV) {
 		/* not (yet) implemented */
 		return;
 	} else if (decalPtr->DecalID == DECAL_SHAFTOFLIGHT||decalPtr->DecalID == DECAL_SHAFTOFLIGHT_OUTER) {
-		CheckBoundTextureIsCorrect(NULL);
+		TextureHandle = NULL;
 		
 		RecipW = 1.0 / 256.0; /* ignored */
 		RecipH = 1.0 / 256.0;
@@ -789,9 +790,7 @@ void D3D_Decal_Output(DECAL *decalPtr, RENDERVERTEX *renderVerticesPtr)
 		} else {
 			float height = (float) TextureHandle->h;
 			RecipH = 1.0 / height;
-		}
-		
-		CheckBoundTextureIsCorrect(TextureHandle);
+		}		
 	}
 	
 	if (decalDescPtr->IsLit) {
@@ -815,54 +814,41 @@ void D3D_Decal_Output(DECAL *decalPtr, RENDERVERTEX *renderVerticesPtr)
 		a = decalDescPtr->Alpha;
 	}
 	
-	glColor4ub(r, g, b, a);
+	CheckTriangleBuffer(RenderPolygon.NumberOfVertices, 0, 0, 0, TextureHandle, decalDescPtr->TranslucencyType, -1);
 	
 	for (i = 0; i < RenderPolygon.NumberOfVertices; i++) {
 		RENDERVERTEX *vertices = &renderVerticesPtr[i];
 		
 		GLfloat x, y, z, zvalue;
 		GLfloat s, t, rhw;
-		int x1, y1;
-		
-		rhw = 1.0 / vertices->Z;
 		
-		x1 = (vertices->X*(Global_VDB_Ptr->VDB_ProjX+1))/vertices->Z+Global_VDB_Ptr->VDB_CentreX;
-		y1 = (vertices->Y*(Global_VDB_Ptr->VDB_ProjY+1))/vertices->Z+Global_VDB_Ptr->VDB_CentreY;
-
-		if (x1<Global_VDB_Ptr->VDB_ClipLeft) {
-			x1=Global_VDB_Ptr->VDB_ClipLeft;
-		} else if (x1>Global_VDB_Ptr->VDB_ClipRight) {
-			x1=Global_VDB_Ptr->VDB_ClipRight;
-		}
-				
-		if (y1<Global_VDB_Ptr->VDB_ClipUp) {
-			y1=Global_VDB_Ptr->VDB_ClipUp;
-		} else if (y1>Global_VDB_Ptr->VDB_ClipDown) {
-			y1=Global_VDB_Ptr->VDB_ClipDown;
-		}
-		
-		x = x1;
-		y = y1;
+		rhw = 1.0 / (float)vertices->Z;
 		
-		x =  (x - ScreenDescriptorBlock.SDB_CentreX)/ScreenDescriptorBlock.SDB_CentreX;
-		y = -(y - ScreenDescriptorBlock.SDB_CentreY)/ScreenDescriptorBlock.SDB_CentreY;
+		x =  ((float)vertices->X*((float)Global_VDB_Ptr->VDB_ProjX+1.0f))/((float)vertices->Z*(float)ScreenDescriptorBlock.SDB_CentreX);
+		y = -((float)vertices->Y*((float)Global_VDB_Ptr->VDB_ProjY+1.0f))/((float)vertices->Z*(float)ScreenDescriptorBlock.SDB_CentreY);
 		
-		s = ((float)(vertices->U>>16)+.5) * RecipW;
-		t = ((float)(vertices->V>>16)+.5) * RecipH;
-
+		s = ((float)(vertices->U/65536.0f)+0.5f) * RecipW;
+		t = ((float)(vertices->V/65536.0f)+0.5f) * RecipH;
+				
 		zvalue = vertices->Z+HeadUpDisplayZOffset;
-		z = 1.0 - 2*ZNear/zvalue;
+		z = 1.0f - 2.0f*ZNear/zvalue;
+
+		varrp->v[0] = x/rhw;
+		varrp->v[1] = y/rhw;
+		varrp->v[2] = z/rhw;
+		varrp->v[3] = 1/rhw;
+		
+		varrp->t[0] = s;
+		varrp->t[1] = t;
 		
-		tarr[i].v[0] = x/rhw;
-		tarr[i].v[1] = y/rhw;
-		tarr[i].v[2] = z/rhw;
-		tarr[i].v[3] = 1/rhw;
+		varrp->c[0] = r;
+		varrp->c[1] = g;
+		varrp->c[2] = b;
+		varrp->c[3] = a;
 		
-		tarr[i].t[0] = s;
-		tarr[i].t[1] = t;
+		varrp++;
+		varrc++;
 	}
-	
-	DrawTriangles_T2F_V4F(RenderPolygon.NumberOfVertices);
 }
 
 void D3D_Particle_Output(PARTICLE *particlePtr, RENDERVERTEX *renderVerticesPtr)
@@ -872,31 +858,26 @@ void D3D_Particle_Output(PARTICLE *particlePtr, RENDERVERTEX *renderVerticesPtr)
 	GLfloat ZNear;
 	int i;
 	float RecipW, RecipH;
+	int r, g, b, a;
 	
 	D3DTexture *TextureHandle;
 
-	TextureHandle = ImageHeaderArray[texoffset].D3DTexture;
+
+	ZNear = (GLfloat) (Global_VDB_Ptr->VDB_ClipZ * GlobalScale);	
 	
-	ZNear = (GLfloat) (Global_VDB_Ptr->VDB_ClipZ * GlobalScale);
+	TextureHandle = ImageHeaderArray[texoffset].D3DTexture;
 	
-	CheckBoundTextureIsCorrect(TextureHandle);
-	CheckTranslucencyModeIsCorrect(particleDescPtr->TranslucencyType);
-
-//	if(ImageHeaderArray[texoffset].ImageWidth==256) {
 	if (TextureHandle->w == 256) {
 		RecipW = 1.0 / 256.0;
 	} else {
-//		float width = (float) ImageHeaderArray[texoffset].ImageWidth;
 		float width = (float) TextureHandle->w;
 		
 		RecipW = (1.0 / width);
 	}
 	
-//	if(ImageHeaderArray[texoffset].ImageHeight==256) {
 	if (TextureHandle->h == 256) {
 		RecipH = 1.0 / 256.0;
 	} else {
-//		float height = (float) ImageHeaderArray[texoffset].ImageHeight;
 		float height = (float) TextureHandle->h;
 		
 		RecipH = (1.0 / height);
@@ -908,46 +889,35 @@ void D3D_Particle_Output(PARTICLE *particlePtr, RENDERVERTEX *renderVerticesPtr)
 		
 		if (particlePtr->ParticleID==PARTICLE_SMOKECLOUD || particlePtr->ParticleID==PARTICLE_ANDROID_BLOOD)
 		{
-			int r, g, b, a;
-	
 			/* this should be OK. (ColourComponents was RGBA while RGBA_MAKE is BGRA (little endian) */
 			r = (particlePtr->Colour >> 0)  & 0xFF;
 			g = (particlePtr->Colour >> 8)  & 0xFF;
 			b = (particlePtr->Colour >> 16) & 0xFF;
 			a = (particlePtr->Colour >> 24) & 0xFF;
-
-			glColor4ub(
-				MUL_FIXED(intensity,r),
-				MUL_FIXED(intensity,g),
-				MUL_FIXED(intensity,b),
-				a
-				);
 		} else {
-			glColor4ub(
-				MUL_FIXED(intensity,particleDescPtr->RedScale[CurrentVisionMode]),
-				MUL_FIXED(intensity,particleDescPtr->GreenScale[CurrentVisionMode]),
-				MUL_FIXED(intensity,particleDescPtr->BlueScale[CurrentVisionMode]),
-				particleDescPtr->Alpha
-				);
+			r = MUL_FIXED(intensity,particleDescPtr->RedScale[CurrentVisionMode]);
+			g = MUL_FIXED(intensity,particleDescPtr->GreenScale[CurrentVisionMode]);
+			b = MUL_FIXED(intensity,particleDescPtr->BlueScale[CurrentVisionMode]);
+			a = particleDescPtr->Alpha;
 		}
 	} else {
-		int r, g, b, a;
-		
 		b = (particlePtr->Colour >> 0)  & 0xFF;
 		g = (particlePtr->Colour >> 8)  & 0xFF;
 		r = (particlePtr->Colour >> 16) & 0xFF;
 		a = (particlePtr->Colour >> 24) & 0xFF;
-		
-		glColor4ub(r, g, b, a);
 	}
 	if (RAINBOWBLOOD_CHEATMODE) {
-		glColor4ub(FastRandom()&255, FastRandom()&255, FastRandom()&255, particleDescPtr->Alpha);
+		r = FastRandom()&255;
+		g = FastRandom()&255;
+		b = FastRandom()&255;
+		a = particleDescPtr->Alpha;
 	}
 
+	CheckTriangleBuffer(RenderPolygon.NumberOfVertices, 0, 0, 0, TextureHandle, particleDescPtr->TranslucencyType, -1);
+	
 	for (i = 0; i < RenderPolygon.NumberOfVertices; i++) {
 		RENDERVERTEX *vertices = &renderVerticesPtr[i];
 		
-		int x1, y1;
 		GLfloat x, y, z;
 		GLfloat s, t;
 		GLfloat rhw = 1/(float)vertices->Z;
@@ -955,27 +925,8 @@ void D3D_Particle_Output(PARTICLE *particlePtr, RENDERVERTEX *renderVerticesPtr)
 		s = ((float)(vertices->U>>16)+.5) * RecipW;
 		t = ((float)(vertices->V>>16)+.5) * RecipH;
 		
-		
-		x1 = (vertices->X*(Global_VDB_Ptr->VDB_ProjX+1))/vertices->Z+Global_VDB_Ptr->VDB_CentreX;
-		y1 = (vertices->Y*(Global_VDB_Ptr->VDB_ProjY+1))/vertices->Z+Global_VDB_Ptr->VDB_CentreY;
-
-		if (x1<Global_VDB_Ptr->VDB_ClipLeft) {
-			x1=Global_VDB_Ptr->VDB_ClipLeft;
-		} else if (x1>Global_VDB_Ptr->VDB_ClipRight) {
-			x1=Global_VDB_Ptr->VDB_ClipRight;
-		}
-				
-		if (y1<Global_VDB_Ptr->VDB_ClipUp) {
-			y1=Global_VDB_Ptr->VDB_ClipUp;
-		} else if (y1>Global_VDB_Ptr->VDB_ClipDown) {
-			y1=Global_VDB_Ptr->VDB_ClipDown;
-		}
-		
-		x = x1;
-		y = y1;
-		
-		x =  (x - ScreenDescriptorBlock.SDB_CentreX)/ScreenDescriptorBlock.SDB_CentreX;
-		y = -(y - ScreenDescriptorBlock.SDB_CentreY)/ScreenDescriptorBlock.SDB_CentreY;
+		x =  ((float)vertices->X*((float)Global_VDB_Ptr->VDB_ProjX+1.0f))/((float)vertices->Z*(float)ScreenDescriptorBlock.SDB_CentreX);
+		y = -((float)vertices->Y*((float)Global_VDB_Ptr->VDB_ProjY+1.0f))/((float)vertices->Z*(float)ScreenDescriptorBlock.SDB_CentreY);		
 		
 		if (particleDescPtr->IsDrawnInFront) {
 			z = -0.999f; /* ... */
@@ -985,16 +936,22 @@ void D3D_Particle_Output(PARTICLE *particlePtr, RENDERVERTEX *renderVerticesPtr)
 			z = 1.0 - 2.0*ZNear/((float)vertices->Z); /* currently maps [ZNear, inf) to [-1, 1], probably could be more precise with a ZFar */
 		}
 
-		tarr[i].v[0] = x/rhw;
-		tarr[i].v[1] = y/rhw;
-		tarr[i].v[2] = z/rhw;
-		tarr[i].v[3] = 1/rhw;
+		varrp->v[0] = x/rhw;
+		varrp->v[1] = y/rhw;
+		varrp->v[2] = z/rhw;
+		varrp->v[3] = 1/rhw;
+		
+		varrp->t[0] = s;
+		varrp->t[1] = t;
+		
+		varrp->c[0] = r;
+		varrp->c[1] = g;
+		varrp->c[2] = b;
+		varrp->c[3] = a;
 		
-		tarr[i].t[0] = s;
-		tarr[i].t[1] = t;
+		varrp++;
+		varrc++;
 	}
-
-	DrawTriangles_T2F_V4F(RenderPolygon.NumberOfVertices);
 }
 
 void D3D_PredatorThermalVisionPolygon_Output(POLYHEADER *inputPolyPtr, RENDERVERTEX *renderVerticesPtr)
@@ -1003,54 +960,35 @@ void D3D_PredatorThermalVisionPolygon_Output(POLYHEADER *inputPolyPtr, RENDERVER
 	int i;
 	ZNear = (float) (Global_VDB_Ptr->VDB_ClipZ * GlobalScale);
 	
-	CheckBoundTextureIsCorrect(NULL); /* disable texturing */
-	CheckTranslucencyModeIsCorrect(TRANSLUCENCY_OFF);
+	CheckTriangleBuffer(RenderPolygon.NumberOfVertices, 0, 0, 0, NULL, TRANSLUCENCY_OFF, -1);
 	
 	for (i = 0; i < RenderPolygon.NumberOfVertices; i++) {
 		RENDERVERTEX *vertices = &renderVerticesPtr[i];
 		
-		int x1, y1;
 		GLfloat x, y, z;
 		float rhw, zvalue;
 		
-		x1 = (vertices->X*(Global_VDB_Ptr->VDB_ProjX+1))/vertices->Z+Global_VDB_Ptr->VDB_CentreX;
-		y1 = (vertices->Y*(Global_VDB_Ptr->VDB_ProjY+1))/vertices->Z+Global_VDB_Ptr->VDB_CentreY;
-
-		if (x1<Global_VDB_Ptr->VDB_ClipLeft) {
-			x1=Global_VDB_Ptr->VDB_ClipLeft;
-		} else if (x1>Global_VDB_Ptr->VDB_ClipRight) {
-			x1=Global_VDB_Ptr->VDB_ClipRight;
-		}
-				
-		if (y1<Global_VDB_Ptr->VDB_ClipUp) {
-			y1=Global_VDB_Ptr->VDB_ClipUp;
-		} else if (y1>Global_VDB_Ptr->VDB_ClipDown) {
-			y1=Global_VDB_Ptr->VDB_ClipDown;
-		}
-		
-		x = x1;
-		y = y1;
-		
-		x =  (x - ScreenDescriptorBlock.SDB_CentreX)/ScreenDescriptorBlock.SDB_CentreX;
-		y = -(y - ScreenDescriptorBlock.SDB_CentreY)/ScreenDescriptorBlock.SDB_CentreY;
+		x =  ((float)vertices->X*((float)Global_VDB_Ptr->VDB_ProjX+1.0f))/((float)vertices->Z*(float)ScreenDescriptorBlock.SDB_CentreX);
+		y = -((float)vertices->Y*((float)Global_VDB_Ptr->VDB_ProjY+1.0f))/((float)vertices->Z*(float)ScreenDescriptorBlock.SDB_CentreY);
 		
 		zvalue = vertices->Z+HeadUpDisplayZOffset;
 		z = 1.0 - 2*ZNear/zvalue;
 		
 		rhw = 1.0/(float)vertices->Z;
+
+		varrp->v[0] = x/rhw;
+		varrp->v[1] = y/rhw;
+		varrp->v[2] = z/rhw;
+		varrp->v[3] = 1/rhw;
 		
-		tarr[i].v[0] = x/rhw;
-		tarr[i].v[1] = y/rhw;
-		tarr[i].v[2] = z/rhw;
-		tarr[i].v[3] = 1/rhw;
+		varrp->c[0] = vertices->R;
+		varrp->c[1] = vertices->G;
+		varrp->c[2] = vertices->B;
+		varrp->c[3] = vertices->A;
 		
-		tarr[i].c[0] = vertices->R;
-		tarr[i].c[1] = vertices->G;
-		tarr[i].c[2] = vertices->B;
-		tarr[i].c[3] = vertices->A;
+		varrp++;
+		varrc++;
 	}
-
-	DrawTriangles_C4UB_V4F(RenderPolygon.NumberOfVertices);
 }
 
 void D3D_ZBufferedGouraudPolygon_Output(POLYHEADER *inputPolyPtr, RENDERVERTEX *renderVerticesPtr)
@@ -1062,56 +1000,37 @@ void D3D_ZBufferedGouraudPolygon_Output(POLYHEADER *inputPolyPtr, RENDERVERTEX *
 	
 	flags = inputPolyPtr->PolyFlags;
 	
-	CheckTranslucencyModeIsCorrect(RenderPolygon.TranslucencyMode);
-	CheckBoundTextureIsCorrect(NULL);
+	CheckTriangleBuffer(RenderPolygon.NumberOfVertices, 0, 0, 0, NULL, RenderPolygon.TranslucencyMode, -1);
 	
 	for (i = 0; i < RenderPolygon.NumberOfVertices; i++) {
 		RENDERVERTEX *vertices = &renderVerticesPtr[i];	
-		int x1, y1;
 		GLfloat x, y, z;
 		float rhw, zvalue;
-		
-		x1 = (vertices->X*(Global_VDB_Ptr->VDB_ProjX+1))/vertices->Z+Global_VDB_Ptr->VDB_CentreX;
-		y1 = (vertices->Y*(Global_VDB_Ptr->VDB_ProjY+1))/vertices->Z+Global_VDB_Ptr->VDB_CentreY;
-
-		if (x1<Global_VDB_Ptr->VDB_ClipLeft) {
-			x1=Global_VDB_Ptr->VDB_ClipLeft;
-		} else if (x1>Global_VDB_Ptr->VDB_ClipRight) {
-			x1=Global_VDB_Ptr->VDB_ClipRight;
-		}
 				
-		if (y1<Global_VDB_Ptr->VDB_ClipUp) {
-			y1=Global_VDB_Ptr->VDB_ClipUp;
-		} else if (y1>Global_VDB_Ptr->VDB_ClipDown) {
-			y1=Global_VDB_Ptr->VDB_ClipDown;
-		}
-		
-		x = x1;
-		y = y1;
-		
-		x =  (x - ScreenDescriptorBlock.SDB_CentreX)/ScreenDescriptorBlock.SDB_CentreX;
-		y = -(y - ScreenDescriptorBlock.SDB_CentreY)/ScreenDescriptorBlock.SDB_CentreY;
-		
 		zvalue = vertices->Z+HeadUpDisplayZOffset;
 		z = 1.0 - 2*ZNear/zvalue;
 				
 		rhw = 1.0/(float)vertices->Z;
+
+		x =  ((float)vertices->X*((float)Global_VDB_Ptr->VDB_ProjX+1.0f))/((float)vertices->Z*(float)ScreenDescriptorBlock.SDB_CentreX);
+		y = -((float)vertices->Y*((float)Global_VDB_Ptr->VDB_ProjY+1.0f))/((float)vertices->Z*(float)ScreenDescriptorBlock.SDB_CentreY);	
+
+		varrp->v[0] = x/rhw;
+		varrp->v[1] = y/rhw;
+		varrp->v[2] = z/rhw;
+		varrp->v[3] = 1/rhw;
 		
-		tarr[i].v[0] = x/rhw;
-		tarr[i].v[1] = y/rhw;
-		tarr[i].v[2] = z/rhw;
-		tarr[i].v[3] = 1/rhw;
-		
-		tarr[i].c[0] = vertices->R;
-		tarr[i].c[1] = vertices->G;
-		tarr[i].c[2] = vertices->B;
+		varrp->c[0] = vertices->R;
+		varrp->c[1] = vertices->G;
+		varrp->c[2] = vertices->B;
 		if (flags & iflag_transparent)
-			tarr[i].c[3] = vertices->A;
+			varrp->c[3] = vertices->A;
 		else
-			tarr[i].c[3] = 255;
+			varrp->c[3] = 255;
+		
+		varrp++;
+		varrc++;
 	}
-
-	DrawTriangles_C4UB_V4F(RenderPolygon.NumberOfVertices);
 }
 
 void D3D_PlayerOnFireOverlay()
@@ -1517,9 +1436,11 @@ void D3D_FadeDownScreen(int brightness, int colour)
 
 void D3D_HUD_Setup()
 {
+	FlushTriangleBuffers(1);
+	
 	CheckTranslucencyModeIsCorrect(TRANSLUCENCY_GLOWING);
 	
-	glDepthFunc(GL_LEQUAL);
+	glDepthFunc(GL_LEQUAL);	
 }
 
 void D3D_HUDQuad_Output(int imageNumber, struct VertexTag *quadVerticesPtr, unsigned int colour)
@@ -1966,6 +1887,7 @@ void D3D_DrawParticle_Rain(PARTICLE *particlePtr,VECTORCH *prevPositionPtr)
 {
 	VECTORCH vertices[3];
 	float ZNear;
+	int i;
 	
 	vertices[0] = *prevPositionPtr;
 	
@@ -1992,66 +1914,36 @@ void D3D_DrawParticle_Rain(PARTICLE *particlePtr,VECTORCH *prevPositionPtr)
 
 		ZNear = (float) (Global_VDB_Ptr->VDB_ClipZ * GlobalScale);
 
-		{
-			int i = 3;
-			VECTORCH *verticesPtr = vertices;
-			do
-			{
-				GLfloat xf, yf, zf, rhw;
+		CheckTriangleBuffer(3, 0, 0, 0, NULL, TRANSLUCENCY_NORMAL, -1);
 				
-				int x = (verticesPtr->vx*(Global_VDB_Ptr->VDB_ProjX))/verticesPtr->vz+Global_VDB_Ptr->VDB_CentreX;
-				int y = (verticesPtr->vy*(Global_VDB_Ptr->VDB_ProjY))/verticesPtr->vz+Global_VDB_Ptr->VDB_CentreY;
+		for (i = 0; i < 3; i++) {
+			GLfloat xf, yf, zf, rhw;
+			
+			xf =  ((float)vertices[i].vx*((float)Global_VDB_Ptr->VDB_ProjX+1.0f))/((float)vertices[i].vz*(float)ScreenDescriptorBlock.SDB_CentreX);
+			yf = -((float)vertices[i].vy*((float)Global_VDB_Ptr->VDB_ProjY+1.0f))/((float)vertices[i].vz*(float)ScreenDescriptorBlock.SDB_CentreY);
+			
+			zf = 1.0f - 2.0f*ZNear/(float)vertices[i].vz;
+			rhw = 1.0f / (float)vertices[i].vz;
 
-				if (x<Global_VDB_Ptr->VDB_ClipLeft)
-				{
-					x=Global_VDB_Ptr->VDB_ClipLeft;
-				}	
-				else if (x>Global_VDB_Ptr->VDB_ClipRight)
-				{
-					x=Global_VDB_Ptr->VDB_ClipRight;	
-				}
-					
-				if (y<Global_VDB_Ptr->VDB_ClipUp)
-				{
-					y=Global_VDB_Ptr->VDB_ClipUp;
-				}
-				else if (y>Global_VDB_Ptr->VDB_ClipDown)
-				{
-					y=Global_VDB_Ptr->VDB_ClipDown;	
-				}
-		
-				xf =  ((float)x - (float)ScreenDescriptorBlock.SDB_CentreX - 0.5f)/((float)ScreenDescriptorBlock.SDB_CentreX - 0.5f);
-				yf = -((float)y - (float)ScreenDescriptorBlock.SDB_CentreY - 0.5f)/((float)ScreenDescriptorBlock.SDB_CentreY - 0.5f);
-				
-				zf = 1.0f - 2.0f*ZNear/(float)verticesPtr->vz;
-				rhw = 1.0f / (float)verticesPtr->vz;
+			varrp->v[0] = xf/rhw;
+			varrp->v[1] = yf/rhw;
+			varrp->v[2] = zf/rhw;
+			varrp->v[3] = 1.0f/rhw;
 				
-				tarr[3-i].v[0] = xf/rhw;
-				tarr[3-i].v[1] = yf/rhw;
-				tarr[3-i].v[2] = zf/rhw;
-				tarr[3-i].v[3] = 1.0f/rhw;
-				
-				if (i == 3) {
-					tarr[3-i].c[0] = 0;
-					tarr[3-i].c[1] = 255;
-					tarr[3-i].c[2] = 255;
-					tarr[3-i].c[3] = 32;
-				} else {
-					tarr[3-i].c[0] = 255;
-					tarr[3-i].c[1] = 255;
-					tarr[3-i].c[2] = 255;
-					tarr[3-i].c[3] = 32;
-				}
-
-				verticesPtr++;
+			if (i == 0) {
+				varrp->c[0] = 0;
+				varrp->c[1] = 255;
+				varrp->c[2] = 255;
+				varrp->c[3] = 32;
+			} else {
+				varrp->c[0] = 255;
+				varrp->c[1] = 255;
+				varrp->c[2] = 255;
+				varrp->c[3] = 32;
 			}
-		  	while(--i);
+			varrp++;
+			varrc++;			
 		}
-		
-		CheckBoundTextureIsCorrect(NULL);
-		CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
-
-		DrawTriangles_C4UB_V4F(3); /* single triangle */
 	}
 }
 
@@ -2063,11 +1955,11 @@ void PostLandscapeRendering()
 
 	extern char LevelName[];
 
-
 	if (!strcmp(LevelName,"fall")||!strcmp(LevelName,"fall_m"))
 	{
 		char drawWaterFall = 0;
 		char drawStream = 0;
+		char drawStream2 = 0;
 
 		while(numOfObjects)
 		{
@@ -2095,19 +1987,27 @@ void PostLandscapeRendering()
 				       ||(!strcmp(modulePtr->name,"watergate")))
 				{
 		   			drawStream = 1;
+				} 
+				else if(  (!strcmp(modulePtr->name,"openwat03"))
+					||(!strcmp(modulePtr->name,"openwat04"))
+					||(!strcmp(modulePtr->name,"openwat04A"))
+					||(!strcmp(modulePtr->name,"openwat02")))
+				{
+					drawStream2 = 1;
 				}
+				
 			}
 		}	
 
 		if (drawWaterFall)
 		{
-			CurrTextureHandle = NULL;
-			CheckBoundTextureIsCorrect(NULL);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
+//			CurrTextureHandle = NULL;
+//			CheckBoundTextureIsCorrect(NULL);
+//			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 			
+			FlushTriangleBuffers(1);
 			glDepthMask(GL_FALSE);
 
-	   		//UpdateWaterFall();
 			WaterFallBase = 109952;
 			
 			MeshZScale = (66572-51026)/15;
@@ -2116,14 +2016,15 @@ void PostLandscapeRendering()
 	   		D3D_DrawWaterFall(175545,-3039,51026);
 //			MeshZScale = -(538490-392169);
 //			MeshXScale = 55000;
-	//		D3D_DrawWaterPatch(-100000, WaterFallBase, 538490);
+//			D3D_DrawWaterPatch(-100000, WaterFallBase, 538490);
 			
+			FlushTriangleBuffers(1);
 			glDepthMask(GL_TRUE);
 		}
 		if (drawStream)
 		{
 			int x = 68581;
-			int y = 12925;
+			int y = 12925; /* probably should lower this a little.. */
 			int z = 93696;
 			MeshXScale = (87869-68581);
 			MeshZScale = (105385-93696);
@@ -2140,45 +2041,50 @@ void PostLandscapeRendering()
 		 	MeshZScale/=2;
 			
 			CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
-		 	D3D_DrawWaterPatch(x, y, z);
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
+			CheckTriangleBuffer(0, 0, 0, 0, CurrTextureHandle, TRANSLUCENCY_NORMAL, -1);
+			
+		 	D3D_DrawWaterPatch(x, y, z);		 	
 		 	D3D_DrawWaterPatch(x+MeshXScale, y, z);
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 		 	D3D_DrawWaterPatch(x+MeshXScale*2, y, z);
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 		 	D3D_DrawWaterPatch(x+MeshXScale*3, y, z);
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 		 	D3D_DrawWaterPatch(x, y, z+MeshZScale);
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 		 	D3D_DrawWaterPatch(x+MeshXScale, y, z+MeshZScale);
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 		 	D3D_DrawWaterPatch(x+MeshXScale*2, y, z+MeshZScale);
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 		 	D3D_DrawWaterPatch(x+MeshXScale*3, y, z+MeshZScale);
 		}
+		if (drawStream2)
+		{
+#if 0 /* added, but then disabled (too squishy) */
+			int x = 217400;
+			int y = 20750;
+			int z = 54000;
+			MeshXScale = (87869-68581);
+			MeshZScale = (105385-93696);
+			{
+				extern void CheckForObjectsInWater(int minX, int maxX, int minZ, int maxZ, int averageY);
+				CheckForObjectsInWater(x, x+MeshXScale, z, z+MeshZScale, y);
+			}
+
+			WaterXOrigin=x;
+			WaterZOrigin=z;
+			WaterUScale = 4.0f/(float)MeshXScale;
+			WaterVScale = 4.0f/(float)MeshZScale;
+		 	MeshXScale/=4;
+		 	MeshZScale/=2;
+			
+			CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
+			CheckTriangleBuffer(0, 0, 0, 0, CurrTextureHandle, TRANSLUCENCY_NORMAL, -1);
+			
+		 	D3D_DrawWaterPatch(x, y, z);		 	
+		 	D3D_DrawWaterPatch(x+MeshXScale, y, z);
+		 	D3D_DrawWaterPatch(x+MeshXScale*2, y, z);
+		 	D3D_DrawWaterPatch(x+MeshXScale*3, y, z);
+		 	D3D_DrawWaterPatch(x, y, z+MeshZScale);
+		 	D3D_DrawWaterPatch(x+MeshXScale, y, z+MeshZScale);
+		 	D3D_DrawWaterPatch(x+MeshXScale*2, y, z+MeshZScale);
+		 	D3D_DrawWaterPatch(x+MeshXScale*3, y, z+MeshZScale);
+#endif		 	
+		}	
 	}
 #if 0
 	else if ( (!__stricmp(LevelName,"e3demo")) || (!__stricmp(LevelName,"e3demosp")) )
@@ -2507,45 +2413,14 @@ void PostLandscapeRendering()
 		 	MeshZScale/=2;
 			
 			CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
+			CheckTriangleBuffer(0, 0, 0, 0, CurrTextureHandle, TRANSLUCENCY_NORMAL, -1);
 		 	D3D_DrawWaterPatch(x, y, z);
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
-		 	D3D_DrawWaterPatch(x+MeshXScale, y, z);
-		 	
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
+		 	D3D_DrawWaterPatch(x+MeshXScale, y, z);		 	
 		 	D3D_DrawWaterPatch(x+MeshXScale*2, y, z);
-		 	
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 		 	D3D_DrawWaterPatch(x+MeshXScale*3, y, z);
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 		 	D3D_DrawWaterPatch(x, y, z+MeshZScale);
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 		 	D3D_DrawWaterPatch(x+MeshXScale, y, z+MeshZScale);
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 		 	D3D_DrawWaterPatch(x+MeshXScale*2, y, z+MeshZScale);
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 		 	D3D_DrawWaterPatch(x+MeshXScale*3, y, z+MeshZScale);
 		}
 		else if (drawEndWater)
@@ -2566,45 +2441,15 @@ void PostLandscapeRendering()
 		 	MeshXScale/=4;
 		 	MeshZScale/=2;
 			
-
-		 	CurrTextureHandle = ImageHeaderArray[WaterShaftImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
+			CurrTextureHandle = ImageHeaderArray[WaterShaftImageNumber].D3DTexture;
+			CheckTriangleBuffer(0, 0, 0, 0, CurrTextureHandle, TRANSLUCENCY_NORMAL, -1);
 		 	D3D_DrawWaterPatch(x, y, z);
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[WaterShaftImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 		 	D3D_DrawWaterPatch(x+MeshXScale, y, z);
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[WaterShaftImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 		 	D3D_DrawWaterPatch(x+MeshXScale*2, y, z);
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[WaterShaftImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 		 	D3D_DrawWaterPatch(x+MeshXScale*3, y, z);
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[WaterShaftImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 		 	D3D_DrawWaterPatch(x, y, z+MeshZScale);
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[WaterShaftImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 		 	D3D_DrawWaterPatch(x+MeshXScale, y, z+MeshZScale);
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[WaterShaftImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 		 	D3D_DrawWaterPatch(x+MeshXScale*2, y, z+MeshZScale);
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[WaterShaftImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 		 	D3D_DrawWaterPatch(x+MeshXScale*3, y, z+MeshZScale);
 		}
 	}
@@ -2663,26 +2508,11 @@ void PostLandscapeRendering()
 		 	MeshXScale/=2;
 		 	MeshZScale/=2;
 			
-			
-			/* TODO: this is a hack for the 2 pass specular color because it changes the texture/blend func */
 			CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
+			CheckTriangleBuffer(0, 0, 0, 0, CurrTextureHandle, TRANSLUCENCY_NORMAL, -1);
 		 	D3D_DrawWaterPatch(x, y, z);
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 		 	D3D_DrawWaterPatch(x+MeshXScale, y, z);
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 		 	D3D_DrawWaterPatch(x, y, z+MeshZScale);
-		 	
-		 	CurrTextureHandle = ImageHeaderArray[ChromeImageNumber].D3DTexture;
-			CheckBoundTextureIsCorrect(CurrTextureHandle);
-			CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 		 	D3D_DrawWaterPatch(x+MeshXScale, y, z+MeshZScale);
 		}
 
@@ -2761,23 +2591,10 @@ void D3D_DrawWaterTest(MODULE *testModulePtr)
 				MeshZScale/=2;
 				
 				CurrTextureHandle = ImageHeaderArray[WaterShaftImageNumber].D3DTexture;
-				CheckBoundTextureIsCorrect(CurrTextureHandle);
-				CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
+				CheckTriangleBuffer(0, 0, 0, 0, CurrTextureHandle, TRANSLUCENCY_NORMAL, -1);
 				D3D_DrawWaterPatch(x, y, z);
-				
-				CurrTextureHandle = ImageHeaderArray[WaterShaftImageNumber].D3DTexture;
-				CheckBoundTextureIsCorrect(CurrTextureHandle);
-				CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 				D3D_DrawWaterPatch(x+MeshXScale, y, z);
-				
-				CurrTextureHandle = ImageHeaderArray[WaterShaftImageNumber].D3DTexture;
-				CheckBoundTextureIsCorrect(CurrTextureHandle);
-				CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 				D3D_DrawWaterPatch(x, y, z+MeshZScale);
-				
-				CurrTextureHandle = ImageHeaderArray[WaterShaftImageNumber].D3DTexture;
-				CheckBoundTextureIsCorrect(CurrTextureHandle);
-				CheckTranslucencyModeIsCorrect(TRANSLUCENCY_NORMAL);
 				D3D_DrawWaterPatch(x+MeshXScale, y, z+MeshZScale);
 				
 				{
@@ -2960,8 +2777,8 @@ void D3D_DrawWaterPatch(int xOrigin, int yOrigin, int zOrigin)
 			#endif
 
 			#if 1
-			MeshWorldVertex[i].vx = ((point->vx-WaterXOrigin)/4+MUL_FIXED(GetSin((point->vy*16)&4095),128));			
-			MeshWorldVertex[i].vy = ((point->vz-WaterZOrigin)/4+MUL_FIXED(GetSin((point->vy*16+200)&4095),128));			
+			MeshWorldVertex[i].vx = ((point->vx-WaterXOrigin)/4+MUL_FIXED(GetSin((point->vy*16)&4095),128));
+			MeshWorldVertex[i].vy = ((point->vz-WaterZOrigin)/4+MUL_FIXED(GetSin((point->vy*16+200)&4095),128));
 			#endif
 			
 			#if 1
@@ -3012,10 +2829,7 @@ void D3D_DrawWaterPatch(int xOrigin, int yOrigin, int zOrigin)
 	{
 		D3D_DrawMoltenMetalMesh_Unclipped();
 //		D3D_DrawWaterMesh_Unclipped();
-	}	
-	else
-//	else if (MeshVertexOutcode[0]||MeshVertexOutcode[15]||MeshVertexOutcode[240]||MeshVertexOutcode[255])
-	{
+	} else {
 		D3D_DrawMoltenMetalMesh_Clipped();
 //		D3D_DrawWaterMesh_Clipped();
 	}
@@ -3267,273 +3081,6 @@ void D3D_DrawWaterMesh_Clipped(void)
 
 #endif
 
-#if 0
-
-void D3D_DrawMoltenMetalMesh_Unclipped(void)
-{
-	float ZNear = (float) (Global_VDB_Ptr->VDB_ClipZ * GlobalScale);
-
-	VECTORCH *point = MeshVertex;
-	VECTORCH *pointWS = MeshWorldVertex;
-
-	int i, x, y, z;
-	int tc;
-
-	for (i=0; i<256; i++) {
-		GLfloat xf, yf, zf;
-		GLfloat sf, tf, rhw;
-		int r, g, b, a;
-		
-		if (point->vz < 1) point->vz = 1;
-
-		x = (point->vx*(Global_VDB_Ptr->VDB_ProjX+1))/point->vz+Global_VDB_Ptr->VDB_CentreX;
-		y = (point->vy*(Global_VDB_Ptr->VDB_ProjY+1))/point->vz+Global_VDB_Ptr->VDB_CentreY;
-
-		if (x<Global_VDB_Ptr->VDB_ClipLeft) {
-			x=Global_VDB_Ptr->VDB_ClipLeft;
-		} else if (x>Global_VDB_Ptr->VDB_ClipRight) {
-			x=Global_VDB_Ptr->VDB_ClipRight;	
-		}			
-
-		if (y<Global_VDB_Ptr->VDB_ClipUp) {
-			y=Global_VDB_Ptr->VDB_ClipUp;
-		} else if (y>Global_VDB_Ptr->VDB_ClipDown) {
-			y=Global_VDB_Ptr->VDB_ClipDown;	
-		}
-			
-		sf = pointWS->vx*WaterUScale+(1.0f/256.0f);
-		tf = pointWS->vy*WaterVScale+(1.0f/256.0f);
-	
-		z = point->vz + HeadUpDisplayZOffset;
-		rhw = 1.0f / (float)point->vz;		  	
-		
-		b = (MeshVertexColour[i] >> 0)  & 0xFF;
-		g = (MeshVertexColour[i] >> 8)  & 0xFF;
-		r = (MeshVertexColour[i] >> 16) & 0xFF;
-		a = (MeshVertexColour[i] >> 24) & 0xFF;
-			
-		xf =  ((float)x - (float)ScreenDescriptorBlock.SDB_CentreX - 0.5f) / ((float)ScreenDescriptorBlock.SDB_CentreX - 0.5f);
-		yf = -((float)y - (float)ScreenDescriptorBlock.SDB_CentreY - 0.5f) / ((float)ScreenDescriptorBlock.SDB_CentreY - 0.5f);
-		zf = 1.0f - 2.0f*ZNear/(float)z;
-			
-		tarr[i].v[0] = xf/rhw;
-		tarr[i].v[1] = yf/rhw;
-		tarr[i].v[2] = zf/rhw;
-		tarr[i].v[3] = 1.0f/rhw;
-		
-		tarr[i].t[0] = sf;
-		tarr[i].t[1] = tf;
-		
-		tarr[i].c[0] = r;
-		tarr[i].c[1] = g;
-		tarr[i].c[2] = b;
-		tarr[i].c[3] = a;
-		
-		point++;
-		pointWS++;
-	}
-    
-	/* CONSTRUCT POLYS */
-	
-	tc = 0;
-	for (x = 0; x < 15; x++) {
-		for(y = 0; y < 15; y++) {
-//			OUTPUT_TRIANGLE(0+x+(16*y),1+x+(16*y),16+x+(16*y), 256);
-//			OUTPUT_TRIANGLE(1+x+(16*y),17+x+(16*y),16+x+(16*y), 256);
-			if ((16+x+(16*y)) < 256) {
-				tris[tc+0].a = 0+x+(16*y);
-				tris[tc+0].b = 1+x+(16*y);
-				tris[tc+0].c = 16+x+(16*y);
-				tris[tc+1].a = 1+x+(16*y);
-				tris[tc+1].b = 17+x+(16*y);
-				tris[tc+1].c = 16+x+(16*y);
-			
-				tc += 2;
-			}
-		}
-	}
-	DrawTriangleArray_T2F_C4UB_V4F(tc);
-}
-
-void D3D_DrawMoltenMetalMesh_Clipped(void)
-{
-	int i, x, y, z;
-	
-	float ZNear = (float) (Global_VDB_Ptr->VDB_ClipZ * GlobalScale);	
-
-	{
-		VECTORCH *point = MeshVertex;
-		VECTORCH *pointWS = MeshWorldVertex;
-
-		for (i=0; i<256; i++)
-		{
-			GLfloat xf, yf, zf;
-			GLfloat sf, tf, rhw;
-			int r, g, b, a;
-			
-			if (point->vz < 1) point->vz = 1;
-			
-			x = (point->vx*(Global_VDB_Ptr->VDB_ProjX+1))/point->vz+Global_VDB_Ptr->VDB_CentreX;
-			y = (point->vy*(Global_VDB_Ptr->VDB_ProjY+1))/point->vz+Global_VDB_Ptr->VDB_CentreY;
-
-			if (x<Global_VDB_Ptr->VDB_ClipLeft) {
-				x=Global_VDB_Ptr->VDB_ClipLeft;
-			} else if (x>Global_VDB_Ptr->VDB_ClipRight) {
-				x=Global_VDB_Ptr->VDB_ClipRight;	
-			}
-				
-			if (y<Global_VDB_Ptr->VDB_ClipUp) {
-				y=Global_VDB_Ptr->VDB_ClipUp;
-			} else if (y>Global_VDB_Ptr->VDB_ClipDown) {
-				y=Global_VDB_Ptr->VDB_ClipDown;	
-			}
-			
-			sf = pointWS->vx*WaterUScale+(1.0f/256.0f);
-			tf = pointWS->vy*WaterVScale+(1.0f/256.0f);
-	
-			z = point->vz + HeadUpDisplayZOffset;
-		  	rhw = 1.0f / (float)point->vz;
-		  	
-			b = (MeshVertexColour[i] >> 0)  & 0xFF;
-			g = (MeshVertexColour[i] >> 8)  & 0xFF;
-			r = (MeshVertexColour[i] >> 16) & 0xFF;
-			a = (MeshVertexColour[i] >> 24) & 0xFF;
-			
-			xf =  ((float)x - (float)ScreenDescriptorBlock.SDB_CentreX - 0.5f) / ((float)ScreenDescriptorBlock.SDB_CentreX - 0.5f);
-			yf = -((float)y - (float)ScreenDescriptorBlock.SDB_CentreY - 0.5f) / ((float)ScreenDescriptorBlock.SDB_CentreY - 0.5f);
-			zf = 1.0f - 2.0f*ZNear/(float)z;
-			
-			tarr[i].v[0] = xf/rhw;
-			tarr[i].v[1] = yf/rhw;
-			tarr[i].v[2] = zf/rhw;
-			tarr[i].v[3] = 1.0f/rhw;
-			
-			tarr[i].t[0] = sf;
-			tarr[i].t[1] = tf;
-			
-			tarr[i].c[0] = r;
-			tarr[i].c[1] = g;
-			tarr[i].c[2] = b;
-			tarr[i].c[3] = a;
-			
-			point++;
-			pointWS++;
-		}
-	}
-
-	/* CONSTRUCT POLYS */
-	{
-		int tc = 0;
-		
-		for (x=0; x<15; x++)
-		{
-			for(y=0; y<15; y++)
-			{
-				int p1 = 0+x+(16*y);
-				int p2 = 1+x+(16*y);
-				int p3 = 16+x+(16*y);
-				int p4 = 17+x+(16*y);
-				
-				if (p3 > 255)
-					continue;
-#if 0
-				#if 0
-				if (MeshVertexOutcode[p1]&&MeshVertexOutcode[p2]&&MeshVertexOutcode[p3])
-				{
-					OP_TRIANGLE_LIST(1, ExecBufInstPtr);
-					OUTPUT_TRIANGLE(p1,p2,p3, 256);
-				}
-				if (MeshVertexOutcode[p2]&&MeshVertexOutcode[p3]&&MeshVertexOutcode[p4])
-				{
-					OP_TRIANGLE_LIST(1, ExecBufInstPtr);
-					OUTPUT_TRIANGLE(p2,p4,p3, 256);
-				}	
-				#else
-				if (MeshVertexOutcode[p1]&&MeshVertexOutcode[p2]&&MeshVertexOutcode[p3]&&MeshVertexOutcode[p4])
-				{
-					OP_TRIANGLE_LIST(2, ExecBufInstPtr);
-					OUTPUT_TRIANGLE(p1,p2,p3, 256);
-					OUTPUT_TRIANGLE(p2,p4,p3, 256);
-				}	
-
-				#endif
-#endif
-				if (MeshVertexOutcode[p1]&&MeshVertexOutcode[p2]&&MeshVertexOutcode[p3]&&MeshVertexOutcode[p4]) {
-					tris[tc+0].a = p1;
-					tris[tc+0].b = p2;
-					tris[tc+0].c = p3;
-					tris[tc+1].a = p2;
-					tris[tc+1].b = p4;
-					tris[tc+1].c = p3;
-					tc += 2;
-				}
-			}
-		}
-		DrawTriangleArray_T2F_C4UB_V4F(tc);
-	}
-	{
-		POLYHEADER fakeHeader;
-
-		fakeHeader.PolyFlags = 0;
-		fakeHeader.PolyColour = 0;
-		RenderPolygon.TranslucencyMode = TRANSLUCENCY_NORMAL;
-		
-		for (x=0; x<15; x++)
-		{
-			for(y=0; y<15; y++)
-			{
-				int p[4];
-				p[0] = 0+x+(16*y);
-				p[1] = 1+x+(16*y);
-				p[2] = 17+x+(16*y);
-				p[3] = 16+x+(16*y);
-
-				if (p[3] > 255)
-					continue;
-					
-				if (!(MeshVertexOutcode[p[0]]&&MeshVertexOutcode[p[1]]&&MeshVertexOutcode[p[2]]&&MeshVertexOutcode[p[3]]))
-				{
-					for (i=0; i<4; i++) 
-					{
-						VerticesBuffer[i].X	= MeshVertex[p[i]].vx;
-						VerticesBuffer[i].Y	= MeshVertex[p[i]].vy;
-						VerticesBuffer[i].Z	= MeshVertex[p[i]].vz;
-						VerticesBuffer[i].U = MeshWorldVertex[p[i]].vx*(WaterUScale*128.0f*65536.0f);
-						VerticesBuffer[i].V = MeshWorldVertex[p[i]].vy*(WaterVScale*128.0f*65536.0f);
-															   
-						VerticesBuffer[i].A = (MeshVertexColour[p[i]]&0xff000000)>>24;
-						VerticesBuffer[i].R = (MeshVertexColour[p[i]]&0x00ff0000)>>16;
-						VerticesBuffer[i].G	= (MeshVertexColour[p[i]]&0x0000ff00)>>8;
-						VerticesBuffer[i].B = MeshVertexColour[p[i]]&0x000000ff;
-						VerticesBuffer[i].SpecularR = 0;
-						VerticesBuffer[i].SpecularG = 0;
-						VerticesBuffer[i].SpecularB = 0;
-						RenderPolygon.NumberOfVertices=4;
-						
-					}
-					if (QuadWithinFrustrum())
-					{		 
-						GouraudTexturedPolygon_ClipWithZ();
-						if(RenderPolygon.NumberOfVertices<3) continue;
-						GouraudTexturedPolygon_ClipWithNegativeX();
-						if(RenderPolygon.NumberOfVertices<3) continue;
-						GouraudTexturedPolygon_ClipWithPositiveY();
-						if(RenderPolygon.NumberOfVertices<3) continue;
-						GouraudTexturedPolygon_ClipWithNegativeY();
-						if(RenderPolygon.NumberOfVertices<3) continue;
-						GouraudTexturedPolygon_ClipWithPositiveX();
-						if(RenderPolygon.NumberOfVertices<3) continue;
-					   //	D3D_ZBufferedGouraudPolygon_Output(&fakeHeader,RenderPolygon.Vertices);
-				   	   	D3D_ZBufferedGouraudTexturedPolygon_Output(&fakeHeader,RenderPolygon.Vertices);
-					}
-				}
-			}
-		}
-	}
-}
-
-#endif
-
 signed int ForceFieldPointDisplacement[15*3+1][16];
 signed int ForceFieldPointDisplacement2[15*3+1][16];
 signed int ForceFieldPointVelocity[15*3+1][16];
@@ -4233,8 +3780,11 @@ void D3D_DrawMoltenMetalMesh_Unclipped(void)
 	VECTORCH *pointWS = MeshWorldVertex;
 
 	int i, x, y, z;
-	int tc;
-
+	int start;
+	
+	CheckTriangleBuffer( /*256*/ 273, 0, 450, 0, (D3DTexture *)-1, -1, -1);
+	
+	start = varrc;
 	for (i=0; i<256; i++) {
 		GLfloat xf, yf, zf;
 		GLfloat sf, tf, rhw;
@@ -4271,19 +3821,22 @@ void D3D_DrawMoltenMetalMesh_Unclipped(void)
 		xf =  ((float)x - (float)ScreenDescriptorBlock.SDB_CentreX - 0.5f) / ((float)ScreenDescriptorBlock.SDB_CentreX - 0.5f);
 		yf = -((float)y - (float)ScreenDescriptorBlock.SDB_CentreY - 0.5f) / ((float)ScreenDescriptorBlock.SDB_CentreY - 0.5f);
 		zf = 1.0f - 2.0f*ZNear/(float)z;
-			
-		tarr[i].v[0] = xf/rhw;
-		tarr[i].v[1] = yf/rhw;
-		tarr[i].v[2] = zf/rhw;
-		tarr[i].v[3] = 1.0f/rhw;
+
+		varrp->v[0] = xf/rhw;
+		varrp->v[1] = yf/rhw;
+		varrp->v[2] = zf/rhw;
+		varrp->v[3] = 1.0f/rhw;
 		
-		tarr[i].t[0] = sf;
-		tarr[i].t[1] = tf;
+		varrp->t[0] = sf;
+		varrp->t[1] = tf;
 		
-		tarr[i].c[0] = r;
-		tarr[i].c[1] = g;
-		tarr[i].c[2] = b;
-		tarr[i].c[3] = a;
+		varrp->c[0] = r;
+		varrp->c[1] = g;
+		varrp->c[2] = b;
+		varrp->c[3] = a;
+
+		varrp++;
+		varrc++;
 		
 		point++;
 		pointWS++;
@@ -4291,36 +3844,39 @@ void D3D_DrawMoltenMetalMesh_Unclipped(void)
     
 	/* CONSTRUCT POLYS */
 	
-	tc = 0;
 	for (x = 0; x < 15; x++) {
 		for(y = 0; y < 15; y++) {
 //			OUTPUT_TRIANGLE(0+x+(16*y),1+x+(16*y),16+x+(16*y), 256);
 //			OUTPUT_TRIANGLE(1+x+(16*y),17+x+(16*y),16+x+(16*y), 256);
-			if ((16+x+(16*y)) < 256) {
-				tris[tc+0].a = 0+x+(16*y);
-				tris[tc+0].b = 1+x+(16*y);
-				tris[tc+0].c = 16+x+(16*y);
-				tris[tc+1].a = 1+x+(16*y);
-				tris[tc+1].b = 17+x+(16*y);
-				tris[tc+1].c = 16+x+(16*y);
+
+			tarrp[0].a = start+0+x+(16*y);
+			tarrp[0].b = start+1+x+(16*y);
+			tarrp[0].c = start+16+x+(16*y);
 			
-				tc += 2;
-			}
+			tarrp[1].a = start+1+x+(16*y);
+			tarrp[1].b = start+17+x+(16*y);
+			tarrp[1].c = start+16+x+(16*y);
+			
+			tarrp += 2;
+			tarrc += 2;
 		}
 	}
-	DrawTriangleArray_T2F_C4UB_V4F(tc);
 }
 
 void D3D_DrawMoltenMetalMesh_Clipped(void)
 {
+	/* clipping unnecessary. */
+	D3D_DrawMoltenMetalMesh_Unclipped();
+#if 0
 	int i, x, y, z;
-	
+
 	float ZNear = (float) (Global_VDB_Ptr->VDB_ClipZ * GlobalScale);	
 
-	{
-		VECTORCH *point = MeshVertex;
-		VECTORCH *pointWS = MeshWorldVertex;
+	VECTORCH *point = MeshVertex;
+	VECTORCH *pointWS = MeshWorldVertex;
 
+	CheckTriangleBuffer(256, 0, 450, 0, (D3DTexture *)-1, -1, -1);
+	
 		for (i=0; i<256; i++)
 		{
 			GLfloat xf, yf, zf;
@@ -4358,7 +3914,7 @@ void D3D_DrawMoltenMetalMesh_Clipped(void)
 			xf =  ((float)x - (float)ScreenDescriptorBlock.SDB_CentreX - 0.5f) / ((float)ScreenDescriptorBlock.SDB_CentreX - 0.5f);
 			yf = -((float)y - (float)ScreenDescriptorBlock.SDB_CentreY - 0.5f) / ((float)ScreenDescriptorBlock.SDB_CentreY - 0.5f);
 			zf = 1.0f - 2.0f*ZNear/(float)z;
-			
+
 			tarr[i].v[0] = xf/rhw;
 			tarr[i].v[1] = yf/rhw;
 			tarr[i].v[2] = zf/rhw;
@@ -4371,11 +3927,10 @@ void D3D_DrawMoltenMetalMesh_Clipped(void)
 			tarr[i].c[1] = g;
 			tarr[i].c[2] = b;
 			tarr[i].c[3] = a;
-			
+
 			point++;
 			pointWS++;
 		}
-	}
 
 	/* CONSTRUCT POLYS */
 	{
@@ -4415,17 +3970,18 @@ void D3D_DrawMoltenMetalMesh_Clipped(void)
 				#endif
 #endif
 				if (MeshVertexOutcode[p1]&&MeshVertexOutcode[p2]&&MeshVertexOutcode[p3]&&MeshVertexOutcode[p4]) {
+#if 0				
 					tris[tc+0].a = p1;
 					tris[tc+0].b = p2;
 					tris[tc+0].c = p3;
 					tris[tc+1].a = p2;
 					tris[tc+1].b = p4;
 					tris[tc+1].c = p3;
+#endif					
 					tc += 2;
 				}
 			}
 		}
-		DrawTriangleArray_T2F_C4UB_V4F(tc);
 	}
 	{
 		POLYHEADER fakeHeader;
@@ -4479,13 +4035,17 @@ void D3D_DrawMoltenMetalMesh_Clipped(void)
 						if(RenderPolygon.NumberOfVertices<3) continue;
 						GouraudTexturedPolygon_ClipWithPositiveX();
 						if(RenderPolygon.NumberOfVertices<3) continue;
-					   //	D3D_ZBufferedGouraudPolygon_Output(&fakeHeader,RenderPolygon.Vertices);
-				   	   	D3D_ZBufferedGouraudTexturedPolygon_Output(&fakeHeader,RenderPolygon.Vertices);
+
+					   	if (CurrTextureHandle == NULL)
+						   	D3D_ZBufferedGouraudPolygon_Output(&fakeHeader,RenderPolygon.Vertices);
+						else
+							D3D_ZBufferedGouraudTexturedPolygon_Output(&fakeHeader,RenderPolygon.Vertices);
 					}
 				}
 			}
 		}
 	}
+#endif	
 }
 
 #if 0 /* not yet */