From 8396b780e4430e8f483daa6293573e57dbda48af Mon Sep 17 00:00:00 2001
From: atsb <atsb@atsb>
Date: Mon, 27 Mar 2023 11:06:50 +0200
Subject: [PATCH 1/2] adding back some code but it is really unstable

---
 src/engine/am_draw.c    |  57 +++++++++++++----
 src/engine/dgl.c        | 121 +++++++++++++++++++++++++++++++++++
 src/engine/gl_draw.c    |  14 +++++
 src/engine/gl_main.c    |  67 ++++++++++++++++----
 src/engine/gl_main.h    |   1 +
 src/engine/gl_texture.c |  86 +++++++++++++++++++++----
 src/engine/gl_texture.h |   2 +
 src/engine/r_bsp.c      |   1 +
 src/engine/r_drawlist.c |  26 ++++++--
 src/engine/r_drawlist.h |   2 +-
 src/engine/r_lights.c   |   2 +
 src/engine/r_main.c     |  15 +++++
 src/engine/r_main.h     |   1 +
 src/engine/r_scene.c    |  97 +++++++++++++++++-----------
 src/engine/r_sky.c      | 136 +++++++++++++++++++++++-----------------
 src/engine/r_things.c   |  49 +++++++++++----
 src/engine/st_stuff.c   |  11 ++--
 17 files changed, 533 insertions(+), 155 deletions(-)

diff --git a/src/engine/am_draw.c b/src/engine/am_draw.c
index 494687e9..145ca038 100644
--- a/src/engine/am_draw.c
+++ b/src/engine/am_draw.c
@@ -47,6 +47,7 @@ static angle_t am_viewangle;
 
 CVAR_EXTERNAL(am_fulldraw);
 CVAR_EXTERNAL(am_ssect);
+CVAR_EXTERNAL(r_texturecombiner);
 
 //
 // AM_BeginDraw
@@ -55,6 +56,16 @@ CVAR_EXTERNAL(am_ssect);
 void AM_BeginDraw(angle_t view, fixed_t x, fixed_t y) {
 	am_viewangle = view;
 
+	    if(r_texturecombiner.value > 0 && am_overlay.value) {
+        GL_SetState(GLSTATE_BLEND, 1);
+
+        //
+        // increase the rgb scale so the automap can look good while transparent (overlay mode)
+        //
+        GL_SetTextureMode(GL_COMBINE);
+        dglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE, 4);
+    }
+
 	dglDepthRange(0.0f, 0.0f);
 	dglMatrixMode(GL_PROJECTION);
 	dglLoadIdentity();
@@ -77,10 +88,16 @@ void AM_BeginDraw(angle_t view, fixed_t x, fixed_t y) {
 //
 
 void AM_EndDraw(void) {
-	dglPopMatrix();
-	dglDepthRange(0.0f, 1.0f);
+    dglPopMatrix();
+    dglDepthRange(0.0f, 1.0f);
 
-	GL_SetDefaultCombiner();
+    if(r_texturecombiner.value > 0 && am_overlay.value) {
+        GL_SetState(GLSTATE_BLEND, 0);
+        GL_SetTextureMode(GL_COMBINE);
+        GL_SetColorScale();
+    }
+
+    GL_SetDefaultCombiner();
 }
 
 //
@@ -233,14 +250,24 @@ void AM_DrawLeafs(float scale) {
 	//
 	// process draw list
 	//
-	DL_BeginDrawList(!am_ssect.value && 1);
-
-	if (!nolights) {
-		GL_SetTextureMode(GL_MODULATE);
-	}
-	else {
-		GL_SetTextureMode(GL_REPLACE);
-	}
+    DL_BeginDrawList(!am_ssect.value && r_fillmode.value, 0);
+
+    if(r_texturecombiner.value > 0) {
+        if(!nolights) {
+            dglTexCombModulate(GL_TEXTURE0_ARB, GL_PRIMARY_COLOR);
+        }
+        else {
+            dglTexCombReplace();
+        }
+    }
+    else {
+        if(!nolights) {
+            GL_SetTextureMode(GL_MODULATE);
+        }
+        else {
+            GL_SetTextureMode(GL_REPLACE);
+        }
+    }
 
 	DL_ProcessDrawList(DLT_AMAP, DL_ProcessAutomap);
 }
@@ -314,7 +341,9 @@ void AM_DrawTriangle(mobj_t* mobj, float scale, boolean solid, byte r, byte g, b
 		return;
 	}
 
-	dglPolygonMode(GL_FRONT_AND_BACK, (solid == 1) ? GL_LINE : GL_FILL);
+    if(r_fillmode.value) {
+        dglPolygonMode(GL_FRONT_AND_BACK, (solid == 1) ? GL_LINE : GL_FILL);
+    }
 
 	dglSetVertex(tri);
 	RB_AddTriangle(0, 1, 2);
@@ -322,7 +351,9 @@ void AM_DrawTriangle(mobj_t* mobj, float scale, boolean solid, byte r, byte g, b
 	dglDrawGeometry(3, tri);
 	dglEnable(GL_TEXTURE_2D);
 
-	dglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+    if(r_fillmode.value) {
+        dglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+    }
 
 	if (devparm) {
 		vertCount += 3;
diff --git a/src/engine/dgl.c b/src/engine/dgl.c
index f23b588c..9583cb45 100644
--- a/src/engine/dgl.c
+++ b/src/engine/dgl.c
@@ -219,3 +219,124 @@ void dglGetColorf(rcolor color, float* argb) {
 	argb[1] = (float)((color >> 8) & 0xff) / 255.0f;
 	argb[0] = (float)(color & 0xff) / 255.0f;
 }
+
+//
+// dglTexCombReplace
+//
+
+void dglTexCombReplace(void) {
+#ifdef LOG_GLFUNC_CALLS
+	I_Printf("dglTexCombReplace\n");
+#endif
+	GL_SetTextureMode(GL_COMBINE_ARB);
+	GL_SetCombineState(GL_REPLACE);
+	GL_SetCombineSourceRGB(0, GL_TEXTURE);
+	GL_SetCombineOperandRGB(0, GL_SRC_COLOR);
+}
+
+//
+// dglTexCombColor
+//
+
+void dglTexCombColor(int t, rcolor c, int func) {
+	float f[4];
+#ifdef LOG_GLFUNC_CALLS
+	I_Printf("dglTexCombColor(t=0x%x, c=0x%x)\n", t, c);
+#endif
+	dglGetColorf(c, f);
+	GL_SetTextureMode(GL_COMBINE_ARB);
+	GL_SetEnvColor(f);
+	GL_SetCombineState(func);
+	GL_SetCombineSourceRGB(0, t);
+	GL_SetCombineOperandRGB(0, GL_SRC_COLOR);
+	GL_SetCombineSourceRGB(1, GL_CONSTANT);
+	GL_SetCombineOperandRGB(1, GL_SRC_COLOR);
+}
+
+//
+// dglTexCombColorf
+//
+
+void dglTexCombColorf(int t, float* f, int func) {
+#ifdef LOG_GLFUNC_CALLS
+	I_Printf("dglTexCombColorf(t=0x%x, f=%p)\n", t, f);
+#endif
+	GL_SetTextureMode(GL_COMBINE_ARB);
+	GL_SetEnvColor(f);
+	GL_SetCombineState(func);
+	GL_SetCombineSourceRGB(0, t);
+	GL_SetCombineOperandRGB(0, GL_SRC_COLOR);
+	GL_SetCombineSourceRGB(1, GL_CONSTANT);
+	GL_SetCombineOperandRGB(1, GL_SRC_COLOR);
+}
+
+//
+// dglTexCombModulate
+//
+
+void dglTexCombModulate(int t, int s) {
+#ifdef LOG_GLFUNC_CALLS
+	I_Printf("dglTexCombFinalize(t=0x%x)\n", t);
+#endif
+	GL_SetTextureMode(GL_COMBINE_ARB);
+	GL_SetCombineState(GL_MODULATE);
+	GL_SetCombineSourceRGB(0, t);
+	GL_SetCombineOperandRGB(0, GL_SRC_COLOR);
+	GL_SetCombineSourceRGB(1, s);
+	GL_SetCombineOperandRGB(1, GL_SRC_COLOR);
+}
+
+//
+// dglTexCombAdd
+//
+
+void dglTexCombAdd(int t, int s) {
+#ifdef LOG_GLFUNC_CALLS
+	I_Printf("dglTexCombFinalize(t=0x%x)\n", t);
+#endif
+	GL_SetTextureMode(GL_COMBINE_ARB);
+	GL_SetCombineState(GL_ADD);
+	GL_SetCombineSourceRGB(0, t);
+	GL_SetCombineOperandRGB(0, GL_SRC_COLOR);
+	GL_SetCombineSourceRGB(1, s);
+	GL_SetCombineOperandRGB(1, GL_SRC_COLOR);
+}
+
+//
+// dglTexCombInterpolate
+//
+
+void dglTexCombInterpolate(int t, float a) {
+	float f[4];
+#ifdef LOG_GLFUNC_CALLS
+	I_Printf("dglTexCombInterpolate(t=0x%x, a=%f)\n", t, a);
+#endif
+	f[0] = f[1] = f[2] = 0.0f;
+	f[3] = a;
+
+	GL_SetTextureMode(GL_COMBINE_ARB);
+	GL_SetCombineState(GL_INTERPOLATE);
+	GL_SetEnvColor(f);
+	GL_SetCombineSourceRGB(0, GL_TEXTURE);
+	GL_SetCombineOperandRGB(0, GL_SRC_COLOR);
+	GL_SetCombineSourceRGB(1, t);
+	GL_SetCombineOperandRGB(1, GL_SRC_COLOR);
+	GL_SetCombineSourceRGB(2, GL_CONSTANT);
+	GL_SetCombineOperandRGB(2, GL_SRC_ALPHA);
+}
+
+//
+// dglTexCombReplaceAlpha
+//
+
+void dglTexCombReplaceAlpha(int t) {
+#ifdef LOG_GLFUNC_CALLS
+	I_Printf("dglTexCombReplaceAlpha(t=0x%x)\n", t);
+#endif
+	GL_SetTextureMode(GL_COMBINE_ARB);
+	GL_SetCombineStateAlpha(GL_MODULATE);
+	GL_SetCombineSourceAlpha(0, t);
+	GL_SetCombineOperandAlpha(0, GL_SRC_ALPHA);
+	GL_SetCombineSourceAlpha(1, GL_PRIMARY_COLOR);
+	GL_SetCombineOperandAlpha(1, GL_SRC_ALPHA);
+}
diff --git a/src/engine/gl_draw.c b/src/engine/gl_draw.c
index ab36c539..ce3fb57c 100644
--- a/src/engine/gl_draw.c
+++ b/src/engine/gl_draw.c
@@ -133,6 +133,7 @@ int Draw_Text(int x, int y, rcolor color, float scale,
 	char msg[MAX_MESSAGE_SIZE];
 	va_list    va;
 	const int ix = x;
+	boolean fill = false;
 
 	va_start(va, string);
 	vsprintf(msg, string, va);
@@ -140,6 +141,13 @@ int Draw_Text(int x, int y, rcolor color, float scale,
 
 	GL_SetState(GLSTATE_BLEND, 1);
 
+	if(!r_fillmode.value) {
+        dglEnable(GL_TEXTURE_2D);
+        dglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+        r_fillmode.value = 1.0f;
+        fill = true;
+    }
+
 	GL_BindGfxTexture("SFONT", true);
 
 	dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, DGL_CLAMP);
@@ -214,6 +222,12 @@ int Draw_Text(int x, int y, rcolor color, float scale,
 
 	GL_ResetViewport();
 
+	if(fill) {
+        dglDisable(GL_TEXTURE_2D);
+        dglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+        r_fillmode.value = 0.0f;
+    }
+
 	GL_SetState(GLSTATE_BLEND, 0);
 	GL_SetOrthoScale(1.0f);
 
diff --git a/src/engine/gl_main.c b/src/engine/gl_main.c
index 0dab67ea..20b22de1 100644
--- a/src/engine/gl_main.c
+++ b/src/engine/gl_main.c
@@ -70,7 +70,9 @@ boolean    widescreen = false;
 CVAR_EXTERNAL(v_vsync);
 CVAR_EXTERNAL(r_filter);
 CVAR_EXTERNAL(r_anisotropic);
+CVAR_EXTERNAL(r_texturecombiner);
 CVAR_EXTERNAL(st_flashoverlay);
+CVAR_EXTERNAL(r_colorscale);
 
 //
 // CMD_DumpGLExtensions
@@ -98,6 +100,8 @@ static CMD(DumpGLExtensions) {
 
 GL_ARB_multitexture_Define();
 GL_EXT_texture_filter_anisotropic_Define();
+GL_ARB_texture_env_combine_Define();
+GL_EXT_texture_env_combine_Define();
 
 //
 // FindExtension
@@ -320,19 +324,41 @@ void GL_SetTextureFilter(void) {
 //
 
 void GL_SetDefaultCombiner(void) {
-	    if (!usingGL) {
-        return;
+    if(has_GL_ARB_multitexture) {
+        GL_SetTextureUnit(1, false);
+        GL_SetTextureUnit(2, false);
+        GL_SetTextureUnit(3, false);
+        GL_SetTextureUnit(0, true);
     }
-    
-	if (GL_ARB_multitexture) {
-		GL_SetTextureUnit(1, false);
-		GL_SetTextureUnit(2, false);
-		GL_SetTextureUnit(3, false);
-		GL_SetTextureUnit(0, true);
-	}
 
-	GL_CheckFillMode();
-	GL_SetTextureMode(GL_MODULATE);
+    GL_CheckFillMode();
+
+    if(r_texturecombiner.value > 0) {
+        dglTexCombModulate(GL_TEXTURE0_ARB, GL_PRIMARY_COLOR);
+    }
+    else {
+        GL_SetTextureMode(GL_MODULATE);
+    }
+}
+
+//
+// GL_SetColorScale
+//
+
+void GL_SetColorScale(void) {
+    int cs = (int)r_colorscale.value;
+
+    switch(cs) {
+        case 1:
+            dglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE, 2);
+            break;
+        case 2:
+            dglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE, 4);
+            break;
+        default:
+            dglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE, 1);
+            break;
+    }
 }
 
 //
@@ -449,7 +475,12 @@ void GL_SetState(int bit, boolean enable) {
 //
 
 void GL_CheckFillMode(void) {
-	GL_SetState(GLSTATE_TEXTURE0, 1);
+    if(r_fillmode.value <= 0) {
+        GL_SetState(GLSTATE_TEXTURE0, 0);
+    }
+    else if(r_fillmode.value > 0) {
+        GL_SetState(GLSTATE_TEXTURE0, 1);
+    }
 }
 
 //
@@ -533,13 +564,25 @@ void GL_Init(void) {
 	GL_SetTextureFilter();
 	GL_SetDefaultCombiner();
 
+	r_fillmode.value = 1.0f;
+
 	GL_ARB_multitexture_Init();
 	GL_EXT_texture_filter_anisotropic_Init();
+	GL_ARB_texture_env_combine_Init();
+    GL_EXT_texture_env_combine_Init();
 
 	if (!GL_ARB_multitexture) {
 		CON_Warnf("GL_ARB_multitexture not supported...\n");
 	}
 
+	gl_has_combiner = (has_GL_ARB_texture_env_combine | has_GL_EXT_texture_env_combine);
+
+    if (!gl_has_combiner) {
+        CON_Warnf("Texture combiners not supported...\n");
+        CON_Warnf("Setting r_texturecombiner to 0\n");
+        CON_CvarSetValue(r_texturecombiner.name, 0.0f);
+    }
+
 	dglEnableClientState(GL_VERTEX_ARRAY);
 	dglEnableClientState(GL_TEXTURE_COORD_ARRAY);
 	dglEnableClientState(GL_COLOR_ARRAY);
diff --git a/src/engine/gl_main.h b/src/engine/gl_main.h
index 6d8e1bd0..fa5cb66d 100644
--- a/src/engine/gl_main.h
+++ b/src/engine/gl_main.h
@@ -104,6 +104,7 @@ void GL_SetOrthoScale(float scale);
 float GL_GetOrthoScale(void);
 void GL_SetState(int bit, boolean enable);
 void GL_SetDefaultCombiner(void);
+void GL_SetColorScale(void);
 void GL_Set2DQuad(vtx_t* v, float x, float y, int width, int height,
 	float u1, float u2, float v1, float v2, rcolor c);
 void GL_Draw2DQuad(vtx_t* v, boolean stretch);
diff --git a/src/engine/gl_texture.c b/src/engine/gl_texture.c
index 4d0929f1..935b3a91 100644
--- a/src/engine/gl_texture.c
+++ b/src/engine/gl_texture.c
@@ -1,9 +1,8 @@
-// Emacs style mode select   -*- C -*-
+// Emacs style mode select   -*- C++ -*-
 //-----------------------------------------------------------------------------
 //
 // Copyright(C) 2007-2012 Samuel Villarreal
-// Copyright(C) 2022 André Gulherme
-// 
+//
 // This program is free software; you can redistribute it and/or
 // modify it under the terms of the GNU General Public License
 // as published by the Free Software Foundation; either version 2
@@ -25,7 +24,6 @@
 //
 //-----------------------------------------------------------------------------
 
-#include "gl_shader.h"
 #include "doomstat.h"
 #include "r_local.h"
 #include "i_png.h"
@@ -95,6 +93,17 @@ typedef struct {
 static gl_env_state_t gl_env_state[GL_MAX_TEX_UNITS];
 static int curunit = -1;
 
+CVAR_EXTERNAL(r_fillmode);
+CVAR_CMD(r_texturecombiner, 1) {
+	int i;
+
+	curunit = -1;
+
+	for (i = 0; i < GL_MAX_TEX_UNITS; i++) {
+		dmemset(&gl_env_state[i], 0, sizeof(gl_env_state_t));
+	}
+}
+
 //
 // CMD_DumpTextures
 //
@@ -166,6 +175,10 @@ void GL_BindWorldTexture(int texnum, int* width, int* height) {
 	int w;
 	int h;
 
+	if (r_fillmode.value <= 0) {
+		return;
+	}
+
 	// get translation index
 	texnum = texturetranslation[texnum];
 
@@ -197,8 +210,6 @@ void GL_BindWorldTexture(int texnum, int* width, int* height) {
 	png = I_PNGReadData(t_start + texnum, false, true, true,
 		&w, &h, NULL, palettetranslation[texnum]);
 
-	//GL_LoadShader("GLSL/D64EXPLUS.vert", "GLSL/D64EXPLUS.frag"); - crashes
-
 	dglGenTextures(1, &textureptr[texnum][palettetranslation[texnum]]);
 	dglBindTexture(GL_TEXTURE_2D, textureptr[texnum][palettetranslation[texnum]]);
 	dglTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, png);
@@ -230,6 +241,7 @@ void GL_BindWorldTexture(int texnum, int* width, int* height) {
 //
 // GL_SetNewPalette
 //
+
 void GL_SetNewPalette(int id, byte palID) {
 	palettetranslation[id] = palID;
 	/*if(textureptr[id])
@@ -271,10 +283,10 @@ static void InitGfxTextures(void) {
 	g_end = W_GetNumForName("MOUNTC");
 	numgfx = (g_end - g_start) + 1;
 	gfxptr = Z_Calloc(numgfx * sizeof(dtexture), PU_STATIC, NULL);
-	gfxwidth = Z_Calloc(numgfx * sizeof(short), PU_STATIC, NULL);
-	gfxorigwidth = Z_Calloc(numgfx * sizeof(short), PU_STATIC, NULL);
-	gfxheight = Z_Calloc(numgfx * sizeof(short), PU_STATIC, NULL);
-	gfxorigheight = Z_Calloc(numgfx * sizeof(short), PU_STATIC, NULL);
+	gfxwidth = Z_Calloc(numgfx * sizeof(int16_t), PU_STATIC, NULL);
+	gfxorigwidth = Z_Calloc(numgfx * sizeof(int16_t), PU_STATIC, NULL);
+	gfxheight = Z_Calloc(numgfx * sizeof(int16_t), PU_STATIC, NULL);
+	gfxorigheight = Z_Calloc(numgfx * sizeof(int16_t), PU_STATIC, NULL);
 
 	for (i = 0; i < numgfx; i++) {
 		byte* png;
@@ -401,7 +413,7 @@ static void InitSpriteTextures(void) {
 		byte* png;
 		int w;
 		int h;
-		unsigned int x;
+		size_t x;
 
 		// allocate # of sprites per pointer
 		spriteptr[i] = (dtexture*)Z_Malloc(spritecount[i] * sizeof(dtexture), PU_STATIC, 0);
@@ -432,6 +444,10 @@ void GL_BindSpriteTexture(int spritenum, int pal) {
 	int w;
 	int h;
 
+	if (r_fillmode.value <= 0) {
+		return;
+	}
+
 	if ((spritenum == cursprite) && (pal == curtrans)) {
 		return;
 	}
@@ -561,6 +577,10 @@ static dtexture envtexture = 0;
 void GL_BindEnvTexture(void) {
 	rcolor rgb[16];
 
+	if (r_fillmode.value <= 0) {
+		return;
+	}
+
 	dmemset(rgb, 0xff, sizeof(rcolor) * 16);
 
 	if (envtexture == 0) {
@@ -594,6 +614,10 @@ void GL_UpdateEnvTexture(rcolor color) {
 		return;
 	}
 
+	if (r_fillmode.value <= 0) {
+		return;
+	}
+
 	if (lastenvcolor == color) {
 		return;
 	}
@@ -648,6 +672,10 @@ void GL_SetTextureUnit(int unit, boolean enable) {
 		return;
 	}
 
+	if (r_fillmode.value <= 0) {
+		return;
+	}
+
 	if (unit > 3) {
 		return;
 	}
@@ -679,6 +707,40 @@ void GL_SetTextureMode(int mode) {
 	dglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, state->mode);
 }
 
+//
+// GL_SetCombineState
+//
+
+void GL_SetCombineState(int combine) {
+	gl_env_state_t* state;
+
+	state = &gl_env_state[curunit];
+
+	if (state->combine_rgb == combine) {
+		return;
+	}
+
+	state->combine_rgb = combine;
+	dglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, state->combine_rgb);
+}
+
+//
+// GL_SetCombineStateAlpha
+//
+
+void GL_SetCombineStateAlpha(int combine) {
+	gl_env_state_t* state;
+
+	state = &gl_env_state[curunit];
+
+	if (state->combine_alpha == combine) {
+		return;
+	}
+
+	state->combine_alpha = combine;
+	dglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, state->combine_alpha);
+}
+
 //
 // GL_SetEnvColor
 //
@@ -856,4 +918,4 @@ void GL_DumpTextures(void) {
 
 void GL_ResetTextures(void) {
 	curtexture = cursprite = curgfx = -1;
-}
+}
\ No newline at end of file
diff --git a/src/engine/gl_texture.h b/src/engine/gl_texture.h
index 98b67b47..493dec62 100644
--- a/src/engine/gl_texture.h
+++ b/src/engine/gl_texture.h
@@ -63,6 +63,8 @@ void        GL_InitTextures(void);
 void        GL_UnloadTexture(dtexture* texture);
 void        GL_SetTextureUnit(int unit, boolean enable);
 void        GL_SetTextureMode(int mode);
+void        GL_SetCombineState(int combine);
+void        GL_SetCombineStateAlpha(int combine);
 void        GL_SetEnvColor(float* param);
 void        GL_SetCombineSourceRGB(int source, int target);
 void        GL_SetCombineSourceAlpha(int source, int target);
diff --git a/src/engine/r_bsp.c b/src/engine/r_bsp.c
index d61f0ad0..5fc7c4ed 100644
--- a/src/engine/r_bsp.c
+++ b/src/engine/r_bsp.c
@@ -49,6 +49,7 @@ static void R_AddLine(seg_t* line);
 static void AddSegToDrawlist(drawlist_t* dl, seg_t* line, int texid, int sidetype);
 
 CVAR_EXTERNAL(i_interpolateframes);
+CVAR_EXTERNAL(r_texturecombiner);
 
 //
 // R_AddClipLine
diff --git a/src/engine/r_drawlist.c b/src/engine/r_drawlist.c
index 652ba36d..fb56adef 100644
--- a/src/engine/r_drawlist.c
+++ b/src/engine/r_drawlist.c
@@ -41,6 +41,8 @@ static float envcolor[4] = { 0, 0, 0, 0 };
 
 drawlist_t drawlist[NUMDRAWLISTS];
 
+CVAR_EXTERNAL(r_texturecombiner);
+
 //
 // DL_AddVertexList
 //
@@ -186,11 +188,18 @@ void DL_ProcessDrawList(int tag, boolean(*procfunc)(vtxlist_t*, int*)) {
 				dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
 					head->flags & DLF_MIRRORT ? GL_MIRRORED_REPEAT : GL_REPEAT);
 			}
+			
+            if(r_texturecombiner.value > 0) {
+                envcolor[0] = envcolor[1] = envcolor[2] = ((float)head->params / 255.0f);
+                GL_SetEnvColor(envcolor);
+            }
+            else {
+                int l = (head->params >> 1);
 
-			int l = (head->params >> 1);
+                GL_UpdateEnvTexture(D_RGBA(l, l, l, 0xff));
+            }
 
-			GL_UpdateEnvTexture(D_RGBA(l, l, l, 0xff));
-			dglDrawGeometry(drawcount, drawVertex);
+            dglDrawGeometry(drawcount, drawVertex);
 
 			// count vertex size
 			if (devparm) {
@@ -228,9 +237,14 @@ int DL_GetDrawListSize(int tag) {
 // DL_BeginDrawList
 //
 
-void DL_BeginDrawList(boolean t) {
-	dglSetVertex(drawVertex);
-	GL_SetTextureUnit(0, t);
+void DL_BeginDrawList(boolean t, boolean a) {
+    dglSetVertex(drawVertex);
+
+    GL_SetTextureUnit(0, t);
+
+    if(a) {
+        dglTexCombColorf(GL_TEXTURE0_ARB, envcolor, GL_ADD);
+    }
 }
 
 //
diff --git a/src/engine/r_drawlist.h b/src/engine/r_drawlist.h
index 82e8b95e..90221f1b 100644
--- a/src/engine/r_drawlist.h
+++ b/src/engine/r_drawlist.h
@@ -70,7 +70,7 @@ boolean DL_ProcessSprites(vtxlist_t* vl, int* drawcount);
 
 vtxlist_t* DL_AddVertexList(drawlist_t* dl);
 int DL_GetDrawListSize(int tag);
-void DL_BeginDrawList(boolean t);
+void DL_BeginDrawList(boolean t, boolean a);
 void DL_ProcessDrawList(int tag, boolean(*procfunc)(vtxlist_t*, int*));
 void DL_RenderDrawList(void);
 void DL_Init(void);
diff --git a/src/engine/r_lights.c b/src/engine/r_lights.c
index 48cc6f5e..4b0cef1c 100644
--- a/src/engine/r_lights.c
+++ b/src/engine/r_lights.c
@@ -39,6 +39,8 @@ CVAR_CMD(i_brightness, 100) {
 	R_RefreshBrightness();
 }
 
+CVAR_EXTERNAL(r_texturecombiner);
+
 //
 // R_LightToVertex
 //
diff --git a/src/engine/r_main.c b/src/engine/r_main.c
index 48a8095c..d1d3c81c 100644
--- a/src/engine/r_main.c
+++ b/src/engine/r_main.c
@@ -81,12 +81,18 @@ unsigned int    glBindCalls = 0;
 boolean        bRenderSky = false;
 
 CVAR(r_fov, 74.0);
+CVAR(r_fillmode, 1);
 CVAR(r_fog, 1);
 CVAR(r_wipe, 1);
 CVAR(r_drawmobjbox, 0);
+CVAR(r_rendersprites, 1);
 CVAR(r_skybox, 0);
 CVAR(hud_disablesecretmessages, 0);
 
+CVAR_CMD(r_colorscale, 0) {
+    GL_SetColorScale();
+}
+
 CVAR_CMD(r_filter, 0) {
 	GL_DumpTextures();
 	GL_SetTextureFilter();
@@ -97,6 +103,7 @@ CVAR_CMD(r_anisotropic, 0) {
 	GL_SetTextureFilter();
 }
 
+CVAR_EXTERNAL(r_texturecombiner);
 CVAR_EXTERNAL(i_interpolateframes);
 CVAR_EXTERNAL(p_usecontext);
 
@@ -681,6 +688,10 @@ static void R_DrawContextWall(line_t* line) {
 
 void R_RenderPlayerView(player_t* player) {
 
+    if(!r_fillmode.value) {
+        dglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+    }
+
 	if (devparm) {
 		renderTic = I_GetTimeMS();
 	}
@@ -781,11 +792,15 @@ void R_RenderPlayerView(player_t* player) {
 
 void R_RegisterCvars(void) {
 	CON_CvarRegister(&r_fov);
+    CON_CvarRegister(&r_fillmode);
 	CON_CvarRegister(&r_fog);
 	CON_CvarRegister(&r_filter);
 	CON_CvarRegister(&r_anisotropic);
 	CON_CvarRegister(&r_wipe);
 	CON_CvarRegister(&r_drawmobjbox);
+    CON_CvarRegister(&r_rendersprites);
 	CON_CvarRegister(&r_skybox);
+	CON_CvarRegister(&r_colorscale);
+	CON_CvarRegister(&r_texturecombiner);
 	CON_CvarRegister(&hud_disablesecretmessages);
 }
diff --git a/src/engine/r_main.h b/src/engine/r_main.h
index e4e5f73c..930aebcc 100644
--- a/src/engine/r_main.h
+++ b/src/engine/r_main.h
@@ -59,6 +59,7 @@ extern unsigned int glBindCalls;
 extern boolean     bRenderSky;
 
 CVAR_EXTERNAL(r_fov);
+CVAR_EXTERNAL(r_fillmode);
 
 void R_Init(void);
 void R_RenderPlayerView(player_t* player);
diff --git a/src/engine/r_scene.c b/src/engine/r_scene.c
index 65b59def..ece679be 100644
--- a/src/engine/r_scene.c
+++ b/src/engine/r_scene.c
@@ -32,8 +32,10 @@
 #include "r_sky.h"
 #include "r_drawlist.h"
 
+CVAR_EXTERNAL(r_texturecombiner);
 CVAR_EXTERNAL(i_interpolateframes);
 CVAR_EXTERNAL(r_fog);
+CVAR_EXTERNAL(r_rendersprites);
 CVAR_EXTERNAL(st_flashoverlay);
 
 //
@@ -208,6 +210,11 @@ static boolean ProcessSprites(vtxlist_t* vl, int* drawcount) {
 static void SetupFog(void) {
 	dglFogi(GL_FOG_MODE, GL_LINEAR);
 
+    // don't render fog in wireframe mode
+    if(r_fillmode.value <= 0) {
+        return;
+    }
+
 	if (!skyflatnum) {
 		dglDisable(GL_FOG);
 	}
@@ -286,59 +293,77 @@ void R_SetViewMatrix(void) {
 //
 
 void R_RenderWorld(void) {
-	SetupFog();
+    SetupFog();
 
-	dglEnable(GL_DEPTH_TEST);
+    dglEnable(GL_DEPTH_TEST);
 
-	DL_BeginDrawList(1);
+    DL_BeginDrawList(r_fillmode.value >= 1, r_texturecombiner.value >= 1);
 
-	// setup texture environment for effects
+    // setup texture environment for effects
+    if(r_texturecombiner.value) {
+        if(!nolights) {
+            GL_UpdateEnvTexture(WHITE);
+            GL_SetTextureUnit(1, true);
+            dglTexCombModulate(GL_PREVIOUS, GL_PRIMARY_COLOR);
+        }
 
-	GL_SetTextureUnit(1, true);
-	GL_SetTextureMode(GL_ADD);
-	GL_SetTextureUnit(0, true);
+        if(st_flashoverlay.value <= 0) {
+            GL_SetTextureUnit(2, true);
+            dglTexCombColor(GL_PREVIOUS, flashcolor, GL_ADD);
+        }
 
-	if (nolights)
-	{
-		GL_SetTextureMode(GL_REPLACE);
-	}
+        dglTexCombReplaceAlpha(GL_TEXTURE0_ARB);
 
-	dglEnable(GL_ALPHA_TEST);
+        GL_SetTextureUnit(0, true);
+    }
+    else {
+        GL_SetTextureUnit(1, true);
+        GL_SetTextureMode(GL_ADD);
+        GL_SetTextureUnit(0, true);
 
-	// begin draw list loop
+        if(nolights) {
+            GL_SetTextureMode(GL_REPLACE);
+        }
+    }
 
-	// -------------- Draw walls (segs) --------------------------
+    dglEnable(GL_ALPHA_TEST);
 
-	DL_ProcessDrawList(DLT_WALL, ProcessWalls);
+    // begin draw list loop
 
-	// -------------- Draw floors/ceilings (leafs) ---------------
+    // -------------- Draw walls (segs) --------------------------
 
-	GL_SetState(GLSTATE_BLEND, 1);
-	DL_ProcessDrawList(DLT_FLAT, ProcessFlats);
+    DL_ProcessDrawList(DLT_WALL, ProcessWalls);
 
-	// -------------- Draw things (sprites) ----------------------
+    // -------------- Draw floors/ceilings (leafs) ---------------
 
-	if (devparm) {
-		spriteRenderTic = I_GetTimeMS();
-	}
+    GL_SetState(GLSTATE_BLEND, 1);
+    DL_ProcessDrawList(DLT_FLAT, ProcessFlats);
+
+    // -------------- Draw things (sprites) ----------------------
+
+    if(devparm) {
+        spriteRenderTic = I_GetTimeMS();
+    }
 
-	R_SetupSprites();
+    if(r_rendersprites.value) {
+        R_SetupSprites();
+    }
 
-	dglDepthMask(GL_FALSE);
-	DL_ProcessDrawList(DLT_SPRITE, ProcessSprites);
+    dglDepthMask(GL_FALSE);
+    DL_ProcessDrawList(DLT_SPRITE, ProcessSprites);
 
-	// -------------- Restore states -----------------------------
+    // -------------- Restore states -----------------------------
 
-	dglDisable(GL_ALPHA_TEST);
-	dglDepthMask(GL_TRUE);
-	dglDisable(GL_FOG);
-	dglDisable(GL_DEPTH_TEST);
+    dglDisable(GL_ALPHA_TEST);
+    dglDepthMask(GL_TRUE);
+    dglDisable(GL_FOG);
+    dglDisable(GL_DEPTH_TEST);
 
-	GL_SetOrthoScale(1.0f);
-	GL_SetState(GLSTATE_BLEND, 0);
-	GL_SetState(GLSTATE_CULL, 1);
-	GL_SetDefaultCombiner();
+    GL_SetOrthoScale(1.0f);
+    GL_SetState(GLSTATE_BLEND, 0);
+    GL_SetState(GLSTATE_CULL, 1);
+    GL_SetDefaultCombiner();
 
-	// villsa 12152013 - make sure we're using the default blend function
-	dglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    // villsa 12152013 - make sure we're using the default blend function
+    dglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 }
diff --git a/src/engine/r_sky.c b/src/engine/r_sky.c
index 07792b3c..34bb93fa 100644
--- a/src/engine/r_sky.c
+++ b/src/engine/r_sky.c
@@ -64,6 +64,7 @@ static float sky_cloudpan2 = 0;
 #define FIRESKY_WIDTH   64
 #define FIRESKY_HEIGHT  64
 
+CVAR_EXTERNAL(r_texturecombiner);
 CVAR_EXTERNAL(r_skybox);
 
 #define SKYVIEWPOS(angle, amount, x) x = -(angle / (float)ANG90 * amount); while(x < 1.0f) x += 1.0f
@@ -494,64 +495,83 @@ static void R_DrawTitleSky(void) {
 //
 
 static void R_DrawClouds(void) {
-	rfloat pos = 0.0f;
-	vtx_t v[4];
-
-	GL_SetTextureUnit(0, true);
-	GL_BindGfxTexture(lumpinfo[skypicnum].name, false);
-
-	pos = (TRUEANGLES(viewangle) / 360.0f) * 2.0f;
-
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-
-	dglSetVertex(v);
-
-	GL_Set2DQuad(v, 0, 0, SCREENWIDTH, 120, 0, 0, 0, 0, 0);
-	dglSetVertexColor(&v[0], sky->skycolor[0], 2);
-	dglSetVertexColor(&v[2], sky->skycolor[1], 2);
-
-	glDisable(GL_TEXTURE_2D);
-
-	GL_Draw2DQuad(v, true);
-
-	glEnable(GL_TEXTURE_2D);
-
-	GL_SetTextureUnit(1, true);
-	GL_SetTextureMode(GL_ADD);
-	GL_UpdateEnvTexture(sky->skycolor[1]);
-	GL_SetTextureUnit(0, true);
-
-	dglSetVertexColor(&v[0], sky->skycolor[2], 4);
-	v[0].a = v[1].a = v[2].a = v[3].a = 0x60;
-
-	v[3].x = v[1].x = 1.1025f;
-	v[0].x = v[2].x = -1.1025f;
-	v[2].y = v[3].y = 0;
-	v[0].y = v[1].y = 0.4315f;
-	v[0].z = v[1].z = 0;
-	v[2].z = v[3].z = -1.0f;
-	v[0].tu = v[2].tu = F2D3D(CloudOffsetX) - pos;
-	v[1].tu = v[3].tu = (F2D3D(CloudOffsetX) + 1.5f) - pos;
-	v[0].tv = v[1].tv = F2D3D(CloudOffsetY);
-	v[2].tv = v[3].tv = F2D3D(CloudOffsetY) + 2.0f;
-
-	GL_SetOrthoScale(1.0f); // force ortho mode to be set
-
-	glMatrixMode(GL_PROJECTION);
-	glLoadIdentity();
-	dglViewFrustum(SCREENWIDTH, SCREENHEIGHT, 45.0f, 0.1f);
-	glMatrixMode(GL_MODELVIEW);
-	glEnable(GL_ALPHA);
-	glPushMatrix();
-	glTranslated(0.0f, 0.0f, -1.0f);
-	RB_AddTriangle(0, 1, 2);
-	RB_AddTriangle(3, 2, 1);
-	dglDrawGeometry(4, v);
-	glPopMatrix();
-	glDisable(GL_ALPHA);
-
-	GL_SetDefaultCombiner();
+    rfloat pos = 0.0f;
+    vtx_t v[4];
+
+    GL_SetTextureUnit(0, true);
+    GL_BindGfxTexture(lumpinfo[skypicnum].name, false);
+
+    pos = (TRUEANGLES(viewangle) / 360.0f) * 2.0f;
+
+    dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+    dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+
+    dglSetVertex(v);
+
+    if(r_texturecombiner.value > 0 && gl_max_texture_units > 2) {
+        dglSetVertexColor(&v[0], sky->skycolor[0], 2);
+        dglSetVertexColor(&v[2], sky->skycolor[1], 2);
+
+        GL_UpdateEnvTexture(WHITE);
+
+        // pass 1: texture * skycolor
+        dglTexCombColor(GL_TEXTURE, sky->skycolor[2], GL_MODULATE);
+
+        // pass 2: result * const (though the original game uses the texture's alpha)
+        GL_SetTextureUnit(1, true);
+        dglTexCombColor(GL_PREVIOUS, 0xFF909090, GL_MODULATE);
+
+        // pass 3: result + fragment color
+        GL_SetTextureUnit(2, true);
+        dglTexCombAdd(GL_PREVIOUS, GL_PRIMARY_COLOR);
+    }
+    else {
+        GL_Set2DQuad(v, 0, 0, SCREENWIDTH, 120, 0, 0, 0, 0, 0);
+        dglSetVertexColor(&v[0], sky->skycolor[0], 2);
+        dglSetVertexColor(&v[2], sky->skycolor[1], 2);
+
+        dglDisable(GL_TEXTURE_2D);
+
+        GL_Draw2DQuad(v, true);
+
+        dglEnable(GL_TEXTURE_2D);
+
+        GL_SetTextureUnit(1, true);
+        GL_SetTextureMode(GL_ADD);
+        GL_UpdateEnvTexture(sky->skycolor[1]);
+        GL_SetTextureUnit(0, true);
+
+        dglSetVertexColor(&v[0], sky->skycolor[2], 4);
+        v[0].a = v[1].a = v[2].a = v[3].a = 0x60;
+    }
+
+    v[3].x = v[1].x = 1.1025f;
+    v[0].x = v[2].x = -1.1025f;
+    v[2].y = v[3].y = 0;
+    v[0].y = v[1].y = 0.4315f;
+    v[0].z = v[1].z = 0;
+    v[2].z = v[3].z = -1.0f;
+    v[0].tu = v[2].tu = F2D3D(CloudOffsetX) - pos;
+    v[1].tu = v[3].tu = (F2D3D(CloudOffsetX) + 1.5f) - pos;
+    v[0].tv = v[1].tv = F2D3D(CloudOffsetY);
+    v[2].tv = v[3].tv = F2D3D(CloudOffsetY) + 2.0f;
+
+    GL_SetOrthoScale(1.0f); // force ortho mode to be set
+
+    dglMatrixMode(GL_PROJECTION);
+    dglLoadIdentity();
+    dglViewFrustum(SCREENWIDTH, SCREENHEIGHT, 45.0f, 0.1f);
+    dglMatrixMode(GL_MODELVIEW);
+    dglEnable(GL_BLEND);
+    dglPushMatrix();
+    dglTranslated(0.0f, 0.0f, -1.0f);
+    RB_AddTriangle(0, 1, 2);
+    RB_AddTriangle(3, 2, 1);
+    dglDrawGeometry(4, v);
+    dglPopMatrix();
+    dglDisable(GL_BLEND);
+
+    GL_SetDefaultCombiner();
 }
 
 //
diff --git a/src/engine/r_things.c b/src/engine/r_things.c
index 6a7376b5..4b614263 100644
--- a/src/engine/r_things.c
+++ b/src/engine/r_things.c
@@ -55,9 +55,11 @@ char* spritename;
 static visspritelist_t visspritelist[MAX_SPRITES];
 static visspritelist_t* vissprite = NULL;
 
+CVAR_EXTERNAL(r_texturecombiner);
 CVAR_EXTERNAL(st_flashoverlay);
 CVAR_EXTERNAL(i_interpolateframes);
 CVAR_EXTERNAL(v_accessibility);
+CVAR_EXTERNAL(r_rendersprites);
 
 static void AddSpriteDrawlist(drawlist_t* dl, visspritelist_t* vis, int texid);
 
@@ -638,20 +640,43 @@ void R_DrawPSprite(pspdef_t* psp, sector_t* sector, player_t* player) {
 	GL_SetTextureUnit(0, true);
 	GL_CheckFillMode();
 
-	//
-	// setup texture environment for effects
-	//
-	int lightlevel = (sector->lightlevel + 64); // haleyjd: slightly brighter
+    //
+    // setup texture environment for effects
+    //
+    if(r_texturecombiner.value) {
+        float f[4];
 
-	if (lightlevel > 0xff)
-	{
-		GL_SetTextureMode(GL_BLEND);
-	}
+        f[0] = f[1] = f[2] = ((float)sector->lightlevel / 255.0f);
 
-	if (nolights)
-	{
-		GL_SetTextureMode(GL_REPLACE);
-	}
+        dglTexCombColorf(GL_TEXTURE0_ARB, f, GL_ADD);
+
+        if(!nolights) {
+            GL_UpdateEnvTexture(WHITE);
+            GL_SetTextureUnit(1, true);
+            dglTexCombModulate(GL_PREVIOUS, GL_PRIMARY_COLOR);
+        }
+
+        if(st_flashoverlay.value <= 0) {
+            GL_SetTextureUnit(2, true);
+            dglTexCombColor(GL_PREVIOUS, flashcolor, GL_ADD);
+        }
+
+        dglTexCombReplaceAlpha(GL_TEXTURE0_ARB);
+
+        GL_SetTextureUnit(0, true);
+    }
+    else {
+        int l = (sector->lightlevel >> 1);
+
+        GL_SetTextureUnit(1, true);
+        GL_SetTextureMode(GL_ADD);
+        GL_UpdateEnvTexture(D_RGBA(l, l, l, 0xff));
+        GL_SetTextureUnit(0, true);
+
+        if(nolights) {
+            GL_SetTextureMode(GL_REPLACE);
+        }
+    }
 
 	// render
 	dglSetVertex(v);
diff --git a/src/engine/st_stuff.c b/src/engine/st_stuff.c
index c448ff3b..b26e77a0 100644
--- a/src/engine/st_stuff.c
+++ b/src/engine/st_stuff.c
@@ -70,6 +70,7 @@ CVAR(st_hud_color, 0);
 CVAR_EXTERNAL(p_usecontext);
 CVAR_EXTERNAL(p_damageindicator);
 CVAR_EXTERNAL(v_accessibility);
+CVAR_EXTERNAL(r_texturecombiner);
 
 //
 // STATUS BAR DATA
@@ -742,11 +743,11 @@ void ST_Drawer(void) {
 	// flash overlay
 	//
 
-	if ((st_flashoverlay.value ||
-		gl_max_texture_units <= 2 ||
-		flashcolor)) {
-		ST_FlashingScreen(st_flash_r, st_flash_g, st_flash_b, st_flash_a);
-	}
+    if((st_flashoverlay.value ||
+            gl_max_texture_units <= 2 ||
+            r_texturecombiner.value <= 0) && flashcolor) {
+        ST_FlashingScreen(st_flash_r, st_flash_g, st_flash_b, st_flash_a);
+    }
 
 	if (iwadDemo) {
 		return;

From 05cc283bb8d2b9f708e7030125cbfde5446ec564 Mon Sep 17 00:00:00 2001
From: atsb <atsb@atsb>
Date: Tue, 28 Mar 2023 09:38:13 +0200
Subject: [PATCH 2/2] adding a fixed texture combiner

---
 doom64ex-plus.wad    | Bin 3810577 -> 3814795 bytes
 src/engine/gl_main.c | 651 ++++++++++++++++++++++++-------------------
 2 files changed, 362 insertions(+), 289 deletions(-)

diff --git a/doom64ex-plus.wad b/doom64ex-plus.wad
index e83a14639f48a6e3a6a9b37b154b02cea0df6cb7..393d4e404a5566d4c1b6c0d73d2782c72b5705e0 100644
GIT binary patch
delta 11772
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
N{veC@JMrJW{~L*`9-ROH

delta 9970
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
XNHBfLF^5$Dp-ufUiBCoNpWOZ*DU{Mq

diff --git a/src/engine/gl_main.c b/src/engine/gl_main.c
index 20b22de1..ae78af8e 100644
--- a/src/engine/gl_main.c
+++ b/src/engine/gl_main.c
@@ -45,20 +45,19 @@
 #include "con_console.h"
 #include "m_misc.h"
 #include "g_actions.h"
-#include "i_sdlinput.h"
 
 int ViewWindowX = 0;
 int ViewWindowY = 0;
-int ViewWidth = 0;
-int ViewHeight = 0;
+int ViewWidth   = 0;
+int ViewHeight  = 0;
 
 int gl_max_texture_units;
 int gl_max_texture_size;
 boolean gl_has_combiner;
 
-const char* gl_vendor;
-const char* gl_renderer;
-const char* gl_version;
+const char *gl_vendor;
+const char *gl_renderer;
+const char *gl_version;
 
 static float glScaleFactor = 1.0f;
 
@@ -69,8 +68,8 @@ boolean    widescreen = false;
 
 CVAR_EXTERNAL(v_vsync);
 CVAR_EXTERNAL(r_filter);
-CVAR_EXTERNAL(r_anisotropic);
 CVAR_EXTERNAL(r_texturecombiner);
+CVAR_EXTERNAL(r_anisotropic);
 CVAR_EXTERNAL(st_flashoverlay);
 CVAR_EXTERNAL(r_colorscale);
 
@@ -79,93 +78,98 @@ CVAR_EXTERNAL(r_colorscale);
 //
 
 static CMD(DumpGLExtensions) {
-	char* string;
-	int i = 0;
-	int len = 0;
+    char *string;
+    int i = 0;
+    int len = 0;
 
-	string = (char*)dglGetString(GL_EXTENSIONS);
-	len = dstrlen(string);
+    string = (char*)dglGetString(GL_EXTENSIONS);
+    len = dstrlen(string);
 
-	for (i = 0; i < len; i++) {
-		if (string[i] == 0x20) {
-			string[i] = '\n';
-		}
-	}
+    for(i = 0; i < len; i++) {
+        if(string[i] == 0x20) {
+            string[i] = '\n';
+        }
+    }
 
-	M_WriteTextFile("GL_EXTENSIONS.TXT", string, len);
-	CON_Printf(WHITE, "Written GL_EXTENSIONS.TXT\n");
+    M_WriteTextFile("GL_EXTENSIONS.TXT", string, len);
+    CON_Printf(WHITE, "Written GL_EXTENSIONS.TXT\n");
 }
 
 // ======================== OGL Extensions ===================================
 
 GL_ARB_multitexture_Define();
-GL_EXT_texture_filter_anisotropic_Define();
+//GL_EXT_compiled_vertex_array_Define();
+//GL_EXT_multi_draw_arrays_Define();
+//GL_EXT_fog_coord_Define();
+//GL_ARB_vertex_buffer_object_Define();
+//GL_ARB_texture_non_power_of_two_Define();
 GL_ARB_texture_env_combine_Define();
 GL_EXT_texture_env_combine_Define();
+GL_EXT_texture_filter_anisotropic_Define();
 
 //
 // FindExtension
 //
 
-static boolean FindExtension(const char* ext) {
-	const char* extensions = NULL;
-	const char* start;
-	const char* where, * terminator;
-
-	// Extension names should not have spaces.
-	where = strrchr(ext, ' ');
-	if (where || *ext == '\0') {
-		return 0;
-	}
-
-	extensions = dglGetString(GL_EXTENSIONS);
-
-	start = extensions;
-	for (;;) {
-		where = strstr(start, ext);
-		if (!where) {
-			break;
-		}
-		terminator = where + dstrlen(ext);
-		if (where == start || *(where - 1) == ' ') {
-			if (*terminator == ' ' || *terminator == '\0') {
-				return true;
-			}
-			start = terminator;
-		}
-	}
-	return false;
+static boolean FindExtension(const char *ext) {
+    const char *extensions = NULL;
+    const char *start;
+    const char *where, *terminator;
+
+    // Extension names should not have spaces.
+    where = strrchr(ext, ' ');
+    if(where || *ext == '\0') {
+        return 0;
+    }
+
+    extensions = dglGetString(GL_EXTENSIONS);
+
+    start = extensions;
+    for(;;) {
+        where = strstr(start, ext);
+        if(!where) {
+            break;
+        }
+        terminator = where + dstrlen(ext);
+        if(where == start || *(where - 1) == ' ') {
+            if(*terminator == ' ' || *terminator == '\0') {
+                return true;
+            }
+            start = terminator;
+        }
+    }
+    return false;
 }
 
 //
 // GL_CheckExtension
 //
 
-boolean GL_CheckExtension(const char* ext) {
-	if (FindExtension(ext)) {
-		CON_Printf(WHITE, "GL Extension: %s = true\n", ext);
-		return true;
-	}
-	else {
-		CON_Printf(YELLOW, "GL Extension: %s = false\n", ext);
-	}
+boolean GL_CheckExtension(const char *ext) {
+    if(FindExtension(ext)) {
+        CON_Printf(WHITE, "GL Extension: %s = true\n", ext);
+        return true;
+    }
+    else {
+        CON_Printf(YELLOW, "GL Extension: %s = false\n", ext);
+    }
 
-	return false;
+    return false;
 }
 
 //
 // GL_RegisterProc
 //
 
-void* GL_RegisterProc(const char* address) {
-	void* proc = SDL_GL_GetProcAddress(address);
+void* GL_RegisterProc(const char *address) {
+    void *proc = SDL_GL_GetProcAddress(address);
 
-	if (!proc) {
-		CON_Warnf("GL_RegisterProc: Failed to get proc address: %s", address);
-		return NULL;
-	}
+    if(!proc) {
+        CON_Warnf("GL_RegisterProc: Failed to get proc address: %s", address);
+        return NULL;
+    }
 
-	return proc;
+    return proc;
 }
 
 //
@@ -175,44 +179,44 @@ void* GL_RegisterProc(const char* address) {
 static byte checkortho = 0;
 
 void GL_SetOrtho(boolean stretch) {
-	float width;
-	float height;
-
-	if (checkortho) {
-		if (widescreen) {
-			if (stretch && checkortho == 2) {
-				return;
-			}
-		}
-		else {
-			return;
-		}
-	}
-
-	dglMatrixMode(GL_MODELVIEW);
-	dglLoadIdentity();
-	dglMatrixMode(GL_PROJECTION);
-	dglLoadIdentity();
-
-	if (widescreen && !stretch) {
-		const float ratio = (4.0f / 3.0f);
-		float fitwidth = ViewHeight * ratio;
-		float fitx = (ViewWidth - fitwidth) / 2.0f;
-
-		dglViewport(ViewWindowX + (int)fitx, ViewWindowY, (int)fitwidth, ViewHeight);
-	}
+    float width;
+    float height;
+
+    if(checkortho) {
+        if(widescreen) {
+            if(stretch && checkortho == 2) {
+                return;
+            }
+        }
+        else {
+            return;
+        }
+    }
+
+    dglMatrixMode(GL_MODELVIEW);
+    dglLoadIdentity();
+    dglMatrixMode(GL_PROJECTION);
+    dglLoadIdentity();
+
+    if(widescreen && !stretch) {
+        const float ratio = (4.0f / 3.0f);
+        float fitwidth = ViewHeight * ratio;
+        float fitx = (ViewWidth - fitwidth) / 2.0f;
+
+        dglViewport(ViewWindowX + (int)fitx, ViewWindowY, (int)fitwidth, ViewHeight);
+    }
 
 	width = SCREENWIDTH & (int)~3;
 	height = SCREENHEIGHT;
 
-	if (glScaleFactor != 1.0f) {
-		width /= glScaleFactor;
-		height /= glScaleFactor;
-	}
+    if(glScaleFactor != 1.0f) {
+        width /= glScaleFactor;
+        height /= glScaleFactor;
+    }
 
-	dglOrtho(0, width, height, 0, -1, 1);
+    dglOrtho(0, width, height, 0, -1, 1);
 
-	checkortho = (stretch && widescreen) ? 2 : 1;
+    checkortho = (stretch && widescreen) ? 2 : 1;
 }
 
 //
@@ -220,9 +224,9 @@ void GL_SetOrtho(boolean stretch) {
 //
 
 void GL_ResetViewport(void) {
-	if (widescreen) {
-		dglViewport(ViewWindowX, ViewWindowY, ViewWidth, ViewHeight);
-	}
+    if(widescreen) {
+        dglViewport(ViewWindowX, ViewWindowY, ViewWidth, ViewHeight);
+    }
 }
 
 //
@@ -230,8 +234,8 @@ void GL_ResetViewport(void) {
 //
 
 void GL_SetOrthoScale(float scale) {
-	glScaleFactor = scale;
-	checkortho = 0;
+    glScaleFactor = scale;
+    checkortho = 0;
 }
 
 //
@@ -239,7 +243,7 @@ void GL_SetOrthoScale(float scale) {
 //
 
 float GL_GetOrthoScale(void) {
-	return glScaleFactor;
+    return glScaleFactor;
 }
 
 //
@@ -247,7 +251,7 @@ float GL_GetOrthoScale(void) {
 //
 
 void GL_SwapBuffers(void) {
-	I_FinishUpdate();
+    I_FinishUpdate();
 }
 
 //
@@ -255,46 +259,46 @@ void GL_SwapBuffers(void) {
 //
 
 byte* GL_GetScreenBuffer(int x, int y, int width, int height) {
-	byte* buffer;
-	byte* data;
-	int i;
-	int j;
-	int offset1;
-	int offset2;
-	int pack;
-	int col;
-
-	col = (width * 3);
-	data = (byte*)Z_Calloc(height * width * 3, PU_STATIC, 0);
-	buffer = (byte*)Z_Calloc(col, PU_STATIC, 0);
-
-	//
-	// 20120313 villsa - force pack alignment to 1
-	//
-	dglGetIntegerv(GL_PACK_ALIGNMENT, &pack);
-	dglPixelStorei(GL_PACK_ALIGNMENT, 1);
-	dglFlush();
-	dglReadPixels(x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, data);
-	dglPixelStorei(GL_PACK_ALIGNMENT, pack);
-
-	//
-	// Need to vertically flip the image
-	// 20120313 villsa - better method to flip image. uses one buffer instead of two
-	//
-	for (i = 0; i < height / 2; i++) {
-		for (j = 0; j < col; j++) {
-			offset1 = (i * col) + j;
-			offset2 = ((height - (i + 1)) * col) + j;
-
-			buffer[j] = data[offset1];
-			data[offset1] = data[offset2];
-			data[offset2] = buffer[j];
-		}
-	}
-
-	Z_Free(buffer);
-
-	return data;
+    byte* buffer;
+    byte* data;
+    int i;
+    int j;
+    int offset1;
+    int offset2;
+    int pack;
+    int col;
+
+    col     = (width * 3);
+    data    = (byte*)Z_Calloc(height * width * 3, PU_STATIC, 0);
+    buffer  = (byte*)Z_Calloc(col, PU_STATIC, 0);
+
+    //
+    // 20120313 villsa - force pack alignment to 1
+    //
+    dglGetIntegerv(GL_PACK_ALIGNMENT, &pack);
+    dglPixelStorei(GL_PACK_ALIGNMENT, 1);
+    dglFlush();
+    dglReadPixels(x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, data);
+    dglPixelStorei(GL_PACK_ALIGNMENT, pack);
+
+    //
+    // Need to vertically flip the image
+    // 20120313 villsa - better method to flip image. uses one buffer instead of two
+    //
+    for(i = 0; i < height / 2; i++) {
+        for(j = 0; j < col; j++) {
+            offset1 = (i * col) + j;
+            offset2 = ((height - (i + 1)) * col) + j;
+
+            buffer[j] = data[offset1];
+            data[offset1] = data[offset2];
+            data[offset2] = buffer[j];
+        }
+    }
+
+    Z_Free(buffer);
+
+    return data;
 }
 
 //
@@ -302,21 +306,21 @@ byte* GL_GetScreenBuffer(int x, int y, int width, int height) {
 //
 
 void GL_SetTextureFilter(void) {
-	if (!usingGL) {
-		return;
-	}
-
-	dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, (int)r_filter.value == 0 ? GL_LINEAR : GL_NEAREST);
-	dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, (int)r_filter.value == 0 ? GL_LINEAR : GL_NEAREST);
-
-	if (GL_EXT_texture_filter_anisotropic) {
-		if (r_anisotropic.value) {
-			dglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, max_anisotropic);
-		}
-		else {
-			dglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 0);
-		}
-	}
+    if(!usingGL) {
+        return;
+    }
+
+    dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, (int)r_filter.value == 0 ? GL_LINEAR : GL_NEAREST);
+    dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, (int)r_filter.value == 0 ? GL_LINEAR : GL_NEAREST);
+
+    if(has_GL_EXT_texture_filter_anisotropic) {
+        if(r_anisotropic.value) {
+            dglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, max_anisotropic);
+        }
+        else {
+            dglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 0);
+        }
+    }
 }
 
 //
@@ -324,6 +328,10 @@ void GL_SetTextureFilter(void) {
 //
 
 void GL_SetDefaultCombiner(void) {
+    if (!usingGL) {
+        return;
+    }
+
     if(has_GL_ARB_multitexture) {
         GL_SetTextureUnit(1, false);
         GL_SetTextureUnit(2, false);
@@ -346,6 +354,10 @@ void GL_SetDefaultCombiner(void) {
 //
 
 void GL_SetColorScale(void) {
+    if (!usingGL) {
+        return;
+    }
+
     int cs = (int)r_colorscale.value;
 
     switch(cs) {
@@ -365,51 +377,51 @@ void GL_SetColorScale(void) {
 // GL_Set2DQuad
 //
 
-void GL_Set2DQuad(vtx_t* v, float x, float y, int width, int height,
-	float u1, float u2, float v1, float v2, rcolor c) {
-	float left, right, top, bottom;
+void GL_Set2DQuad(vtx_t *v, float x, float y, int width, int height,
+                  float u1, float u2, float v1, float v2, rcolor c) {
+    float left, right, top, bottom;
 
-	left = ViewWindowX + x * ViewWidth / video_width;
-	right = left + (width * ViewWidth / video_width);
-	top = ViewWindowY + y * ViewHeight / video_height;
-	bottom = top + (height * ViewHeight / video_height);
+    left = ViewWindowX + x * ViewWidth / video_width;
+    right = left + (width * ViewWidth / video_width);
+    top = ViewWindowY + y * ViewHeight / video_height;
+    bottom = top + (height * ViewHeight / video_height);
 
-	v[0].x = v[2].x = left;
-	v[1].x = v[3].x = right;
-	v[0].y = v[1].y = top;
-	v[2].y = v[3].y = bottom;
+    v[0].x = v[2].x = left;
+    v[1].x = v[3].x = right;
+    v[0].y = v[1].y = top;
+    v[2].y = v[3].y = bottom;
 
-	v[0].z = v[1].z = v[2].z = v[3].z = 0.0f;
+    v[0].z = v[1].z = v[2].z = v[3].z = 0.0f;
 
-	v[0].tu = u1;
-	v[2].tu = u1;
-	v[1].tu = u2;
-	v[3].tu = u2;
-	v[0].tv = v1;
-	v[1].tv = v1;
-	v[2].tv = v2;
-	v[3].tv = v2;
+    v[0].tu = u1;
+    v[2].tu = u1;
+    v[1].tu = u2;
+    v[3].tu = u2;
+    v[0].tv = v1;
+    v[1].tv = v1;
+    v[2].tv = v2;
+    v[3].tv = v2;
 
-	dglSetVertexColor(v, c, 4);
+    dglSetVertexColor(v, c, 4);
 }
 
 //
 // GL_Draw2DQuad
 //
 
-void GL_Draw2DQuad(vtx_t* v, boolean stretch) {
-	GL_SetOrtho(stretch);
+void GL_Draw2DQuad(vtx_t *v, boolean stretch) {
+    GL_SetOrtho(stretch);
 
-	dglSetVertex(v);
-	RB_AddTriangle(0, 1, 2);
-	RB_AddTriangle(3, 2, 1);
-	dglDrawGeometry(4, v);
+    dglSetVertex(v);
+    RB_AddTriangle(0, 1, 2);
+    RB_AddTriangle(3, 2, 1);
+    dglDrawGeometry(4, v);
 
-	GL_ResetViewport();
+    GL_ResetViewport();
 
-	if (devparm) {
-		vertCount += 4;
-	}
+    if(devparm) {
+        vertCount += 4;
+    }
 }
 
 //
@@ -417,11 +429,11 @@ void GL_Draw2DQuad(vtx_t* v, boolean stretch) {
 //
 
 void GL_SetupAndDraw2DQuad(float x, float y, int width, int height,
-	float u1, float u2, float v1, float v2, rcolor c, boolean stretch) {
-	vtx_t v[4];
+                           float u1, float u2, float v1, float v2, rcolor c, boolean stretch) {
+    vtx_t v[4];
 
-	GL_Set2DQuad(v, x, y, width, height, u1, u2, v1, v2, c);
-	GL_Draw2DQuad(v, stretch);
+    GL_Set2DQuad(v, x, y, width, height, u1, u2, v1, v2, c);
+    GL_Draw2DQuad(v, stretch);
 };
 
 //
@@ -443,29 +455,29 @@ void GL_SetState(int bit, boolean enable) {
         glstate_flag &= ~(1 << flag);                   \
     }
 
-	switch (bit) {
-	case GLSTATE_BLEND:
-		TOGGLEGLBIT(GLSTATE_BLEND, GL_BLEND);
-		break;
-	case GLSTATE_CULL:
-		TOGGLEGLBIT(GLSTATE_CULL, GL_CULL_FACE);
-		break;
-	case GLSTATE_TEXTURE0:
-		TOGGLEGLBIT(GLSTATE_TEXTURE0, GL_TEXTURE_2D);
-		break;
-	case GLSTATE_TEXTURE1:
-		TOGGLEGLBIT(GLSTATE_TEXTURE1, GL_TEXTURE_2D);
-		break;
-	case GLSTATE_TEXTURE2:
-		TOGGLEGLBIT(GLSTATE_TEXTURE2, GL_TEXTURE_2D);
-		break;
-	case GLSTATE_TEXTURE3:
-		TOGGLEGLBIT(GLSTATE_TEXTURE3, GL_TEXTURE_2D);
-		break;
-	default:
-		CON_Warnf("GL_SetState: unknown bit flag: %i\n", bit);
-		break;
-	}
+    switch(bit) {
+    case GLSTATE_BLEND:
+        TOGGLEGLBIT(GLSTATE_BLEND, GL_BLEND);
+        break;
+    case GLSTATE_CULL:
+        TOGGLEGLBIT(GLSTATE_CULL, GL_CULL_FACE);
+        break;
+    case GLSTATE_TEXTURE0:
+        TOGGLEGLBIT(GLSTATE_TEXTURE0, GL_TEXTURE_2D);
+        break;
+    case GLSTATE_TEXTURE1:
+        TOGGLEGLBIT(GLSTATE_TEXTURE1, GL_TEXTURE_2D);
+        break;
+    case GLSTATE_TEXTURE2:
+        TOGGLEGLBIT(GLSTATE_TEXTURE2, GL_TEXTURE_2D);
+        break;
+    case GLSTATE_TEXTURE3:
+        TOGGLEGLBIT(GLSTATE_TEXTURE3, GL_TEXTURE_2D);
+        break;
+    default:
+        CON_Warnf("GL_SetState: unknown bit flag: %i\n", bit);
+        break;
+    }
 
 #undef TOGGLEGLBIT
 }
@@ -488,13 +500,13 @@ void GL_CheckFillMode(void) {
 //
 
 void GL_ClearView(rcolor clearcolor) {
-	float f[4];
+    float f[4];
 
-	dglGetColorf(clearcolor, f);
-	dglClearColor(f[0], f[1], f[2], f[3]);
-	dglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-	dglViewport(ViewWindowX, ViewWindowY, ViewWidth, ViewHeight);
-	dglScissor(ViewWindowX, ViewWindowY, ViewWidth, ViewHeight);
+    dglGetColorf(clearcolor, f);
+    dglClearColor(f[0], f[1], f[2], f[3]);
+    dglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    dglViewport(ViewWindowX, ViewWindowY, ViewWidth, ViewHeight);
+    dglScissor(ViewWindowX, ViewWindowY, ViewWidth, ViewHeight);
 }
 
 //
@@ -502,10 +514,10 @@ void GL_ClearView(rcolor clearcolor) {
 //
 
 boolean GL_GetBool(int x) {
-	byte b;
-	dglGetBooleanv(x, &b);
+    byte b;
+    dglGetBooleanv(x, &b);
 
-	return (boolean)b;
+    return (boolean)b;
 }
 
 //
@@ -513,91 +525,152 @@ boolean GL_GetBool(int x) {
 //
 
 static void CalcViewSize(void) {
-	ViewWidth = video_width;
-	ViewHeight = video_height;
+    ViewWidth = video_width;
+    ViewHeight = video_height;
+
+    widescreen = !dfcmp(((float)ViewWidth / (float)ViewHeight), (4.0f / 3.0f));
+
+    ViewWindowX = (video_width - ViewWidth) / 2;
 
-	widescreen = !dfcmp(((float)ViewWidth / (float)ViewHeight), (4.0f / 3.0f));
+    if(ViewWidth == video_width) {
+        ViewWindowY = 0;
+    }
+    else {
+        ViewWindowY = (ViewHeight) / 2;
+    }
+}
 
-	ViewWindowX = (video_width - ViewWidth) / 2;
+//
+// GetVersionInt
+// Borrowed from prboom+
+//
+
+typedef enum {
+    OPENGL_VERSION_1_0,
+    OPENGL_VERSION_1_1,
+    OPENGL_VERSION_1_2,
+    OPENGL_VERSION_1_3,
+    OPENGL_VERSION_1_4,
+    OPENGL_VERSION_1_5,
+    OPENGL_VERSION_2_0,
+    OPENGL_VERSION_2_1,
+} glversion_t;
+
+static int GetVersionInt(const char* version) {
+    int MajorVersion;
+    int MinorVersion;
+    int versionvar;
+
+    versionvar = OPENGL_VERSION_1_0;
+
+    if(sscanf(version, "%d.%d", &MajorVersion, &MinorVersion) == 2) {
+        if(MajorVersion > 1) {
+            versionvar = OPENGL_VERSION_2_0;
+
+            if(MinorVersion > 0) {
+                versionvar = OPENGL_VERSION_2_1;
+            }
+        }
+        else {
+            versionvar = OPENGL_VERSION_1_0;
+
+            if(MinorVersion > 0) {
+                versionvar = OPENGL_VERSION_1_1;
+            }
+            if(MinorVersion > 1) {
+                versionvar = OPENGL_VERSION_1_2;
+            }
+            if(MinorVersion > 2) {
+                versionvar = OPENGL_VERSION_1_3;
+            }
+            if(MinorVersion > 3) {
+                versionvar = OPENGL_VERSION_1_4;
+            }
+            if(MinorVersion > 4) {
+                versionvar = OPENGL_VERSION_1_5;
+            }
+        }
+    }
 
-	if (ViewWidth == video_width) {
-		ViewWindowY = 0;
-	}
-	else {
-		ViewWindowY = (ViewHeight) / 2;
-	}
+    return versionvar;
 }
 
 //
+// GL_Init
+//
+
 void GL_Init(void) {
+    gl_vendor = dglGetString(GL_VENDOR);
+    I_Printf("GL_VENDOR: %s\n", gl_vendor);
+    gl_renderer = dglGetString(GL_RENDERER);
+    I_Printf("GL_RENDERER: %s\n", gl_renderer);
+    gl_version = dglGetString(GL_VERSION);
+    I_Printf("GL_VERSION: %s\n", gl_version);
+    dglGetIntegerv(GL_MAX_TEXTURE_SIZE, &gl_max_texture_size);
+    I_Printf("GL_MAX_TEXTURE_SIZE: %i\n", gl_max_texture_size);
+    dglGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max_texture_units);
+    I_Printf("GL_MAX_TEXTURE_UNITS_ARB: %i\n", gl_max_texture_units);
+
+    if(gl_max_texture_units <= 2) {
+        CON_Warnf("Not enough texture units supported...\n");
+    }
 
-	gl_vendor = glGetString(GL_VENDOR);
-	I_Printf("GL_VENDOR: %s\n", gl_vendor);
-	gl_version = glGetString(GL_VERSION);
-	I_Printf("GL_VERSION: %s\n", gl_version);
-	glGetIntegerv(GL_MAX_TEXTURE_SIZE, &gl_max_texture_size);
-	I_Printf("GL_MAX_TEXTURE_SIZE: %i\n", gl_max_texture_size);
-	glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max_texture_units);
-	I_Printf("GL_MAX_TEXTURE_UNITS_ARB: %i\n", gl_max_texture_units);
-
-	if (gl_max_texture_units <= 2) {
-		CON_Warnf("Not enough texture units supported...\n");
-	}
-
-	CalcViewSize();
-
-	dglViewport(0, 0, video_width, video_height);
-	dglClearDepth(1.0f);
-	dglDisable(GL_TEXTURE_2D);
-	dglEnable(GL_CULL_FACE);
-	dglCullFace(GL_FRONT);
-	dglShadeModel(GL_SMOOTH);
-	dglHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
-	dglDepthFunc(GL_LEQUAL);
-	dglAlphaFunc(GL_GEQUAL, ALPHACLEARGLOBAL);
-	dglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	dglFogi(GL_FOG_MODE, GL_LINEAR);
-	dglHint(GL_FOG_HINT, GL_NICEST);
-	dglEnable(GL_SCISSOR_TEST);
-	dglEnable(GL_DITHER);
-
-	GL_SetTextureFilter();
-	GL_SetDefaultCombiner();
-
-	r_fillmode.value = 1.0f;
-
-	GL_ARB_multitexture_Init();
-	GL_EXT_texture_filter_anisotropic_Init();
-	GL_ARB_texture_env_combine_Init();
+    CalcViewSize();
+
+    dglViewport(0, 0, video_width, video_height);
+    dglClearDepth(1.0f);
+    dglDisable(GL_TEXTURE_2D);
+    dglEnable(GL_CULL_FACE);
+    dglCullFace(GL_FRONT);
+    dglShadeModel(GL_SMOOTH);
+    dglHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
+    dglDepthFunc(GL_LEQUAL);
+    dglAlphaFunc(GL_GEQUAL, ALPHACLEARGLOBAL);
+    dglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    dglFogi(GL_FOG_MODE, GL_LINEAR);
+    dglHint(GL_FOG_HINT, GL_NICEST);
+    dglEnable(GL_SCISSOR_TEST);
+    dglEnable(GL_DITHER);
+
+    GL_SetTextureFilter();
+    GL_SetDefaultCombiner();
+
+    r_fillmode.value = 1.0f;
+
+    GL_ARB_multitexture_Init();
+    //GL_EXT_compiled_vertex_array_Init();
+    //GL_ARB_texture_non_power_of_two_Init();
+    GL_ARB_texture_env_combine_Init();
     GL_EXT_texture_env_combine_Init();
+    GL_EXT_texture_filter_anisotropic_Init();
 
-	if (!GL_ARB_multitexture) {
-		CON_Warnf("GL_ARB_multitexture not supported...\n");
-	}
+    if(!has_GL_ARB_multitexture) {
+        CON_Warnf("GL_ARB_multitexture not supported...\n");
+    }
 
-	gl_has_combiner = (has_GL_ARB_texture_env_combine | has_GL_EXT_texture_env_combine);
+    gl_has_combiner = (has_GL_ARB_texture_env_combine | has_GL_EXT_texture_env_combine);
 
-    if (!gl_has_combiner) {
+    if(!gl_has_combiner) {
         CON_Warnf("Texture combiners not supported...\n");
         CON_Warnf("Setting r_texturecombiner to 0\n");
         CON_CvarSetValue(r_texturecombiner.name, 0.0f);
     }
 
-	dglEnableClientState(GL_VERTEX_ARRAY);
-	dglEnableClientState(GL_TEXTURE_COORD_ARRAY);
-	dglEnableClientState(GL_COLOR_ARRAY);
+    dglEnableClientState(GL_VERTEX_ARRAY);
+    dglEnableClientState(GL_TEXTURE_COORD_ARRAY);
+    dglEnableClientState(GL_COLOR_ARRAY);
 
-	DGL_CLAMP = gl_version ? GL_CLAMP_TO_EDGE : GL_CLAMP;
+    DGL_CLAMP = (GetVersionInt(gl_version) >= OPENGL_VERSION_1_2 ? GL_CLAMP_TO_EDGE : GL_CLAMP);
 
-	glScaleFactor = 1.0f;
+    glScaleFactor = 1.0f;
 
-	if (GL_EXT_texture_filter_anisotropic) {
-		dglGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &max_anisotropic);
-	}
+    if(has_GL_EXT_texture_filter_anisotropic) {
+        dglGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &max_anisotropic);
+    }
 
-	usingGL = true;
+    usingGL = true;
 
-	G_AddCommand("dumpglext", CMD_DumpGLExtensions, 0);
+    G_AddCommand("dumpglext", CMD_DumpGLExtensions, 0);
 
 	SDL_GL_SetSwapInterval((int)v_vsync.value);
-}
+}
\ No newline at end of file