Descent3/renderer/SoftwareOpenGL.cpp

#include "RendererConfig.h"
#ifdef USE_SOFTWARE_TNL

#if defined(WIN32)
#include <windows.h>
#include "ddraw.h"
#elif defined(__LINUX__)
#include "linux/linux_fix.h"
#include "linux/dyna_xext.h"
#include "lnxscreenmode.h"
#include <X11/Xatom.h>
#define min(a,b) (((a)<(b))?(a):(b))
#define max(a,b) (((a)>(b))?(a):(b))
#else
#endif

#include "DDAccess.h"
#include "pstypes.h"
#include "pserror.h"
#include "mono.h"
#include "3d.h"
#include "renderer.h"
#include "ddvid.h"
#include "ddio.h"
#include "application.h"
#include "bitmap.h"
#include "lightmap.h"
#include "rend_opengl.h"
#include "grdefs.h"
#include "mem.h"
#include "rtperformance.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <gl/gl.h>
#include <gl/glu.h>

#define DECLARE_OPENGL
#include "dyna_gl.h"

#if defined(WIN32)
#include "win/arb_extensions.h"
#endif

int FindArg(char *);
void rend_SetLightingState(light_state state);

int OpenGL_window_initted=0;

// The font characteristics
static float rend_FontRed[4],rend_FontBlue[4],rend_FontGreen[4],rend_FontAlpha[4];
char Renderer_error_message[256]="Generic renderer error";
int Triangles_drawn=0;
bool UseHardware=0;
bool NoLightmaps=0;
bool StateLimited=0;
bool UseMultitexture=0;
bool UseWBuffer=0;
int Overlay_map=-1;
int Bump_map=0,Bumpmap_ready=0;
ubyte Overlay_type=OT_NONE;
float Z_bias=0.0;
ubyte Renderer_close_flag=0,Renderer_initted=0;
// Is this hardware or software rendered?
renderer_type Renderer_type=RENDERER_SOFTWARE_16BIT;
int WindowGL=0;

extern matrix Unscaled_matrix;
extern vector View_position;


#define CHECK_ERROR(x)	

#if defined(WIN32)
	//	Moved from DDGR library
	static HWND hOpenGLWnd = NULL;
	static HDC hOpenGLDC = NULL;
	HGLRC ResourceContext;
	static WORD Saved_gamma_values[256*3];
#elif defined(__LINUX__)
	static Display *OpenGL_Display=NULL;
	static Window OpenGL_Window;
	static XVisualInfo OpenGL_VisualInfo;
	static GLXContext OpenGL_Context;
	static bool OpenGL_TextureHack = false;
	static bool OpenGL_UseLists = false;
	static oeLnxApplication *OpenGL_LinuxApp = NULL;
	#define glXQueryExtension dglXQueryExtension
	#define glXCreateContext dglXCreateContext
	#define glXMakeCurrent dglXMakeCurrent
	#define glXSwapBuffers dglXSwapBuffers 
	#define glXDestroyContext dglXDestroyContext
	#define glXWaitGL dglXWaitGL
#else
#endif

#define GET_WRAP_STATE(x)	(x>>4)
#define GET_FILTER_STATE(x)	(x & 0x0f)

#define SET_WRAP_STATE(x,s) {x&=0x0F; x|=(s<<4);}
#define SET_FILTER_STATE(x,s) {x&=0xF0; x|=(s);}

//	OpenGL Stuff
#define UNSIGNED_SHORT_5_5_5_1_EXT 0x8034
#define UNSIGNED_SHORT_4_4_4_4_EXT 0x8033
static int OpenGL_polys_drawn=0;
static int OpenGL_verts_processed=0;
static int OpenGL_uploads=0;
static int OpenGL_sets_this_frame[10];
static int OpenGL_packed_pixels=0;
static int OpenGL_multitexture=0;
static int Cur_texture_object_num=1;
static int OpenGL_cache_initted=0;
static int OpenGL_last_bound[2];
static int Last_texel_unit_set=-1;
static int OpenGL_last_frame_polys_drawn=0;
static int OpenGL_last_frame_verts_processed=0;
static int OpenGL_last_uploaded=0;
static float OpenGL_Alpha_factor=1.0f;

#ifndef RELEASE
	// This is for the Microsoft OpenGL reference driver
	// Setting this will turn off bilinear filtering and zbuffer so we can get decent 
	// framerates to discern driver problems
	static ubyte Fast_test_render=0;
#endif

#if defined(WIN32)
	PFNGLACTIVETEXTUREARBPROC oglActiveTextureARB;
	PFNGLCLIENTACTIVETEXTUREARBPROC oglClientActiveTextureARB;
	PFNGLMULTITEXCOORD4FARBPROC oglMultiTexCoord4f;
#endif

ushort *OpenGL_bitmap_remap;
ushort *OpenGL_lightmap_remap;
ubyte *OpenGL_bitmap_states;
ubyte *OpenGL_lightmap_states;

uint *opengl_Upload_data=NULL;
uint *opengl_Translate_table=NULL;
uint *opengl_4444_translate_table=NULL;

ushort *opengl_packed_Upload_data=NULL;
ushort *opengl_packed_Translate_table=NULL;
ushort *opengl_packed_4444_translate_table=NULL;

rendering_state OpenGL_state;
static float Alpha_multiplier=1.0;

renderer_preferred_state OpenGL_preferred_state={0,1,1.5}; 

// These structs are for drawing with OpenGL vertex arrays
// Useful for fast indexing
typedef struct
{
	float r,g,b,a;
} color_array;

typedef struct
{	
	float s,t,r,w;
} tex_array;

vector GL_verts[100];
color_array GL_colors[100];
tex_array GL_tex_coords[100];
tex_array GL_tex_coords2[100];

bool OpenGL_multitexture_state=false;
module *OpenGLDLLHandle=NULL;
int Already_loaded=0;
bool opengl_Blending_on=0;

static oeApplication *ParentApplication;

//Sets up multi-texturing using ARB extensions
void opengl_GetDLLFunctions(void)
{
#if defined(WIN32)
	oglActiveTextureARB=(PFNGLACTIVETEXTUREARBPROC)dwglGetProcAddress( "glActiveTextureARB" );
	if (!oglActiveTextureARB)
		goto dll_error;

	oglClientActiveTextureARB=(PFNGLCLIENTACTIVETEXTUREARBPROC)dwglGetProcAddress( "glClientActiveTextureARB" );
	if (!oglClientActiveTextureARB)
		goto dll_error;

	oglMultiTexCoord4f=(PFNGLMULTITEXCOORD4FARBPROC)dwglGetProcAddress( "glMultiTexCoord4f" );
	if (!oglMultiTexCoord4f)
		goto dll_error;

	return;

dll_error:
#endif
	OpenGL_multitexture = 0;
}

// returns true if the passed in extension name is supported
int opengl_CheckExtension( char *extName )
{
	char *p = (char *)dglGetString(GL_EXTENSIONS);	
	int extNameLen = strlen(extName);
	char *end = p + strlen(p);

	while( p < end )
	{
		int n = strcspn(p, " ");
		if ((extNameLen == n) && (strncmp(extName, p, n) == 0)) 
			return 1;

		p += (n + 1);
	}

	return 0;
}

// Gets some specific information about this particular flavor of opengl
void opengl_GetInformation ()
{
	mprintf ((0,"OpenGL Vendor: %s\n",dglGetString(GL_VENDOR)));
	mprintf ((0,"OpenGL Renderer: %s\n",dglGetString(GL_RENDERER)));
	mprintf ((0,"OpenGL Version: %s\n",dglGetString(GL_VERSION)));
	mprintf ((0,"OpenGL Extensions: %s\n",dglGetString (GL_EXTENSIONS)));

	/*
	#ifndef RELEASE
	// If this is the microsoft driver, then make stuff go faster
	const ubyte *renderer=dglGetString(GL_RENDERER);
	if (!(strnicmp ((const char *)renderer,"GDI",3)))
		Fast_test_render=1;
	else
		Fast_test_render=0;
	#endif
	*/
}

int opengl_MakeTextureObject (int tn)
{
	int num=Cur_texture_object_num;

	Cur_texture_object_num++;

	if (OpenGL_multitexture && Last_texel_unit_set!=tn)
	{
#if defined(WIN32)
		oglActiveTextureARB (GL_TEXTURE0_ARB+tn);
		Last_texel_unit_set=tn;
#endif
	}

	dglBindTexture (GL_TEXTURE_2D,num);
	dglPixelStorei (GL_UNPACK_ALIGNMENT,2);

	dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
	dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);

	dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
	dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);

	//glTexEnvf (GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);

	CHECK_ERROR(2)

	return num;
}

int opengl_InitCache(void)
{
	OpenGL_bitmap_remap=(ushort *)mem_malloc (MAX_BITMAPS*2);
	ASSERT (OpenGL_bitmap_remap);
	OpenGL_lightmap_remap=(ushort *)mem_malloc (MAX_LIGHTMAPS*2);
	ASSERT (OpenGL_lightmap_remap);

	OpenGL_bitmap_states=(ubyte *)mem_malloc (MAX_BITMAPS);
	ASSERT (OpenGL_bitmap_states);
	OpenGL_lightmap_states=(ubyte *)mem_malloc (MAX_LIGHTMAPS);
	ASSERT (OpenGL_lightmap_states);

	Cur_texture_object_num=1;

	// Setup textures and cacheing
	int i;
	for (i=0;i<MAX_BITMAPS;i++)
	{
		OpenGL_bitmap_remap[i]=65535;
		OpenGL_bitmap_states[i]=255;
		GameBitmaps[i].flags|=BF_CHANGED|BF_BRAND_NEW;
	}

	for (i=0;i<MAX_LIGHTMAPS;i++)
	{
		OpenGL_lightmap_remap[i]=65535;
		OpenGL_lightmap_states[i]=255;
		GameLightmaps[i].flags|=LF_CHANGED|LF_BRAND_NEW;
	}

	dglTexEnvf (GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);

	if (OpenGL_multitexture)
	{
#if defined(WIN32)
		oglActiveTextureARB (GL_TEXTURE0_ARB+1);
		dglTexEnvf (GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
		oglActiveTextureARB (GL_TEXTURE0_ARB+0);
#endif
	}

	CHECK_ERROR(3)

	OpenGL_cache_initted=1;
	return 1;
}

// Sets default states for our renderer
void opengl_SetDefaults()
{
	mprintf ((0,"Setting states\n"));

	OpenGL_state.cur_color=0x00FFFFFF;
	OpenGL_state.cur_bilinear_state=-1;
	OpenGL_state.cur_zbuffer_state=-1;
	OpenGL_state.cur_texture_quality=-1;
	OpenGL_state.cur_light_state=LS_GOURAUD;
	OpenGL_state.cur_color_model=CM_MONO;
	OpenGL_state.cur_bilinear_state=-1;
	OpenGL_state.cur_alpha_type=AT_TEXTURE;

	// Enable some states
	dglAlphaFunc (GL_GREATER,0);
	dglEnable (GL_ALPHA_TEST);
	dglEnable (GL_BLEND);
	dglEnable (GL_DITHER);
	opengl_Blending_on=true;

#ifndef RELEASE
	if (Fast_test_render)
		dglDisable (GL_DITHER);
#endif

	rend_SetAlphaType(AT_ALWAYS);
	rend_SetAlphaValue(255);
	rend_SetFiltering(1);
	rend_SetLightingState(LS_NONE);
	rend_SetTextureType(TT_FLAT);
	rend_SetColorModel(CM_RGB);
	rend_SetZBufferState(1);
	rend_SetZValues(0,3000);
	opengl_SetGammaValue (OpenGL_preferred_state.gamma);
	OpenGL_last_bound[0]=9999999;
	OpenGL_last_bound[1]=9999999;
	Last_texel_unit_set=-1;
	OpenGL_multitexture_state=false;

#ifdef __LINUX__
	OpenGL_UseLists = (FindArg("-gllists"))?true:false;
	if(OpenGL_UseLists)
	{
#endif	
		dglEnableClientState (GL_VERTEX_ARRAY);
		dglEnableClientState (GL_COLOR_ARRAY);
		dglEnableClientState (GL_TEXTURE_COORD_ARRAY);

		dglVertexPointer (3,GL_FLOAT,0,GL_verts);
		dglColorPointer (4,GL_FLOAT,0,GL_colors);
		dglTexCoordPointer (4,GL_FLOAT,0,GL_tex_coords);
#ifdef __LINUX__
	}
#endif

	dglHint (GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
	dglHint (GL_FOG_HINT,GL_FASTEST);
	dglEnable (GL_SCISSOR_TEST);
	dglScissor (0,0,OpenGL_state.screen_width,OpenGL_state.screen_height);
	dglDisable (GL_SCISSOR_TEST);
	dglDepthRange(0.0f,1.0f);

	if (OpenGL_multitexture)
	{
#if defined(WIN32)
		oglActiveTextureARB (GL_TEXTURE0_ARB+1);
		oglClientActiveTextureARB (GL_TEXTURE0_ARB+1);
		dglEnableClientState (GL_TEXTURE_COORD_ARRAY);
		dglTexCoordPointer (4,GL_FLOAT,0,GL_tex_coords2);
		dglHint (GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
		dglHint (GL_FOG_HINT,GL_FASTEST);

		oglClientActiveTextureARB (GL_TEXTURE0_ARB+0);

		dglDisable (GL_TEXTURE_2D);
		dglAlphaFunc (GL_GREATER,0);
		dglEnable (GL_ALPHA_TEST);
		dglEnable (GL_BLEND);
		dglEnable (GL_DITHER);
		dglBlendFunc (GL_DST_COLOR,GL_ZERO);
		oglActiveTextureARB (GL_TEXTURE0_ARB+0);
#endif
	}
}

#if defined(WIN32)
// Check for OpenGL support, 
int opengl_Setup(HDC glhdc)
{
	if (!Already_loaded)
	{
		if (!(OpenGLDLLHandle=LoadOpenGLDLL("opengl32.dll")))
		{
			rend_SetErrorMessage("Failed to load opengl dll!\n");
			Int3();
			return 0;
		}
	}

	// Finds an acceptable pixel format to render to
	PIXELFORMATDESCRIPTOR pfd, pfd_copy;
	int pf;

	memset(&pfd, 0, sizeof(pfd));
	pfd.nSize        = sizeof(pfd);
	pfd.nVersion     = 1;
	pfd.dwFlags      = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_GENERIC_ACCELERATED;
	pfd.iPixelType   = PFD_TYPE_RGBA;

	/*if (!WindowGL)
	{
	if (OpenGL_preferred_state.bit_depth==32)
	{
	pfd.cColorBits   = 32;
	pfd.cDepthBits   = 32;
	}
	else
	{
	pfd.cColorBits   = OpenGL_preferred_state.bit_depth;
	pfd.cDepthBits   =OpenGL_preferred_state.bit_depth;
	}

	pfd.cColorBits   = 16;
	pfd.cDepthBits   =16;

	}
	else
	{
	pfd.cColorBits   = 16;
	pfd.cDepthBits   =16;
	}*/


	// Find the user's "best match" PFD 
	pf = ChoosePixelFormat(glhdc, &pfd);
	if (pf == 0) 
	{
		Int3();
		//FreeLibrary(opengl_dll_handle);
		return NULL;
	} 

	mprintf ((0,"Choose pixel format successful!\n"));

	// Try and set the new PFD
	if (SetPixelFormat(glhdc, pf, &pfd) == FALSE) 
	{
		DWORD ret=GetLastError();
		Int3();
		//FreeLibrary(opengl_dll_handle);
		return NULL;
	}

	mprintf ((0,"SetPixelFormat successful!\n"));

	// Get a copy of the newly set PFD
	if(DescribePixelFormat(glhdc, pf, sizeof(PIXELFORMATDESCRIPTOR), &pfd_copy)==0)
	{
		Int3();
		//FreeLibrary(opengl_dll_handle);
		return NULL;
	}

	// Check the returned PFD to see if it is hardware accelerated
	if((pfd_copy.dwFlags & PFD_GENERIC_ACCELERATED)==0 && (pfd_copy.dwFlags & PFD_GENERIC_FORMAT)!=0)
	{
		Int3();
		//FreeLibrary(opengl_dll_handle);
		return NULL;
	}

	// Create an OpenGL context, and make it the current context
	ResourceContext = dwglCreateContext((HDC)glhdc);
	if(ResourceContext==NULL) {
		DWORD ret=GetLastError();
		//FreeLibrary(opengl_dll_handle);
		Int3();
		return NULL;   
	}

	ASSERT (ResourceContext!=NULL);
	mprintf ((0,"Making context current\n"));
	dwglMakeCurrent((HDC)glhdc, ResourceContext);

	Already_loaded=1;

	return 1;

}
#elif defined(__LINUX__)
bool opengl_GetXConfig(Display *dpy,XVisualInfo *vis,int attrib,int *value)
{
	int res;

	res = dglXGetConfig( dpy, vis , attrib, value );

	if(res==0)
		return true;

	switch(res)
	{
	case GLX_NO_EXTENSION:
		fprintf(stdout,"GLX: Display does not support the GLX extension (%d)\n",attrib);
		break;
	case GLX_BAD_SCREEN:
		fprintf(stdout,"GLX: The screen of the vis does not correspond to a screen (%d)\n",attrib);
		break;
	case GLX_BAD_ATTRIBUTE:
		fprintf(stdout,"GLX: Bad Attribute (%d\%d)\n",attrib,*value);
		break;
	case GLX_BAD_VISUAL:
		fprintf(stdout,"GLX: Bad Visual on non GLX_USE_GL call (%d)\n",attrib);
		break;
	default:
		fprintf(stdout,"GLX: Unknown error (%d)\n",attrib);
		break;
	}

	return false;
}

int opengl_Setup(oeApplication *app,int *width,int *height)
{
	if (!Already_loaded)
	{
#define MAX_ARGS			30
#define MAX_CHARS_PER_ARG	100
		extern char GameArgs[MAX_ARGS][MAX_CHARS_PER_ARG];

		char gl_library[256];
		int arg;
		arg = FindArg("-gllibrary");
		if(arg!=0)
		{
			strcpy(gl_library,GameArgs[arg+1]);
			fprintf(stdout,"OpenGL: Loading %s library\n",gl_library);
		}else
		{
			strcpy(gl_library,"libGL.so");
		}
		if (!(OpenGLDLLHandle=LoadOpenGLDLL(gl_library)))
		{
			char buffer[512];
			sprintf(buffer,"Failed to load %s!\n",gl_library);
			fprintf(stderr,buffer);
			rend_SetErrorMessage(buffer);			
			Int3();
			return 0;
		}
	}

	int dummy;

	OpenGL_TextureHack = (FindArg("-gltexturehack"))?true:false;

	if(app)
	{
		tLnxAppInfo app_info;
		OpenGL_LinuxApp = (oeLnxApplication *)app;

		app->get_info((void *)&app_info);

		OpenGL_Display = app_info.m_Display;
		OpenGL_Window = app_info.m_window;
		memcpy(&OpenGL_VisualInfo,&app_info.m_VisualInfo,sizeof(XVisualInfo));
	}else
	{
		// since the application object wasn't passed in, make sure
		// this isn't the first init
		if(!OpenGL_Display)
		{
			// ACK!
			fprintf(stdout,"OGL: Error in opengl_Setup().  Application object not specified\n");
			return 0;
		}
	}

	// we need to destroy the OpenGL window
	XUnmapWindow(OpenGL_Display,OpenGL_Window);
	XDestroyWindow(OpenGL_Display,OpenGL_Window);

	// Make sure OpenGL's GLX extension is supported.  The glXQueryExtension also returns
	// the GLX extension's error base and event base.  For almost all OpenGL programs,
	// this information is irrelevant.
	if(!glXQueryExtension(OpenGL_Display,&dummy,&dummy))
	{
		fprintf(stderr,"GLX extension not supported by Display\n");
		Int3();
		return 0;
	}

	// Choose our visual
	int screen_num = DefaultScreen(OpenGL_Display);
	int vis_attrib[] = {GLX_RGBA, 
		GLX_RED_SIZE, 1, 
		GLX_GREEN_SIZE, 1, 
		GLX_BLUE_SIZE, 1 , 
		GLX_DEPTH_SIZE, 16,
		GLX_DOUBLEBUFFER,
		None};
	XVisualInfo *new_vis = dglXChooseVisual(OpenGL_Display,screen_num,vis_attrib);
	if(!new_vis)
	{
		fprintf(stdout,"OpenGL: glXChooseVisual returned NULL\n");
		Int3();
		return 0;
	}

	// Create an OpenGL rendering context
	OpenGL_Context = glXCreateContext(OpenGL_Display,new_vis,None,True);
	if(OpenGL_Context==NULL)
	{
		fprintf(stderr,"OpenGL: Unable to create GLX Context\n");
		Int3();
		return 0;
	}

	// Create a new window
	XSetWindowAttributes swa;
	swa.override_redirect = true;
	swa.border_pixel = 0;
	swa.event_mask = ExposureMask|StructureNotifyMask|KeyPressMask|KeyReleaseMask|PointerMotionMask|ButtonPressMask|ButtonReleaseMask;

	OpenGL_Window = XCreateWindow(OpenGL_Display,RootWindow(OpenGL_Display,OpenGL_VisualInfo.screen),0,0,*width,*height,0,OpenGL_VisualInfo.depth,
		InputOutput,OpenGL_VisualInfo.visual,CWBorderPixel|CWEventMask,&swa);

	XSizeHints sizeHints = {0};
	sizeHints.flags |= USSize|USPosition|PAspect;
	sizeHints.width = *width;
	sizeHints.height = *height;
	sizeHints.x = 0;
	sizeHints.y = 0;
	sizeHints.min_aspect.x = sizeHints.max_aspect.x = *width;
	sizeHints.min_aspect.y = sizeHints.max_aspect.y = *height;

	char *argv[1];
	XWMHints *wmHints;
	Atom wmDeleteWindow;

	argv[0] = strdup("opengl");

	XSetStandardProperties(OpenGL_Display,OpenGL_Window,"","",None,(char **)argv,0,&sizeHints);
	free(argv[0]);

	wmHints = XAllocWMHints();
	wmHints->initial_state = NormalState;
	wmHints->flags = StateHint;

	XSetWMHints(OpenGL_Display,OpenGL_Window,wmHints);
	wmDeleteWindow = XInternAtom(OpenGL_Display,"WM_DELETE_WINDOW",False);
	XSetWMProtocols(OpenGL_Display,OpenGL_Window,&wmDeleteWindow,1);

	// move and resize the application window
	XMoveResizeWindow(OpenGL_Display,OpenGL_Window,0,0,*width,*height);

	OpenGL_LinuxApp->set_sizepos(0,0,*width,*height);
	OpenGL_LinuxApp->set_windowinfo(OpenGL_Display,OpenGL_Window);
	OpenGL_LinuxApp->hide_mouse();
	OpenGL_LinuxApp->clear_window();

	//	warp the mouse to 0,0 to start so our screen is in full view
	XWarpPointer(OpenGL_Display,None,OpenGL_Window,0,0,0,0,*width/2,*height/2);

	XStoreName(OpenGL_Display, OpenGL_Window, OpenGL_LinuxApp->get_window_name());
	XSetIconName(OpenGL_Display, OpenGL_Window, OpenGL_LinuxApp->get_window_name());

	XMapWindow(OpenGL_Display,OpenGL_Window);	

	bool wait_for_draw = false;
	XEvent event;
	while (!wait_for_draw)
	{
		XNextEvent(OpenGL_Display, &event);
		if (event.type == Expose && !event.xexpose.count)
			wait_for_draw = true;
	}

	XRaiseWindow(OpenGL_Display,OpenGL_Window);

	// Bind the rendering context
	glXMakeCurrent(OpenGL_Display,OpenGL_Window,OpenGL_Context);

	XSync(OpenGL_Display,False);

	Already_loaded = 1;
	return 1;
}
#endif

// Sets up our OpenGL rendering context
// Returns 1 if ok, 0 if something bad
int opengl_Init (oeApplication *app,renderer_preferred_state *pref_state)
{
	int width,height;
	int retval=1;
	int i;

	mprintf ((0,"Setting up opengl mode!\n"));

	if (pref_state)
	{
		OpenGL_preferred_state=*pref_state;
	}

	int windowX = 0, windowY = 0;
#if defined(WIN32)
	/***********************************************************
	*               WINDOWS OPENGL
	***********************************************************
	*/
	static HWND hwnd;

	if (app!=NULL)
	{
		ParentApplication=app;
		hwnd=(HWND)((oeWin32Application *)app)->m_hWnd;	
	}

	if (!WindowGL)
	{
		// First set our display mode
		// Create direct draw surface

		DEVMODE devmode;

		devmode.dmSize=sizeof(devmode);
		devmode.dmBitsPerPel=16;
		//devmode.dmBitsPerPel=OpenGL_preferred_state.bit_depth;
		devmode.dmPelsWidth=OpenGL_preferred_state.width;
		devmode.dmPelsHeight=OpenGL_preferred_state.height;
		devmode.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;

		int retval=ChangeDisplaySettings(&devmode,0);

		if (retval!=DISP_CHANGE_SUCCESSFUL)
		{
			mprintf ((0,"Display mode change failed (err=%d), trying default!\n",retval));
			retval=-1;
			devmode.dmBitsPerPel=16;
			devmode.dmPelsWidth=640;
			devmode.dmPelsHeight=480;
			devmode.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;

			retval=ChangeDisplaySettings(&devmode,0);
			if (retval!=DISP_CHANGE_SUCCESSFUL)
			{
				mprintf ((0,"OpenGL_INIT:Change display setting failed failed!\n"));
				rend_SetErrorMessage ("OGL: ChangeDisplaySettings failed.  Make sure your desktop is set to 16bit mode!");
				ChangeDisplaySettings(NULL,0);
				goto D3DError;
			}
			else
			{
				OpenGL_preferred_state.bit_depth=16;
				OpenGL_preferred_state.width=640;
				OpenGL_preferred_state.height=480;
			}
		}
		else
			mprintf ((0,"Setdisplaymode to %d x %d (%d bits) is successful!\n",OpenGL_preferred_state.width,OpenGL_preferred_state.height,OpenGL_preferred_state.bit_depth));

	}

	memset (&OpenGL_state,0,sizeof(rendering_state));

	//	These values are set here - samir
	if (app!=NULL)
	{
		hOpenGLWnd = (HWND)((oeWin32Application *)app)->m_hWnd;
	}

	hOpenGLDC = GetDC(hOpenGLWnd);

	if (WindowGL)
	{
		RECT rect;
		POINT topLeft;
		GetClientRect( (HWND)hOpenGLWnd, &rect );

		topLeft.x = rect.left;
		topLeft.y = rect.top;
		ClientToScreen( (HWND)hOpenGLWnd, &topLeft );

		width   = rect.right - rect.left + 1;
		height  = rect.bottom - rect.top + 1;
		windowX = topLeft.x;
		windowY = topLeft.y;
	}
	else
	{
		SetWindowPos(hOpenGLWnd, HWND_TOPMOST, 0, 0, OpenGL_preferred_state.width,OpenGL_preferred_state.height, SWP_FRAMECHANGED);
		width=OpenGL_preferred_state.width;
		height=OpenGL_preferred_state.height;
		RECT rect;
		GetWindowRect ((HWND)hOpenGLWnd,&rect);
		mprintf ((0,"rect=%d %d %d %d\n",rect.top,rect.right,rect.bottom,rect.left));
	}

	OpenGL_state.screen_width=width;
	OpenGL_state.screen_height=height;

	if (!opengl_Setup(hOpenGLDC))
		goto D3DError;

	// Save gamma values for later
	GetDeviceGammaRamp(hOpenGLDC,(LPVOID)Saved_gamma_values);

#elif defined(__LINUX__)
	/***********************************************************
	*               LINUX OPENGL
	***********************************************************
	*/
	// Setup OpenGL_state.screen_width & OpenGL_state.screen_height & width & height
	width = OpenGL_preferred_state.width;
	height = OpenGL_preferred_state.height;

	if(!opengl_Setup(app,&width,&height))
		goto D3DError;

	memset (&OpenGL_state,0,sizeof(rendering_state));
	OpenGL_state.screen_width = width;
	OpenGL_state.screen_height = height;
#else
	// Setup OpenGL_state.screen_width & OpenGL_state.screen_height & width & height

#endif
	// Get some info
	opengl_GetInformation();

	mprintf ((0,"Setting up projection matrix\n"));

	dglMatrixMode(GL_PROJECTION);	
	dglLoadIdentity();
	dglOrtho( (GLfloat)0.0f, (GLfloat)(width), (GLfloat)(height), (GLfloat)0.0f, 0.0f, 1.0f);
	dglViewport( 0, 0, width, height);   
	dglMatrixMode(GL_MODELVIEW);
	dglLoadIdentity();

	opengl_InitCache();

	OpenGL_multitexture=opengl_CheckExtension ("GL_ARB_multitexture");

	if (!OpenGL_multitexture)
		OpenGL_multitexture=opengl_CheckExtension ("GL_SGIS_multitexture");

	OpenGL_packed_pixels=opengl_CheckExtension ("GL_EXT_packed_pixels");

	opengl_GetDLLFunctions();

	if (FindArg ("-NoMultitexture"))
		OpenGL_multitexture=false;

	if (OpenGL_packed_pixels)
	{
		opengl_packed_Upload_data=(ushort *)mem_malloc (256*256*2);
		opengl_packed_Translate_table=(ushort *)mem_malloc (65536*2);
		opengl_packed_4444_translate_table=(ushort *)mem_malloc (65536*2);

		ASSERT (opengl_packed_Upload_data);
		ASSERT (opengl_packed_Translate_table);
		ASSERT (opengl_packed_4444_translate_table);

		mprintf ((0,"Building packed OpenGL translate table...\n"));

		for (i=0;i<65536;i++)
		{
			int r=(i>>10) & 0x1f;
			int g=(i>>5) & 0x1f;
			int b=i & 0x1f;

#ifdef BRIGHTNESS_HACK
			r *= BRIGHTNESS_HACK;
			g *= BRIGHTNESS_HACK;
			b *= BRIGHTNESS_HACK;
			if( r > 0x1F ) r = 0x1F;
			if( g > 0x1F ) g = 0x1F;
			if( b > 0x1F ) b = 0x1F;
#endif

			ushort pix;

			if (!(i & OPAQUE_FLAG))
			{
				pix=0;
			}
			else
			{
				pix=(r<<11) | (g<<6) | (b<<1) | 1;
			}

			opengl_packed_Translate_table[i]=pix;

			// 4444 table
			int a=(i>>12) & 0xf;
			r=(i>>8) & 0xf;
			g=(i>>4) & 0xf;
			b=i & 0xf;

			pix=(r<<12) | (g<<8) | (b<<4) | a;

			opengl_packed_4444_translate_table[i]=pix;

		}
	}
	else
	{
		opengl_Upload_data=(uint *)mem_malloc (256*256*4);
		opengl_Translate_table=(uint *)mem_malloc (65536*4);
		opengl_4444_translate_table=(uint *)mem_malloc (65536*4);

		ASSERT (opengl_Upload_data);
		ASSERT (opengl_Translate_table);
		ASSERT (opengl_4444_translate_table);

		mprintf ((0,"Building OpenGL translate table...\n"));

		for (i=0;i<65536;i++)
		{
			uint pix;
			int r=(i>>10) & 0x1f;
			int g=(i>>5) & 0x1f;
			int b=i & 0x1f;

#ifdef BRIGHTNESS_HACK
			r *= BRIGHTNESS_HACK;
			g *= BRIGHTNESS_HACK;
			b *= BRIGHTNESS_HACK;
			if( r > 0x1F ) r = 0x1F;
			if( g > 0x1F ) g = 0x1F;
			if( b > 0x1F ) b = 0x1F;
#endif

			float fr=(float)r/31.0f;
			float fg=(float)g/31.0f;
			float fb=(float)b/31.0f;

			r=255*fr;
			g=255*fg;
			b=255*fb;

			if (!(i & OPAQUE_FLAG))
				pix=0;
			else
				pix=(255<<24) | (b<<16) | (g<<8) | (r);

			opengl_Translate_table[i]=pix;

			// Do 4444
			int a=(i>>12) & 0xf;
			r=(i>>8) & 0xf;
			g=(i>>4) & 0xf;
			b=i & 0xf;

			float fa=(float)a/15.0f;
			fr=(float)r/15.0f;
			fg=(float)g/15.0f;
			fb=(float)b/15.0f;

			a=255*fa;
			r=255*fr;
			g=255*fg;
			b=255*fb;

			pix=(a<<24) | (b<<16) | (g<<8) | (r);

			opengl_4444_translate_table[i]=pix;
		}
	}

	opengl_SetDefaults();


	CHECK_ERROR(4)

	// Tell our app to use multitexture
	if (OpenGL_multitexture)
		UseMultitexture=true;

	OpenGL_state.initted = 1;

	mprintf ((0,"OpenGL initialization at %d x %d was successful.\n",width,height));

	return retval;

D3DError:
	opengl_Close();
	return 0;
}

// Releases the rendering context
void opengl_Close ()
{
	CHECK_ERROR(5)

		uint *delete_list=(uint *)mem_malloc (Cur_texture_object_num*sizeof(int));
	ASSERT (delete_list);
	for (int i=1;i<Cur_texture_object_num;i++)
		delete_list[i]=i;

	if (Cur_texture_object_num>1)
		dglDeleteTextures (Cur_texture_object_num,(const uint *)delete_list);

	mem_free (delete_list);

#if defined(WIN32)
	if (dwglMakeCurrent)
		dwglMakeCurrent(NULL, NULL);

	if (dwglDeleteContext)
		dwglDeleteContext(ResourceContext);

	// Change our display back
	if (!WindowGL)
		ChangeDisplaySettings(NULL,0);
#elif defined(__LINUX__)
	// Restore our video mode
	LinuxVideoMode.Lock(false);
	LinuxVideoMode.RestoreVideoMode();	
	if(OpenGL_Display)
	{
		if(dglXMakeCurrent)
			glXMakeCurrent(OpenGL_Display,OpenGL_Window,NULL);
		if(dglXDestroyContext)
			glXDestroyContext(OpenGL_Display,OpenGL_Context);
	}	
#else

#endif

	if (OpenGL_packed_pixels)
	{
		if (opengl_packed_Upload_data)
			mem_free (opengl_packed_Upload_data);
		if (opengl_packed_Translate_table)
			mem_free (opengl_packed_Translate_table);
		if (opengl_packed_4444_translate_table)
			mem_free (opengl_packed_4444_translate_table);
		opengl_packed_Upload_data=NULL;
		opengl_packed_Translate_table=NULL;
		opengl_packed_4444_translate_table=NULL;
	}
	else
	{
		if (opengl_Upload_data)
			mem_free (opengl_Upload_data);
		if (opengl_Translate_table)
			mem_free (opengl_Translate_table);
		if (opengl_4444_translate_table)
			mem_free (opengl_4444_translate_table);
		opengl_Upload_data=NULL;
		opengl_Translate_table=NULL;
		opengl_4444_translate_table=NULL;
	}

	if (OpenGL_cache_initted)
	{
		mem_free (OpenGL_lightmap_remap);
		mem_free (OpenGL_bitmap_remap);
		mem_free (OpenGL_lightmap_states);
		mem_free (OpenGL_bitmap_states);
		OpenGL_cache_initted=0;
	}

#if defined(WIN32)
	// Restore gamma values
	SetDeviceGammaRamp(hOpenGLDC,(LPVOID)Saved_gamma_values);
	//	I'm freeing the DC here - samir
	ReleaseDC(hOpenGLWnd, hOpenGLDC);
#elif defined(__LINUX__)

#else

#endif
	//mod_FreeModule (OpenGLDLLHandle);
	OpenGL_state.initted = 0;
}

// Takes our 16bit format and converts it into the memory scheme that OpenGL wants
void opengl_TranslateBitmapToOpenGL (int texnum,int bm_handle,int map_type,int replace,int tn)
{
	ushort *bm_ptr;

	int w,h;
	int size;

	if (OpenGL_multitexture && Last_texel_unit_set!=tn)
	{
#if defined(WIN32)
		oglActiveTextureARB (GL_TEXTURE0_ARB+tn);
		Last_texel_unit_set=tn;
#endif
	}

	if (map_type==MAP_TYPE_LIGHTMAP)
	{
		if (GameLightmaps[bm_handle].flags & LF_BRAND_NEW)
			replace=0;

		bm_ptr=lm_data (bm_handle);
		GameLightmaps[bm_handle].flags &=~(LF_CHANGED|LF_BRAND_NEW);

		w=lm_w(bm_handle);
		h=lm_h(bm_handle);
		size=GameLightmaps[bm_handle].square_res;
	}
	else
	{
		if (GameBitmaps[bm_handle].flags & BF_BRAND_NEW)
			replace=0;

		bm_ptr=bm_data (bm_handle,0);
		GameBitmaps[bm_handle].flags &=~(BF_CHANGED|BF_BRAND_NEW);
		w=bm_w(bm_handle,0);
		h=bm_h(bm_handle,0);
		size=w;
	}

	if (OpenGL_last_bound[tn]!=texnum)
	{
		dglBindTexture (GL_TEXTURE_2D,texnum);
		OpenGL_sets_this_frame[0]++;
		OpenGL_last_bound[tn]=texnum;
	}

	int i;

	if (OpenGL_packed_pixels)
	{
		if (map_type==MAP_TYPE_LIGHTMAP)
		{	
			ushort *left_data=(ushort *)opengl_packed_Upload_data;
			int bm_left=0;

			for (int i=0;i<h;i++,left_data+=size,bm_left+=w)
			{
				ushort *dest_data=left_data;
				for (int t=0;t<w;t++)
				{
					*dest_data++=opengl_packed_Translate_table[bm_ptr[bm_left+t]];
				}
			}

			if (replace)
			{
				dglTexSubImage2D (GL_TEXTURE_2D,0,0,0,size,size,GL_RGBA,UNSIGNED_SHORT_5_5_5_1_EXT,opengl_packed_Upload_data);
			}
			else
			{
				dglTexImage2D (GL_TEXTURE_2D,0,GL_RGB5_A1,size,size,0,GL_RGBA,UNSIGNED_SHORT_5_5_5_1_EXT,opengl_packed_Upload_data);
			}
		}
		else
		{
			int limit=0;

			if (bm_mipped(bm_handle))
				limit=NUM_MIP_LEVELS+3;
			else
				limit=1;

			for (int m=0;m<limit;m++)
			{
				if (m<NUM_MIP_LEVELS)
				{
					bm_ptr=bm_data (bm_handle,m);
					w=bm_w(bm_handle,m);
					h=bm_h(bm_handle,m);
				}
				else
				{
					bm_ptr=bm_data (bm_handle,NUM_MIP_LEVELS-1);
					w=bm_w(bm_handle,NUM_MIP_LEVELS-1);
					h=bm_h(bm_handle,NUM_MIP_LEVELS-1);

					w>>=m-(NUM_MIP_LEVELS-1);
					h>>=m-(NUM_MIP_LEVELS-1);

					if (w<1)
						continue;

				}

				if (bm_format(bm_handle)==BITMAP_FORMAT_4444)
				{
					// Do 4444

					if (bm_mipped(bm_handle))
					{
						for (i=0;i<w*h;i++)
							opengl_packed_Upload_data[i]=0xf|(opengl_packed_4444_translate_table[bm_ptr[i]]);
					}
					else
					{
						for (i=0;i<w*h;i++)
							opengl_packed_Upload_data[i]=opengl_packed_4444_translate_table[bm_ptr[i]];
					}

					if (replace)
					{
						dglTexSubImage2D (GL_TEXTURE_2D,m,0,0,w,h,GL_RGBA,UNSIGNED_SHORT_4_4_4_4_EXT,opengl_packed_Upload_data);
					}
					else
					{
						dglTexImage2D (GL_TEXTURE_2D,m,GL_RGBA4,w,h,0,GL_RGBA,UNSIGNED_SHORT_4_4_4_4_EXT,opengl_packed_Upload_data);
					}
				}
				else
				{
					// Do 1555
					for (i=0;i<w*h;i++)
						opengl_packed_Upload_data[i]=opengl_packed_Translate_table[bm_ptr[i]];

					if (replace)
					{
						dglTexSubImage2D (GL_TEXTURE_2D,m,0,0,w,h,GL_RGBA,UNSIGNED_SHORT_5_5_5_1_EXT,opengl_packed_Upload_data);
					}
					else
					{
						dglTexImage2D (GL_TEXTURE_2D,m,GL_RGB5_A1,w,h,0,GL_RGBA,UNSIGNED_SHORT_5_5_5_1_EXT,opengl_packed_Upload_data);
					}
				}
			}
		}
	}
	else
	{
		if (map_type==MAP_TYPE_LIGHTMAP)
		{	
			uint *left_data=(uint *)opengl_Upload_data;
			int bm_left=0;

			for (int i=0;i<h;i++,left_data+=size,bm_left+=w)
			{
				uint *dest_data=left_data;
				for (int t=0;t<w;t++)
				{
					*dest_data++=opengl_Translate_table[bm_ptr[bm_left+t]];
				}
			}

			if (replace)
			{
				dglTexSubImage2D (GL_TEXTURE_2D,0,0,0,size,size,GL_RGBA,GL_UNSIGNED_BYTE,opengl_Upload_data);
			}
			else
			{
				dglTexImage2D (GL_TEXTURE_2D,0,GL_RGBA,size,size,0,GL_RGBA,GL_UNSIGNED_BYTE,opengl_Upload_data);
			}
		}
		else
		{
			int limit=0;

			if (bm_mipped(bm_handle))
				limit=NUM_MIP_LEVELS;
			else
				limit=1;

			for (int m=0;m<limit;m++)
			{
				bm_ptr=bm_data (bm_handle,m);
				w=bm_w(bm_handle,m);
				h=bm_h(bm_handle,m);

				if (bm_format(bm_handle)==BITMAP_FORMAT_4444)
				{
					// Do 4444

					if (bm_mipped(bm_handle))
					{
						for (i=0;i<w*h;i++)
							opengl_Upload_data[i]=(255<<24)|opengl_4444_translate_table[bm_ptr[i]];
					}
					else
					{
						for (i=0;i<w*h;i++)
							opengl_Upload_data[i]=opengl_4444_translate_table[bm_ptr[i]];
					}
				}
				else
				{
					// Do 1555

					for (i=0;i<w*h;i++)
						opengl_Upload_data[i]=opengl_Translate_table[bm_ptr[i]];
				}

				if (replace)
				{
					dglTexSubImage2D (GL_TEXTURE_2D,m,0,0,w,h,GL_RGBA,GL_UNSIGNED_BYTE,opengl_Upload_data);
				}
				else
				{
					dglTexImage2D (GL_TEXTURE_2D,m,GL_RGBA,w,h,0,GL_RGBA,GL_UNSIGNED_BYTE,opengl_Upload_data);
				}
			}
		}
	}

	//mprintf ((1,"Doing slow upload to opengl!\n"));

	if (map_type==MAP_TYPE_LIGHTMAP)
	{
		GameLightmaps[bm_handle].flags&=~LF_LIMITS;
	}

	CHECK_ERROR(6)
	OpenGL_uploads++;
}

extern bool Force_one_texture;

// Utilizes a LRU cacheing scheme to select/upload textures the opengl driver
int opengl_MakeBitmapCurrent (int handle,int map_type,int tn)
{
	int w,h;
	int texnum;

	if (map_type==MAP_TYPE_LIGHTMAP)
	{
		w=GameLightmaps[handle].square_res;
		h=GameLightmaps[handle].square_res;
	}
	else
	{
		if(Force_one_texture)
		{
			handle=0;
		}

		w=bm_w(handle,0);
		h=bm_h(handle,0);
	}

	if( w != h )
	{
		mprintf ((0,"Can't use non-square textures with OpenGL!\n"));
		return 0;
	}

	// See if the bitmaps is already in the cache
	if (map_type==MAP_TYPE_LIGHTMAP)
	{
		if (OpenGL_lightmap_remap[handle]==65535)
		{
			texnum=opengl_MakeTextureObject (tn);
			SET_WRAP_STATE(OpenGL_lightmap_states[handle],1);
			SET_FILTER_STATE(OpenGL_lightmap_states[handle],0);
			OpenGL_lightmap_remap[handle]=texnum;
			opengl_TranslateBitmapToOpenGL(texnum,handle,map_type,0,tn);
		}
		else
		{
			texnum=OpenGL_lightmap_remap[handle];
			if (GameLightmaps[handle].flags & LF_CHANGED)
				opengl_TranslateBitmapToOpenGL(texnum,handle,map_type,1,tn);
		}
	}
	else
	{
		if (OpenGL_bitmap_remap[handle]==65535)
		{
			texnum=opengl_MakeTextureObject (tn);
			SET_WRAP_STATE(OpenGL_bitmap_states[handle],1);
			SET_FILTER_STATE(OpenGL_bitmap_states[handle],0);
			OpenGL_bitmap_remap[handle]=texnum;
			opengl_TranslateBitmapToOpenGL(texnum,handle,map_type,0,tn);
		}
		else
		{
			texnum=OpenGL_bitmap_remap[handle];
			if( GameBitmaps[handle].flags & BF_CHANGED )
			{
				opengl_TranslateBitmapToOpenGL(texnum,handle,map_type,1,tn);
			}
		}
	}

	if (OpenGL_last_bound[tn]!=texnum)
	{
		if (OpenGL_multitexture && Last_texel_unit_set!=tn)
		{
#if defined(WIN32)
			oglActiveTextureARB (GL_TEXTURE0_ARB+tn);
			Last_texel_unit_set=tn;
#endif
		}

		dglBindTexture (GL_TEXTURE_2D,texnum);
		OpenGL_last_bound[tn]=texnum;
		OpenGL_sets_this_frame[0]++;
	}

	CHECK_ERROR(7)
	return 1;
}

// Sets up an appropriate wrap type for the current bound texture
void opengl_MakeWrapTypeCurrent(int handle,int map_type,int tn)
{
	int uwrap;
	wrap_type dest_wrap;

	if (tn==1)
		dest_wrap=WT_CLAMP;
	else
		dest_wrap=OpenGL_state.cur_wrap_type;

	if (map_type==MAP_TYPE_LIGHTMAP)
		uwrap=GET_WRAP_STATE(OpenGL_lightmap_states[handle]);
	else
		uwrap=GET_WRAP_STATE(OpenGL_bitmap_states[handle]);

	if (uwrap==dest_wrap)
		return;

	if (OpenGL_multitexture && Last_texel_unit_set!=tn)
	{
#if defined(WIN32)
		oglActiveTextureARB (GL_TEXTURE0_ARB+tn);
		Last_texel_unit_set=tn;
#endif
	}

	OpenGL_sets_this_frame[1]++;

	if (OpenGL_state.cur_wrap_type==WT_CLAMP)
	{
		dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
		dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);

	}
	else if (OpenGL_state.cur_wrap_type==WT_WRAP_V)
	{
		dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
		dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
	}
	else
	{
		dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
		dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
	}

	if (map_type==MAP_TYPE_LIGHTMAP)
	{
		SET_WRAP_STATE (OpenGL_lightmap_states[handle],dest_wrap);
	}
	else
	{
		SET_WRAP_STATE (OpenGL_bitmap_states[handle],dest_wrap);
	}

	CHECK_ERROR(8)
}

// Chooses the correct filter type for the currently bound texture
void opengl_MakeFilterTypeCurrent(int handle,int map_type,int tn)
{
	int magf;
	sbyte dest_state;

	if (map_type==MAP_TYPE_LIGHTMAP)
	{
		magf=GET_FILTER_STATE(OpenGL_lightmap_states[handle]);
		dest_state=1;
	}
	else
	{
		magf=GET_FILTER_STATE(OpenGL_bitmap_states[handle]);
		dest_state=OpenGL_preferred_state.filtering;
		if (!OpenGL_state.cur_bilinear_state)
			dest_state=0;
	}

	if (magf==dest_state)
		return;

	if (OpenGL_multitexture && Last_texel_unit_set!=tn)
	{
#if defined(WIN32)
		oglActiveTextureARB (GL_TEXTURE0_ARB+tn);
		Last_texel_unit_set=tn;
#endif
	}

	OpenGL_sets_this_frame[2]++;

	if (dest_state)
	{
		if (map_type==MAP_TYPE_BITMAP && bm_mipped(handle))
		{
			dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
			dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
		}
		else
		{
			dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
			dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
		}
	}
	else
	{
		if (map_type==MAP_TYPE_BITMAP && bm_mipped(handle))
		{
			//dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST_MIPMAP_NEAREST);
			dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
			dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST_MIPMAP_NEAREST);
		}
		else
		{
			dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
			dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
		}
	}

	if (map_type==MAP_TYPE_LIGHTMAP)
	{
		SET_FILTER_STATE (OpenGL_lightmap_states[handle],dest_state);
	}
	else
	{
		SET_FILTER_STATE (OpenGL_bitmap_states[handle],dest_state);
	}

	CHECK_ERROR(9)
}

// returns the alpha that we should use
float opengl_GetAlphaMultiplier(void)
{
	switch(OpenGL_state.cur_alpha_type)
	{
	case AT_ALWAYS:
		return 1.0;
	case AT_CONSTANT:
		return OpenGL_state.cur_alpha/255.0;
	case AT_TEXTURE:
		return 1.0;
	case AT_CONSTANT_TEXTURE:
		return OpenGL_state.cur_alpha/255.0;
	case AT_VERTEX:
		return 1.0;
	case AT_CONSTANT_TEXTURE_VERTEX:
	case AT_CONSTANT_VERTEX:
		return OpenGL_state.cur_alpha/255.0;
	case AT_TEXTURE_VERTEX:
		return 1.0;
	case AT_LIGHTMAP_BLEND:
	case AT_LIGHTMAP_BLEND_SATURATE:
		return OpenGL_state.cur_alpha/255.0;
	case AT_SATURATE_TEXTURE:
		return OpenGL_state.cur_alpha/255.0;
	case AT_SATURATE_VERTEX:
		return 1.0;
	case AT_SATURATE_CONSTANT_VERTEX:
		return OpenGL_state.cur_alpha/255.0;
	case AT_SATURATE_TEXTURE_VERTEX:
		return 1.0;
	case AT_SPECULAR:
		return 1.0;
	default:
		//Int3();		// no type defined,get jason
		return 0;
	}
}

// Turns on/off multitexture blending
void opengl_SetMultitextureBlendMode (bool state)
{
	if (OpenGL_multitexture_state==state)
		return;

	OpenGL_multitexture_state=state;

	if (state)
	{
#if defined(WIN32)
		oglClientActiveTextureARB (GL_TEXTURE0_ARB+1);
		oglActiveTextureARB (GL_TEXTURE0_ARB+1);
		dglEnableClientState (GL_TEXTURE_COORD_ARRAY);
		dglEnable (GL_TEXTURE_2D);

		/*if (Overlay_type==OT_BLEND_SATURATE)
		glBlendFunc (GL_SRC_ALPHA,GL_ONE);
		else
		glBlendFunc (GL_DST_COLOR,GL_ZERO);*/

		oglActiveTextureARB (GL_TEXTURE0_ARB+0);
		Last_texel_unit_set=0;
#endif
	}	
	else
	{
#if defined(WIN32)
		oglClientActiveTextureARB (GL_TEXTURE0_ARB+1);
		oglActiveTextureARB (GL_TEXTURE0_ARB+1);
		dglDisableClientState (GL_TEXTURE_COORD_ARRAY);
		dglDisable (GL_TEXTURE_2D);
		oglActiveTextureARB (GL_TEXTURE0_ARB+0);
		Last_texel_unit_set=0;
#endif
	}
}

// Takes nv vertices and draws the polygon defined by those vertices.  Uses bitmap "handle"
// as a texture
void opengl_DrawMultitexturePolygon (int handle,g3Point **p,int nv,int map_type)
{
	g3Point *pnt;
	int i,fr,fg,fb;
	float alpha;
	vector *vertp;
	color_array *colorp;
	tex_array *texp,*texp2;
	float one_over_square_res=1.0/GameLightmaps[Overlay_map].square_res;

	float xscalar=(float)GameLightmaps[Overlay_map].width*one_over_square_res;
	float yscalar=(float)GameLightmaps[Overlay_map].height*one_over_square_res;

	ASSERT (nv<100);

	int x_add=OpenGL_state.clip_x1;
	int y_add=OpenGL_state.clip_y1;

	if (OpenGL_state.cur_light_state==LS_NONE)
	{
		fr=GR_COLOR_RED(OpenGL_state.cur_color);
		fg=GR_COLOR_GREEN(OpenGL_state.cur_color);
		fb=GR_COLOR_BLUE(OpenGL_state.cur_color);
	}

	alpha=Alpha_multiplier*OpenGL_Alpha_factor;

	vertp=&GL_verts[0];
	texp=&GL_tex_coords[0];
	texp2=&GL_tex_coords2[0];
	colorp=&GL_colors[0];

	// Specify our coordinates
	for (i=0;i<nv;i++,vertp++,texp++,colorp++,texp2++)
	{
		pnt=p[i];

		if (OpenGL_state.cur_alpha_type & ATF_VERTEX)
			alpha=pnt->p3_a*Alpha_multiplier*OpenGL_Alpha_factor;

		// If we have a lighting model, apply the correct lighting!
		if (OpenGL_state.cur_light_state!=LS_NONE)
		{
			// Do lighting based on intesity (MONO) or colored (RGB)
			if (OpenGL_state.cur_color_model==CM_MONO)
			{
				colorp->r=pnt->p3_l;
				colorp->g=pnt->p3_l;
				colorp->b=pnt->p3_l;
				colorp->a=alpha;
			}
			else
			{
				colorp->r=pnt->p3_r;
				colorp->g=pnt->p3_g;
				colorp->b=pnt->p3_b;
				colorp->a=alpha;
			}
		}
		else
		{
			colorp->r=1;
			colorp->g=1;
			colorp->b=1;
			colorp->a=alpha;
		}

		// Texture this polygon!
		float texw=1.0/(pnt->p3_z+Z_bias);
		texp->s=pnt->p3_u*texw;
		texp->t=pnt->p3_v*texw;
		texp->r=0;
		texp->w=texw;

		texp2->s=pnt->p3_u2*xscalar*texw;
		texp2->t=pnt->p3_v2*yscalar*texw;
		texp2->r=0;
		texp2->w=texw;

		// Finally, specify a vertex
		vertp->x=pnt->p3_sx+x_add;
		vertp->y=pnt->p3_sy+y_add;

		//@@vertp->z=-((pnt->p3_z+Z_bias)/OpenGL_state.cur_far_z);
		vertp->z = -max(0,min(1.0,1.0-(1.0/(pnt->p3_z+Z_bias))));

	}

	// make sure our bitmap is ready to be drawn
	opengl_MakeBitmapCurrent (handle,map_type,0);
	opengl_MakeWrapTypeCurrent (handle,map_type,0);
	opengl_MakeFilterTypeCurrent(handle,map_type,0);

	// make sure our bitmap is ready to be drawn
	opengl_MakeBitmapCurrent (Overlay_map,MAP_TYPE_LIGHTMAP,1);
	opengl_MakeWrapTypeCurrent (Overlay_map,MAP_TYPE_LIGHTMAP,1);
	opengl_MakeFilterTypeCurrent(Overlay_map,MAP_TYPE_LIGHTMAP,1);

	opengl_SetMultitextureBlendMode (true);

	// And draw!
#ifdef __LINUX__
	if(OpenGL_UseLists)
	{
#endif
		dglDrawArrays (GL_POLYGON,0,nv);
#ifdef __LINUX__
	}else
	{
		dglBegin(GL_POLYGON);
		for(i=0;i<nv;i++)
		{
			dglTexCoord4fv((GLfloat *)&GL_tex_coords[i]);
			dglColor4fv((GLfloat *)&GL_colors[i]);
			dglVertex3fv((GLfloat *)&GL_verts[i]);
		}
		dglEnd();
	}
#endif

	OpenGL_polys_drawn++;
	OpenGL_verts_processed+=nv;

	CHECK_ERROR(10)
}

void opengl_DrawFlatPolygon(g3Point **p,int nv)
{
	int x_add=OpenGL_state.clip_x1;
	int y_add=OpenGL_state.clip_y1;
	float fr,fg,fb;
	int i;

	if (OpenGL_multitexture)
		opengl_SetMultitextureBlendMode (false);

	float alpha=Alpha_multiplier*OpenGL_Alpha_factor;

	fr=GR_COLOR_RED(OpenGL_state.cur_color);
	fg=GR_COLOR_GREEN(OpenGL_state.cur_color);
	fb=GR_COLOR_BLUE(OpenGL_state.cur_color);
	fr/=255.0;
	fg/=255.0;
	fb/=255.0;

	// And draw!
	dglBegin (GL_POLYGON);
	for (i=0;i<nv;i++)
	{
		g3Point *pnt=p[i];

		if (OpenGL_state.cur_alpha_type & ATF_VERTEX)
			alpha=pnt->p3_a*Alpha_multiplier*OpenGL_Alpha_factor;

		// If we have a lighting model, apply the correct lighting!
		if (OpenGL_state.cur_light_state!=LS_NONE)
		{
			// Do lighting based on intesity (MONO) or colored (RGB)
			if (OpenGL_state.cur_color_model==CM_MONO)
				dglColor4f (pnt->p3_l,pnt->p3_l,pnt->p3_l,alpha);
			else
			{
				dglColor4f (pnt->p3_r,pnt->p3_g,pnt->p3_b,alpha);
			}

		}
		else
			dglColor4f (fr,fg,fb,alpha);

		// Finally, specify a vertex
		//@@dglVertex3f (pnt->p3_sx+x_add,pnt->p3_sy+y_add,-(pnt->p3_z/OpenGL_state.cur_far_z));
		float z = max(0,min(1.0,1.0-(1.0/(pnt->p3_z+Z_bias))));
		dglVertex3f (pnt->p3_sx+x_add,pnt->p3_sy+y_add,-z);
	}

	dglEnd();
	CHECK_ERROR(11)
		OpenGL_polys_drawn++;
	OpenGL_verts_processed+=nv;
}

// Sets the gamma correction value
void opengl_SetGammaValue( float val )
{
	if( WindowGL )
		return;

	OpenGL_preferred_state.gamma = val;
	mprintf ((0,"Setting gamma to %f\n",val));

#if defined(WIN32)
	WORD rampvals[3*256];

	for (int i=0;i<256;i++)
	{
		float norm=(float)i/255.0f;

		float newval = powf(norm,1.0f/val);

		newval*=65535;

		newval=min(65535,newval);

		rampvals[i]=newval;
		rampvals[i+256]=newval;
		rampvals[i+512]=newval;
	}

	SetDeviceGammaRamp(hOpenGLDC,(LPVOID)rampvals);
#endif
}

// Resets the texture cache
void opengl_ResetCache(void)
{
	if( OpenGL_cache_initted )
	{
		mem_free(OpenGL_lightmap_remap);
		mem_free(OpenGL_bitmap_remap);
		mem_free(OpenGL_lightmap_states);
		mem_free(OpenGL_bitmap_states);
		OpenGL_cache_initted=0;
	}

	opengl_InitCache();
}

ubyte opengl_Framebuffer_ready=0;
chunked_bitmap opengl_Chunked_bitmap;

void opengl_ChangeChunkedBitmap(int bm_handle, chunked_bitmap *chunk)
{
	int bw=bm_w(bm_handle,0);
	int bh=bm_h(bm_handle,0);

	//determine optimal size of the square bitmaps
	float fopt=128.0f;
	int iopt;

	//find the smallest dimension and base off that
	int smallest = min(bw,bh);

	if(smallest<=32)
		fopt=32;
	else
		if(smallest<=64)
			fopt=64;
		else
			fopt=128;	

	iopt=(int)fopt;

	// Get how many pieces we need across and down
	float temp=bw/fopt;
	int how_many_across=temp;
	if ((temp-how_many_across)>0)
		how_many_across++;

	temp=bh/fopt;
	int how_many_down=temp;
	if ((temp-how_many_down)>0)
		how_many_down++;

	ASSERT (how_many_across>0);
	ASSERT (how_many_down>0);

	// Now go through our big bitmap and partition it into pieces
	ushort *src_data=bm_data(bm_handle,0);
	ushort *sdata;
	ushort *ddata;

	int shift;
	switch(iopt)
	{
	case 32:
		shift = 5;
		break;
	case 64:
		shift = 6;
		break;
	case 128:
		shift = 7;
		break;
	default:
		Int3(); //Get Jeff
		break;
	}
	int maxx,maxy;
	int windex,hindex;
	int s_y,s_x,d_y,d_x;

	for(hindex=0;hindex<how_many_down;hindex++){
		for(windex=0;windex<how_many_across;windex++){
			//loop through the chunks
			//find end x and y
			if(windex<how_many_across-1)
				maxx=iopt;
			else
				maxx = bw - (windex<<shift);
			if(hindex<how_many_down-1)
				maxy=iopt;
			else
				maxy = bh - (hindex<<shift);

			//find the starting source x and y
			s_x = (windex<<shift);
			s_y = (hindex<<shift);

			//get the pointers pointing to the right spot
			ddata = bm_data(chunk->bm_array[hindex*how_many_across+windex],0);
			GameBitmaps[chunk->bm_array[hindex*how_many_across+windex]].flags|=BF_CHANGED;
			sdata = &src_data[s_y * bw + s_x];

			//copy the data
			for(d_y=0;d_y<maxy;d_y++){
				for(d_x=0;d_x<maxx;d_x++){
					ddata[d_x] = sdata[d_x];
				}//end for d_x
				sdata += bw;
				ddata += iopt;
			}//end for d_y

		}//end for windex
	}//end for hindex
}

#ifdef __LINUX__
void CreateFullScreenWindow(Display *dpy,Window rootwin,Window window,int DisplayScreen,int DisplayWidth,int DisplayHeight)
{
	// see if a motif based window manager is running.  do this by   
	// getting the _MOTIF_WM_INFO property on the root window.  if   
	// it exists then make sure the window it refers to also exists.   
	Bool noWM,isMWMRunning = False;
	Atom a = XInternAtom(dpy, "_MOTIF_WM_INFO", True);   
	if (a)
	{
		struct BzfPropMotifWmInfo
		{
		public:
			long  flags;
			Window  wmWindow;
		};

		Atom type;
		int format;
		unsigned long nitems;
		unsigned long bytes_after;
		long* mwmInfo;

		XGetWindowProperty(dpy,rootwin,a, 0, 4, False,a, &type, &format, &nitems, &bytes_after,(unsigned char**)&mwmInfo);

		if (mwmInfo)
		{
			// get the mwm window from the properties
			const Window mwmWindow = ((BzfPropMotifWmInfo*)mwmInfo)->wmWindow;
			XFree(mwmInfo);

			// verify that window is a child of the root window
			Window root, parent, *children;
			unsigned int numChildren;
			if (XQueryTree(dpy, mwmWindow, &root, &parent,   &children, &numChildren)) 
			{
				XFree(children);
				if (parent == rootwin)
					isMWMRunning = True;
			}
		}
	}

	// turning off decorations is window manager dependent
	if (isMWMRunning)
	{
		fprintf(stdout,"Motif Window Manager\n");
		// it's a Motif based window manager
		long hints[4];
		hints[0] = 0;
		hints[1] = 0;
		hints[2] = 0;
		hints[3] = 0;
		long* xhints;

		a = XInternAtom(dpy, "_MOTIF_WM_HINTS", False);

		{
			// get current hints
			Atom type;
			int format;
			unsigned long nitems;
			unsigned long bytes_after;

			XGetWindowProperty(dpy, window, a, 0, 4, False,a, &type, &format, &nitems, &bytes_after,(unsigned char**)&xhints);

			if (xhints)
			{
				hints[0] = xhints[0];
				hints[1] = xhints[1];
				hints[2] = xhints[2];
				hints[3] = xhints[3];
				XFree(xhints);
			}
		}

		hints[0] |= 2;  // MWM_HINTS_DECORATIONS flag
		hints[2] = 0;  // no decorations

		XChangeProperty(dpy, window, a, a, 32,PropModeReplace, (unsigned char*)&hints, 4);

		noWM = False;
	}else
	{
		// non-motif window manager.  use override redirect to prevent window     
		// manager from messing with our appearance.  unfortunately, the user     
		// can't move or iconify the window either.
		XSetWindowAttributes attr;
		attr.override_redirect = True;
		XChangeWindowAttributes(dpy,window, CWOverrideRedirect, &attr);
		noWM = True;
	}

	// now set position and size
	long dummy;
	XSizeHints xsh;
	XGetWMNormalHints(dpy, window, &xsh, &dummy);   
	xsh.x = 0;
	xsh.y = 0;
	xsh.base_width = DisplayWidth;
	xsh.base_height = DisplayHeight;
	xsh.flags |= USPosition | PPosition | PBaseSize;

	{
		char *env;

		env=getenv("MESA_GLX_FX");
		if (env && *env=='f') // Full screen Mesa mode
		{
			xsh.base_width=640;
			xsh.base_height=480;
		}else
		{
			// Check if we have the XF86 vidmode extension, for virtual roots
			if (LinuxVideoMode.QueryExtension(dpy))
			{
				int dotclock;
				XF86VidModeModeLine modeline;

				LinuxVideoMode.GetModeLine(dpy,DisplayScreen,&dotclock,&modeline);

				xsh.base_width=modeline.hdisplay;
				xsh.base_height=modeline.vdisplay;

				//if (modeline.c_private)
				//	XFree(modeline.c_private);
			}
		}
	}

	// set the window manager hints for the window and move and resize
	// the window (overriding the window manager).  we have to override
	// the window manager for the move and resize because the window
	// *must* be the correct size when we first bind the OpenGL context
	// for the 3Dfx driver since it cannot handle later resizes.  if we
	// don't override the window manager, our move and resize will
	// probably be ignored.
	if (!noWM)
	{
		XSetWindowAttributes attr;
		attr.override_redirect = True;
		XChangeWindowAttributes(dpy,window, CWOverrideRedirect, &attr);
	}

	XSetWMNormalHints(dpy, window, &xsh);
	XMoveResizeWindow(dpy, window, xsh.x, xsh.y, xsh.base_width, xsh.base_height);

	if (!noWM)
	{
		XSetWindowAttributes attr;
		attr.override_redirect = False;
		XChangeWindowAttributes(dpy,window, CWOverrideRedirect, &attr);
	}

	XSync(dpy, False);

}
#endif

// Tells the software renderer whether or not to use mipping
void rend_SetMipState( sbyte mipstate )
{
}

void rend_SetInitOptions(void)
{
	if( FindArg("-forcelightmaps") )
	{
		NoLightmaps=false;
	}

	if( FindArg("-nolightmaps") )
	{
		NoLightmaps=true;
		UseMultitexture=false;
	}

	if( FindArg("-NoMultitexture") )
	{
		UseMultitexture=false;
	}
}

// Init our renderer
int rend_Init(renderer_type state, oeApplication *app,renderer_preferred_state *pref_state)
{
#ifndef DEDICATED_ONLY
	int retval=0;
	rend_SetRendererType( state );
	if( !Renderer_initted )
	{
		if( !Renderer_close_flag )
		{
			atexit( rend_Close );
			Renderer_close_flag = 1;
		}

		Renderer_initted=1;
	}

	if( OpenGL_window_initted )
	{
		rend_CloseOpenGLWindow();
		OpenGL_window_initted=0;
	}

	mprintf ((0,"Renderer init is set to %d\n",Renderer_initted));
	NoLightmaps=false;
	UseHardware=1;
	StateLimited=1;
	UseMultitexture=0;
	UseWBuffer=0;

#ifndef OEM_V3
	int flags = app->flags();
	if( flags & OEAPP_WINDOWED )
	{
		// initialize for windowed
		retval = rend_InitOpenGLWindow( app, pref_state );
	}
	else
	{
		// initialize for full screen
		retval=opengl_Init( app, pref_state );
	}
#endif

	if (retval!=0)
	{
		rend_SetInitOptions();
	}
	return retval;
#else
	return 0;
#endif //#ifdef DEDICATED_ONLY
}

void rend_Close(void)
{
	mprintf((0,"CLOSE:Renderer init is set to %d\n",Renderer_initted));
	if(!Renderer_initted)
		return;

	if( OpenGL_window_initted )
	{
		if( Renderer_type != RENDERER_OPENGL )
		{
			rend_CloseOpenGLWindow();
		}
		OpenGL_window_initted = 0;
	}

	opengl_Close();

	Renderer_initted=0;
}

#ifdef DEDICATED_ONLY

void rend_DrawPolygon3D( int , g3Point **, int , int ){ }
void rend_DrawPolygon2D( int , g3Point **, int , int ){ }

#else

// Takes nv vertices and draws the 3D polygon defined by those vertices.
// Uses bitmap "handle" as a texture
void rend_DrawPolygon3D( int handle, g3Point **p, int nv, int map_type )
{
	g3Point *pnt;
	int i;
	float fr,fg,fb;
	float alpha;
	vector *vertp;
	color_array *colorp;
	tex_array *texp;

	ASSERT (nv<100);

	if (OpenGL_state.cur_texture_quality==0)
	{
		opengl_DrawFlatPolygon (p,nv);
		return;
	}

	if (Overlay_type!=OT_NONE && OpenGL_multitexture)
	{
		opengl_DrawMultitexturePolygon (handle,p,nv,map_type);
		return;
	}

	int x_add=OpenGL_state.clip_x1;
	int y_add=OpenGL_state.clip_y1;

	if (OpenGL_state.cur_light_state==LS_FLAT_GOURAUD)
	{
		fr=GR_COLOR_RED(OpenGL_state.cur_color)/255.0;
		fg=GR_COLOR_GREEN(OpenGL_state.cur_color)/255.0;
		fb=GR_COLOR_BLUE(OpenGL_state.cur_color)/255.0;
	}

	if (OpenGL_multitexture)
		opengl_SetMultitextureBlendMode (false);

	// make sure our bitmap is ready to be drawn
	opengl_MakeBitmapCurrent (handle,map_type,0);
	opengl_MakeWrapTypeCurrent (handle,map_type,0);
	opengl_MakeFilterTypeCurrent(handle,map_type,0);

	alpha=Alpha_multiplier*OpenGL_Alpha_factor;

	vertp=&GL_verts[0];
	texp=&GL_tex_coords[0];
	colorp=&GL_colors[0];

	// Specify our coordinates
	for (i=0;i<nv;i++,vertp++,texp++,colorp++)
	{
		pnt=p[i];


		////////////////////////////////////////////
		if( pnt->p3_flags&PF_ORIGPOINT )
		{
			// get the original point
			float origPoint[4];
			origPoint[0] = pnt->p3_vecPreRot.x;
			origPoint[1] = pnt->p3_vecPreRot.y;
			origPoint[2] = pnt->p3_vecPreRot.z;
			origPoint[3] = 1.0f;

			// transform by the full transform
			float view[4];
			g3_TransformVert( view, origPoint, gTransformFull );


			vector tempv = pnt->p3_vecPreRot - View_position;
			vector testPt = tempv * Unscaled_matrix;

			float screenX = pnt->p3_sx + x_add;
			float screenY = pnt->p3_sy + y_add;

			// normalize
			float oOW = 1.0f / view[3];
			view[0] *= oOW;
			view[1] *= oOW;
			view[2] *= oOW;

			oOW *= 1.0f;
		}
		////////////////////////////////////////////

		if (OpenGL_state.cur_alpha_type & ATF_VERTEX)
			alpha=pnt->p3_a*Alpha_multiplier*OpenGL_Alpha_factor;

		// If we have a lighting model, apply the correct lighting!
		if (OpenGL_state.cur_light_state!=LS_NONE)
		{
			if (OpenGL_state.cur_light_state==LS_FLAT_GOURAUD)
			{
				colorp->r=fr;
				colorp->g=fg;
				colorp->b=fb;
				colorp->a=alpha;
			}
			else

				// Do lighting based on intesity (MONO) or colored (RGB)
				if (OpenGL_state.cur_color_model==CM_MONO)
				{
					colorp->r=pnt->p3_l;
					colorp->g=pnt->p3_l;
					colorp->b=pnt->p3_l;
					colorp->a=alpha;
				}
				else
				{
					colorp->r=pnt->p3_r;
					colorp->g=pnt->p3_g;
					colorp->b=pnt->p3_b;
					colorp->a=alpha;
				}
		}
		else
		{
			colorp->r=1;
			colorp->g=1;
			colorp->b=1;
			colorp->a=alpha;
		}

#ifdef __LINUX__
		//MY TEST HACK...MAYBE BAD DRIVERS? OR MAYBE THIS IS
		//HOW IT SHOULD BE DONE (STILL BUGGY)
		// Texture this polygon!
		float texw=1.0/(pnt->p3_z+Z_bias);
		if(OpenGL_TextureHack)
		{
			texp->s=pnt->p3_u;
			texp->t=pnt->p3_v;
		}else
		{
			texp->s=pnt->p3_u*texw;
			texp->t=pnt->p3_v*texw;
		}
		texp->r=0;
		texp->w=texw;
#else
		// Texture this polygon!
		float texw=1.0/(pnt->p3_z+Z_bias);
		texp->s=pnt->p3_u*texw;
		texp->t=pnt->p3_v*texw;
		texp->r=0;
		texp->w=texw;
#endif
		// Finally, specify a vertex
		vertp->x=pnt->p3_sx+x_add;
		vertp->y=pnt->p3_sy+y_add;

		//@@float z=(pnt->p3_z+Z_bias)/OpenGL_state.cur_far_z;
		float z = max(0,min(1.0,1.0-(1.0/(pnt->p3_z+Z_bias))));
		vertp->z=-z;
	}

	// And draw!
#ifdef __LINUX__
	if(OpenGL_UseLists)
	{
#endif
		dglDrawArrays (GL_POLYGON,0,nv);
#ifdef __LINUX__
	}else
	{
		dglBegin(GL_POLYGON);
		for(i=0;i<nv;i++)
		{
			dglTexCoord4fv((GLfloat *)&GL_tex_coords[i]);
			dglColor4fv((GLfloat *)&GL_colors[i]);
			dglVertex3fv((GLfloat *)&GL_verts[i]);
		}
		dglEnd();
	}
#endif
	OpenGL_polys_drawn++;
	OpenGL_verts_processed+=nv;

	CHECK_ERROR(10)

		// If there is a lightmap to draw, draw it as well
		if (Overlay_type!=OT_NONE)
		{
			return;	// Temp fix until I figure out whats going on
			Int3();	// Shouldn't reach here
		}
}

// Takes nv vertices and draws the 2D polygon defined by those vertices.
// Uses bitmap "handle" as a texture
void rend_DrawPolygon2D( int handle, g3Point **p, int nv )
{
	ASSERT( nv < 100 );
	ASSERT( Overlay_type == OT_NONE );

	if( OpenGL_multitexture )
	{
		opengl_SetMultitextureBlendMode( false );
	}

	int xAdd = OpenGL_state.clip_x1;
	int yAdd = OpenGL_state.clip_y1;

	float fr,fg,fb;
	if( OpenGL_state.cur_light_state == LS_FLAT_GOURAUD || OpenGL_state.cur_texture_quality == 0 )
	{
		float scale = 1.0f / 255.0f;
		fr = GR_COLOR_RED(OpenGL_state.cur_color)   * scale;
		fg = GR_COLOR_GREEN(OpenGL_state.cur_color) * scale;
		fb = GR_COLOR_BLUE(OpenGL_state.cur_color)  * scale;
	}

	// make sure our bitmap is ready to be drawn
	opengl_MakeBitmapCurrent( handle, MAP_TYPE_BITMAP, 0 );
	opengl_MakeWrapTypeCurrent( handle, MAP_TYPE_BITMAP, 0 );
	opengl_MakeFilterTypeCurrent( handle, MAP_TYPE_BITMAP, 0 );

	float alpha = Alpha_multiplier * OpenGL_Alpha_factor;

	vector *vertp       = &GL_verts[0];
	tex_array *texp     = &GL_tex_coords[0];
	color_array *colorp = &GL_colors[0];

	// Specify our coordinates
	int i;
	for( i = 0; i < nv; ++i, ++vertp, ++texp, ++colorp )
	{
		g3Point *pnt = p[i];

		if( OpenGL_state.cur_alpha_type & ATF_VERTEX )
		{
			// the alpha should come from the vertex
			alpha = pnt->p3_a * Alpha_multiplier * OpenGL_Alpha_factor;
		}

		// If we have a lighting model, apply the correct lighting!
		if( OpenGL_state.cur_light_state == LS_FLAT_GOURAUD || OpenGL_state.cur_texture_quality == 0 )
		{
			// pull the color from the constant color data
			colorp->r=fr;
			colorp->g=fg;
			colorp->b=fb;
			colorp->a=alpha;
		}
		else if( OpenGL_state.cur_light_state != LS_NONE )
		{
			// Do lighting based on intensity (MONO) or colored (RGB)
			if( OpenGL_state.cur_color_model == CM_MONO )
			{
				colorp->r=pnt->p3_l;
				colorp->g=pnt->p3_l;
				colorp->b=pnt->p3_l;
				colorp->a=alpha;
			}
			else
			{
				colorp->r=pnt->p3_r;
				colorp->g=pnt->p3_g;
				colorp->b=pnt->p3_b;
				colorp->a=alpha;
			}
		}
		else
		{
			// force white
			colorp->r=1.0f;
			colorp->g=1.0f;
			colorp->b=1.0f;
			colorp->a=alpha;
		}

		texp->s = pnt->p3_u;
		texp->t = pnt->p3_v;
		texp->r = 0.0f;
		texp->w = 1.0f;

		// Finally, specify a vertex
		vertp->x = pnt->p3_sx + xAdd;
		vertp->y = pnt->p3_sy + yAdd;
		vertp->z = 0.0f;
	}

	// And draw!
	#ifdef __LINUX__
	if(OpenGL_UseLists)
	{
	#endif
		if( OpenGL_state.cur_texture_quality == 0 )
		{
			// force disable textures
			dglDisableClientState( GL_TEXTURE_COORD_ARRAY );
		}

		// draw the data in the arrays
		dglDrawArrays( GL_POLYGON, 0, nv );

		if( OpenGL_state.cur_texture_quality == 0 )
		{
			// re-enable textures
			dglEnableClientState( GL_TEXTURE_COORD_ARRAY );
		}

	#ifdef __LINUX__
	}
	else
	{
		dglBegin(GL_POLYGON);
		for( i = 0; i < nv; ++i )
		{
			if( OpenGL_state.cur_texture_quality != 0 )
			{
				dglTexCoord4fv((GLfloat *)&GL_tex_coords[i]);
			}
			dglColor4fv((GLfloat *)&GL_colors[i]);
			dglVertex3fv((GLfloat *)&GL_verts[i]);
		}
		dglEnd();
	}
	#endif

	OpenGL_polys_drawn++;
	OpenGL_verts_processed+=nv;

	CHECK_ERROR(10)
}

#endif // DEDICATED_ONLY

void rend_SetFlatColor( ddgr_color color )
{
	OpenGL_state.cur_color=color;
}

// Sets the fog state to TRUE or FALSE
void rend_SetFogState(sbyte state)
{
	if (state==OpenGL_state.cur_fog_state)
		return;	// No redundant state setting

	OpenGL_state.cur_fog_state=state;

	if (state==1)
	{
		dglEnable(GL_FOG);
	}
	else
	{
		dglDisable(GL_FOG);
	}
}

// Sets the near and far plane of fog
void rend_SetFogBorders(float nearz, float farz)
{
	// Sets the near and far plane of fog
	// Note, the opengl_Far_z variable must be valid for this function to work correctly
	float fog_start,fog_end;

	fog_start = max(0,min(1.0,1.0-(1.0/nearz)));
	fog_end = max(0,min(1.0,1.0-(1.0/farz)));

	OpenGL_state.cur_fog_start=fog_start;
	OpenGL_state.cur_fog_end=fog_end;

	dglFogi(GL_FOG_MODE,GL_LINEAR);
	dglFogf(GL_FOG_START,fog_start);
	dglFogf(GL_FOG_END,fog_end);
}

void rend_SetRendererType(renderer_type state)
{
	Renderer_type=state;
	mprintf((0,"RendererType is set to %d.\n",state));
}

void rend_SetLighting(light_state state)
{
	if (state==OpenGL_state.cur_light_state)
		return;	// No redundant state setting

	if (OpenGL_multitexture && Last_texel_unit_set!=0)
	{
#if defined(WIN32)
		oglActiveTextureARB (GL_TEXTURE0_ARB+0);
		Last_texel_unit_set=0;
#endif
	}

	OpenGL_sets_this_frame[4]++;

	switch (state)
	{
	case LS_NONE:
		dglShadeModel (GL_SMOOTH);
		OpenGL_state.cur_light_state=LS_NONE;
		break;
	case LS_FLAT_GOURAUD:
		dglShadeModel (GL_SMOOTH);
		OpenGL_state.cur_light_state=LS_FLAT_GOURAUD;
		break;
	case LS_GOURAUD:
	case LS_PHONG:
		dglShadeModel (GL_SMOOTH);
		OpenGL_state.cur_light_state=LS_GOURAUD;
		break;
	default:
		Int3();
		break;
	}

	CHECK_ERROR(13)
}

void rend_SetColorModel(color_model state)
{
	switch (state)
	{
	case CM_MONO:
		OpenGL_state.cur_color_model=CM_MONO;
		break;
	case CM_RGB:
		OpenGL_state.cur_color_model=CM_RGB;
		break;
	default:
		Int3();
		break;
	}
}

void rend_SetTextureType(texture_type state)
{
	if (state==OpenGL_state.cur_texture_type)
		return;	// No redundant state setting

	if (OpenGL_multitexture && Last_texel_unit_set!=0)
	{
#if defined(WIN32)
		oglActiveTextureARB (GL_TEXTURE0_ARB+0);
		Last_texel_unit_set=0;
#endif
	}

	OpenGL_sets_this_frame[3]++;

	switch (state)
	{
	case TT_FLAT:
		dglDisable (GL_TEXTURE_2D);
		OpenGL_state.cur_texture_quality=0;
		break;
	case TT_LINEAR:
	case TT_LINEAR_SPECIAL:
	case TT_PERSPECTIVE:
	case TT_PERSPECTIVE_SPECIAL:
		dglEnable (GL_TEXTURE_2D);
		OpenGL_state.cur_texture_quality=2;
		break;
	default:
		Int3();	// huh? Get Jason
		break;
	}

	CHECK_ERROR(12)
	OpenGL_state.cur_texture_type=state;
}

void rend_StartFrame(int x1,int y1,int x2,int y2,int clear_flags)
{
	if( clear_flags & RF_CLEAR_ZBUFFER )
	{
		dglClear(GL_DEPTH_BUFFER_BIT);
	}
	OpenGL_state.clip_x1=x1;
	OpenGL_state.clip_y1=y1;
	OpenGL_state.clip_x2=x2;
	OpenGL_state.clip_y2=y2;
}

// Flips the screen
void rend_Flip(void)
{
#ifndef RELEASE
	int i;

	RTP_INCRVALUE(texture_uploads,OpenGL_uploads);
	RTP_INCRVALUE(polys_drawn,OpenGL_polys_drawn);

	mprintf_at ((1,1,0,"Uploads=%d    Polys=%d   Verts=%d   ",OpenGL_uploads,OpenGL_polys_drawn,OpenGL_verts_processed));
	mprintf_at ((1,2,0,"Sets= 0:%d   1:%d   2:%d   3:%d   ",OpenGL_sets_this_frame[0],OpenGL_sets_this_frame[1],OpenGL_sets_this_frame[2],OpenGL_sets_this_frame[3]));
	mprintf_at ((1,3,0,"Sets= 4:%d   5:%d  ",OpenGL_sets_this_frame[4],OpenGL_sets_this_frame[5]));
	for (i=0;i<10;i++)
		OpenGL_sets_this_frame[i]=0;
#endif

	OpenGL_last_frame_polys_drawn = OpenGL_polys_drawn;
	OpenGL_last_frame_verts_processed = OpenGL_verts_processed;
	OpenGL_last_uploaded = OpenGL_uploads;

	OpenGL_uploads=0;
	OpenGL_polys_drawn=0;
	OpenGL_verts_processed=0;

#if defined(WIN32)	
	SwapBuffers ((HDC)hOpenGLDC);
#elif defined(__LINUX__)
	glXWaitGL();
	glXSwapBuffers(OpenGL_Display,OpenGL_Window);
#endif
}

void rend_EndFrame(void)
{
}

// draws a scaled 2d bitmap to our buffer
void rend_DrawScaledBitmap(int x1,int y1,int x2,int y2,
							int bm,float u0,float v0,float u1,float v1,int color,float *alphas)
{
	g3Point *ptr_pnts[4];
	g3Point pnts[4];
	float r,g,b;
	if (color!=-1)
	{
		r=GR_COLOR_RED(color)/255.0;
		g=GR_COLOR_GREEN(color)/255.0;
		b=GR_COLOR_BLUE(color)/255.0;
	}
	for (int i=0;i<4;i++)
	{
		if (color==-1)
			pnts[i].p3_l=1.0;
		else
		{
			pnts[i].p3_r=r;
			pnts[i].p3_g=g;
			pnts[i].p3_b=b;
		}
		if (alphas)
		{
			pnts[i].p3_a=alphas[i];
		}

		pnts[i].p3_z=1.0f;	
		pnts[i].p3_flags=PF_PROJECTED;
	}

	pnts[0].p3_sx=x1;
	pnts[0].p3_sy=y1;
	pnts[0].p3_u=u0;
	pnts[0].p3_v=v0;
	pnts[1].p3_sx=x2;
	pnts[1].p3_sy=y1;
	pnts[1].p3_u=u1;
	pnts[1].p3_v=v0;
	pnts[2].p3_sx=x2;
	pnts[2].p3_sy=y2;
	pnts[2].p3_u=u1;
	pnts[2].p3_v=v1;
	pnts[3].p3_sx=x1;
	pnts[3].p3_sy=y2;
	pnts[3].p3_u=u0;
	pnts[3].p3_v=v1;
	ptr_pnts[0]=&pnts[0];
	ptr_pnts[1]=&pnts[1];
	ptr_pnts[2]=&pnts[2];
	ptr_pnts[3]=&pnts[3];
	rend_SetTextureType( TT_LINEAR );
	rend_DrawPolygon2D( bm, ptr_pnts, 4 );
}

// Sets where the software renderer should write to
void rend_SetSoftwareParameters(float aspect,int width,int height,int pitch,ubyte *framebuffer)
{
}

// Sets the state of bilinear filtering for our textures
void rend_SetFiltering(sbyte state)
{
#ifndef RELEASE
	if (Fast_test_render)
		state=0;
#endif

	OpenGL_state.cur_bilinear_state=state;
}

// Sets the state of z-buffering to on or off
void rend_SetZBufferState(sbyte state)
{
#ifndef RELEASE
	if (Fast_test_render)
		state=0;
#endif

	if (state==OpenGL_state.cur_zbuffer_state)
		return;	// No redundant state setting

	OpenGL_sets_this_frame[5]++;
	OpenGL_state.cur_zbuffer_state=state;

	//mprintf ((0,"OPENGL: Setting zbuffer state to %d.\n",state)); 

	if (state)
	{
		dglEnable (GL_DEPTH_TEST);
		dglDepthFunc (GL_LEQUAL);
	}
	else
		dglDisable (GL_DEPTH_TEST);

	CHECK_ERROR(14)
}

// Sets the near and far planes for z buffer
void rend_SetZValues(float nearz,float farz)
{
	OpenGL_state.cur_near_z=nearz;
	OpenGL_state.cur_far_z=farz;

	//mprintf ((0,"OPENGL:Setting depth range to %f - %f\n",nearz,farz));

	//JEFF: glDepthRange must take parameters [0,1]
	//It is set in init
	//@@dglDepthRange (0,farz);	
}

// Sets a bitmap as a overlay map to rendered on top of the next texture map
// a -1 value indicates no overlay map
void rend_SetOverlayMap(int handle)
{
	Overlay_map=handle;
}

void rend_SetOverlayType(ubyte type)
{
	Overlay_type=type;
}

// Clears the display to a specified color
void rend_ClearScreen(ddgr_color color)
{
	int r=(color>>16 & 0xFF);
	int g=(color>>8 & 0xFF);
	int b=(color & 0xFF);

	dglClearColor ((float)r/255.0f,(float)g/255.0f,(float)b/255.0f,0);

	dglClear (GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
}

// Clears the zbuffer for the screen
void rend_ClearZBuffer(void)
{
	dglClear(GL_DEPTH_BUFFER_BIT);
}

// Clears the zbuffer for the screen
void rend_ResetCache(void)
{
	mprintf((0,"Resetting texture cache!\n"));
	opengl_ResetCache ();
}

// Fills a rectangle on the display
void rend_FillRect(ddgr_color color,int x1,int y1,int x2,int y2)
{
	int r=GR_COLOR_RED(color);
	int g=GR_COLOR_GREEN(color);
	int b=GR_COLOR_BLUE(color);

	int width=x2-x1;
	int height=y2-y1;

	x1+=OpenGL_state.clip_x1;
	y1+=OpenGL_state.clip_y1;

	dglEnable (GL_SCISSOR_TEST);
	dglScissor (x1,OpenGL_state.screen_height-(height+y1),width,height);
	dglClearColor ((float)r/255.0,(float)g/255.0,(float)b/255.0,0);
	dglClear (GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

	width=OpenGL_state.clip_x2-OpenGL_state.clip_x1;
	height=OpenGL_state.clip_y2-OpenGL_state.clip_y1;

	dglScissor (OpenGL_state.clip_x1,OpenGL_state.screen_height-(OpenGL_state.clip_y1+height),width,height);
	dglDisable (GL_SCISSOR_TEST);
}

// Sets a pixel on the display
void rend_SetPixel(ddgr_color color,int x,int y)
{
	int r=(color>>16 & 0xFF);
	int g=(color>>8 & 0xFF);
	int b=(color & 0xFF);

	dglColor3ub (r,g,b);

	dglBegin (GL_POINTS);
	dglVertex2i (x,y);
	dglEnd();
}

// Sets a pixel on the display
ddgr_color rend_GetPixel(int x,int y)
{
	ddgr_color color[4];
	dglReadPixels (x,(OpenGL_state.screen_height-1)-y,1,1,GL_RGBA,GL_UNSIGNED_BYTE,(GLvoid *)color);
	return color[0];
}

void rend_FillCircle(ddgr_color col, int x, int y, int rad)
{
}

void rend_DrawCircle(int x, int y, int rad)
{
}

// Sets up a font character to draw.  We draw our fonts as pieces of textures
void rend_DrawFontCharacter(int bm_handle,int x1,int y1,int x2,int y2,float u,float v,float w,float h)
{
	g3Point *ptr_pnts[4];
	g3Point pnts[4];
	for (int i=0;i<4;i++)
	{
		pnts[i].p3_z=1;	// Make REALLY close!
		pnts[i].p3_flags=PF_PROJECTED;
		ptr_pnts[i]=&pnts[i];
	}
	pnts[0].p3_sx=x1;
	pnts[0].p3_sy=y1;
	pnts[0].p3_u=u;
	pnts[0].p3_v=v;
	pnts[1].p3_sx=x2;
	pnts[1].p3_sy=y1;
	pnts[1].p3_u=u+w;
	pnts[1].p3_v=v;
	pnts[2].p3_sx=x2;
	pnts[2].p3_sy=y2;
	pnts[2].p3_u=u+w;
	pnts[2].p3_v=v+h;
	pnts[3].p3_sx=x1;
	pnts[3].p3_sy=y2;
	pnts[3].p3_u=u;
	pnts[3].p3_v=v+h;
	rend_DrawPolygon2D(bm_handle,ptr_pnts,4);
}

// Draws a line
void rend_DrawLine(int x1,int y1,int x2,int y2)
{
	sbyte atype;
	light_state ltype;
	texture_type ttype;
	int color=OpenGL_state.cur_color;

	int r=GR_COLOR_RED(color);
	int g=GR_COLOR_GREEN(color);
	int b=GR_COLOR_BLUE(color);

	atype=OpenGL_state.cur_alpha_type;					
	ltype=OpenGL_state.cur_light_state;					
	ttype=OpenGL_state.cur_texture_type;

	rend_SetAlphaType (AT_ALWAYS);
	rend_SetLighting (LS_NONE);
	rend_SetTextureType (TT_FLAT);


	dglBegin (GL_LINES);
	dglColor4ub (r,g,b,255);
	dglVertex2i (x1+OpenGL_state.clip_x1,y1+OpenGL_state.clip_y1);
	dglColor4ub (r,g,b,255);
	dglVertex2i (x2+OpenGL_state.clip_x1,y2+OpenGL_state.clip_y1);
	dglEnd();

	rend_SetAlphaType (atype);
	rend_SetLighting(ltype);
	rend_SetTextureType (ttype);
}

// Sets the argb characteristics of the font characters.  color1 is the upper left and proceeds clockwise
void rend_SetCharacterParameters (ddgr_color color1,ddgr_color color2,ddgr_color color3,ddgr_color color4)
{
	rend_FontRed[0]=(float)(GR_COLOR_RED(color1)/255.0f);
	rend_FontRed[1]=(float)(GR_COLOR_RED(color2)/255.0f);
	rend_FontRed[2]=(float)(GR_COLOR_RED(color3)/255.0f);
	rend_FontRed[3]=(float)(GR_COLOR_RED(color4)/255.0f);
	rend_FontGreen[0]=(float)(GR_COLOR_GREEN(color1)/255.0f);
	rend_FontGreen[1]=(float)(GR_COLOR_GREEN(color2)/255.0f);
	rend_FontGreen[2]=(float)(GR_COLOR_GREEN(color3)/255.0f);
	rend_FontGreen[3]=(float)(GR_COLOR_GREEN(color4)/255.0f);
	rend_FontBlue[0]=(float)(GR_COLOR_BLUE(color1)/255.0f);
	rend_FontBlue[1]=(float)(GR_COLOR_BLUE(color2)/255.0f);
	rend_FontBlue[2]=(float)(GR_COLOR_BLUE(color3)/255.0f);
	rend_FontBlue[3]=(float)(GR_COLOR_BLUE(color4)/255.0f);
	rend_FontAlpha[0]=(color1>>24)/255.0f;
	rend_FontAlpha[1]=(color2>>24)/255.0f;
	rend_FontAlpha[2]=(color3>>24)/255.0f;
	rend_FontAlpha[3]=(color4>>24)/255.0f;
}

// Sets the color of fog
void rend_SetFogColor(ddgr_color color)
{
	if (color==OpenGL_state.cur_fog_color)
		return;

	float fc[4];
	fc[0]=GR_COLOR_RED(color);
	fc[1]=GR_COLOR_GREEN(color);
	fc[2]=GR_COLOR_BLUE(color);
	fc[3]=1;

	fc[0]/=255.0f;
	fc[1]/=255.0f;
	fc[2]/=255.0f;

	dglFogfv (GL_FOG_COLOR,fc);
}

// Sets the lighting state of opengl
void rend_SetLightingState(light_state state)
{
	if (state==OpenGL_state.cur_light_state)
		return;	// No redundant state setting

	if (OpenGL_multitexture && Last_texel_unit_set!=0)
	{
#if defined(WIN32)
		oglActiveTextureARB (GL_TEXTURE0_ARB+0);
		Last_texel_unit_set=0;
#endif
	}

	OpenGL_sets_this_frame[4]++;

	switch (state)
	{
	case LS_NONE:
		dglShadeModel (GL_SMOOTH);
		OpenGL_state.cur_light_state=LS_NONE;
		break;
	case LS_FLAT_GOURAUD:
		dglShadeModel (GL_SMOOTH);
		OpenGL_state.cur_light_state=LS_FLAT_GOURAUD;
		break;
	case LS_GOURAUD:
	case LS_PHONG:
		dglShadeModel (GL_SMOOTH);
		OpenGL_state.cur_light_state=LS_GOURAUD;
		break;
	default:
		Int3();
		break;
	}

	CHECK_ERROR(13)
}

void rend_SetAlphaType(sbyte atype)
{
	if (atype==OpenGL_state.cur_alpha_type)
		return;		// don't set it redundantly

	if (OpenGL_multitexture && Last_texel_unit_set!=0)
	{
#if defined(WIN32)
		oglActiveTextureARB (GL_TEXTURE0_ARB+0);
		Last_texel_unit_set=0;
#endif
	}

	OpenGL_sets_this_frame[6]++;

	if (atype==AT_ALWAYS)
	{
		if (opengl_Blending_on)
		{
			dglDisable (GL_BLEND);
			opengl_Blending_on=false;
		}
	}
	else
	{
		if (!opengl_Blending_on)
		{
			dglEnable (GL_BLEND);
			opengl_Blending_on=true;
		}
	}

	switch (atype)
	{
	case AT_ALWAYS:
		rend_SetAlphaValue (255);
		dglBlendFunc (GL_ONE,GL_ZERO);
		break;
	case AT_CONSTANT:
		dglBlendFunc (GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
		break;
	case AT_TEXTURE:
		rend_SetAlphaValue (255);
		dglBlendFunc (GL_ONE,GL_ZERO);
		break;
	case AT_CONSTANT_TEXTURE:
		dglBlendFunc (GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
		break;
	case AT_VERTEX:
		dglBlendFunc (GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
		break;
	case AT_CONSTANT_TEXTURE_VERTEX:
	case AT_CONSTANT_VERTEX:
		dglBlendFunc (GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
		break;
	case AT_TEXTURE_VERTEX:
		dglBlendFunc (GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
		break;
	case AT_LIGHTMAP_BLEND:
		dglBlendFunc (GL_DST_COLOR,GL_ZERO);
		break;
	case AT_SATURATE_TEXTURE:
	case AT_LIGHTMAP_BLEND_SATURATE:
		dglBlendFunc (GL_SRC_ALPHA,GL_ONE);
		break;
	case AT_SATURATE_VERTEX:
		dglBlendFunc (GL_SRC_ALPHA,GL_ONE);
		break;
	case AT_SATURATE_CONSTANT_VERTEX:
		dglBlendFunc (GL_SRC_ALPHA,GL_ONE);
		break;
	case AT_SATURATE_TEXTURE_VERTEX:
		dglBlendFunc (GL_SRC_ALPHA,GL_ONE);
		break;
	case AT_SPECULAR:
		break;
	default:
		Int3();		// no type defined,get jason
		break;
	}
	OpenGL_state.cur_alpha_type=atype;
	Alpha_multiplier=opengl_GetAlphaMultiplier();
	CHECK_ERROR(15)
}

// Sets the alpha value for constant alpha
void rend_SetAlphaValue(ubyte val)
{
	OpenGL_state.cur_alpha=val;
	Alpha_multiplier=opengl_GetAlphaMultiplier();
}

// Sets the overall alpha scale factor (all alpha values are scaled by this value)
// usefull for motion blur effect
void rend_SetAlphaFactor(float val)
{
	if(val<0.0f) val = 0.0f;
	if(val>1.0f) val = 1.0f;
	OpenGL_Alpha_factor = val;
}

// Returns the current Alpha factor
float rend_GetAlphaFactor(void)
{
	return OpenGL_Alpha_factor;
}

// Sets the texture wrapping type
void rend_SetWrapType(wrap_type val)
{
	OpenGL_state.cur_wrap_type=val;
}

// Draws a line using the states of the renderer
void rend_DrawSpecialLine(g3Point *p0,g3Point *p1)
{
	int x_add=OpenGL_state.clip_x1;
	int y_add=OpenGL_state.clip_y1;
	float fr,fg,fb,alpha;
	int i;

	fr=GR_COLOR_RED(OpenGL_state.cur_color);
	fg=GR_COLOR_GREEN(OpenGL_state.cur_color);
	fb=GR_COLOR_BLUE(OpenGL_state.cur_color);

	fr/=255.0f;
	fg/=255.0f;
	fb/=255.0f;

	alpha=Alpha_multiplier*OpenGL_Alpha_factor;

	// And draw!
	dglBegin (GL_LINES);
	for (i=0;i<2;i++)
	{
		g3Point *pnt=p0;

		if (i==1)
			pnt=p1;

		if (OpenGL_state.cur_alpha_type & ATF_VERTEX)
			alpha=pnt->p3_a*Alpha_multiplier*OpenGL_Alpha_factor;

		// If we have a lighting model, apply the correct lighting!
		if (OpenGL_state.cur_light_state!=LS_NONE)
		{
			if (OpenGL_state.cur_light_state==LS_FLAT_GOURAUD)
			{
				dglColor4f (fr,fg,fb,alpha);
			}
			else
			{
				// Do lighting based on intesity (MONO) or colored (RGB)
				if (OpenGL_state.cur_color_model==CM_MONO)
					dglColor4f (pnt->p3_l,pnt->p3_l,pnt->p3_l,alpha);
				else
				{
					dglColor4f (pnt->p3_r,pnt->p3_g,pnt->p3_b,alpha);
				}
			}
		}
		else
		{
			dglColor4f (fr,fg,fb,alpha);
		}

		// Finally, specify a vertex
		//@@float z=(pnt->p3_z+Z_bias)/OpenGL_state.cur_far_z;
		float z = max(0,min(1.0,1.0-(1.0/(pnt->p3_z+Z_bias))));
		dglVertex3f (pnt->p3_sx+x_add,pnt->p3_sy+y_add,-z);
	}

	dglEnd();
}

// Takes a screenshot of the current frame and puts it into the handle passed
void rend_Screenshot(int bm_handle)
{
	ushort *dest_data;
	uint *temp_data;
	int i,t;
	int total=OpenGL_state.screen_width*OpenGL_state.screen_height;

	ASSERT((bm_w(bm_handle,0))==OpenGL_state.screen_width);
	ASSERT((bm_h(bm_handle,0))==OpenGL_state.screen_height);

	int w=bm_w(bm_handle,0);
	int h=bm_h(bm_handle,0);

	temp_data=(uint *)mem_malloc (total*4);
	ASSERT (temp_data);	// Ran out of memory?

	dest_data=bm_data (bm_handle,0);

	dglReadPixels (0,0,OpenGL_state.screen_width,OpenGL_state.screen_height,GL_RGBA,GL_UNSIGNED_BYTE,(GLvoid *)temp_data);

	for (i=0;i<h;i++)
	{
		for (t=0;t<w;t++)
		{
			uint spix=temp_data[i*w+t];

			int r=spix & 0xff;
			int g=(spix>>8) & 0xff;
			int b=(spix>>16) & 0xff;

			dest_data[(((h-1)-i)*w)+t]=GR_RGB16(r,g,b);
		}
	}

	mem_free(temp_data);
}

void rend_SetZBias(float z_bias)
{
	Z_bias=z_bias;
}

// Enables/disables writes the depth buffer
void rend_SetZBufferWriteMask(int state)
{
	OpenGL_sets_this_frame[5]++;
	if(state)
	{
		dglDepthMask(GL_TRUE);
	}
	else
	{
		dglDepthMask(GL_FALSE);
	}
}

// Gets a pointer to a linear frame buffer
void rend_GetLFBLock(renderer_lfb *lfb)
{
}

// Releases an lfb lock
void rend_ReleaseLFBLock(renderer_lfb *lfb)
{
}

// Returns the aspect ratio of the physical screen
void rend_GetProjectionParameters(int *width,int *height)
{
	*width=OpenGL_state.clip_x2-OpenGL_state.clip_x1;
	*height=OpenGL_state.clip_y2-OpenGL_state.clip_y1;
}

void rend_GetProjectionScreenParameters( int &screenLX, int &screenTY, int &screenW, int &screenH )
{
	screenLX = OpenGL_state.clip_x1;
	screenTY = OpenGL_state.clip_y1;
	screenW  = OpenGL_state.clip_x2 - OpenGL_state.clip_x1;
	screenH  = OpenGL_state.clip_y2 - OpenGL_state.clip_y1;
}

// Returns the aspect ratio of the physical screen
float rend_GetAspectRatio(void)
{
	float aspect_ratio = (float)((3.0f * OpenGL_state.screen_width)/(4.0f * OpenGL_state.screen_height));
	return aspect_ratio;
}

// Given a source x,y and width,height, draws any sized bitmap into the renderer lfb
void rend_DrawLFBBitmap(int sx,int sy,int w,int h,int dx,int dy,ushort *data,int rowsize)
{
}

//	given a chunked bitmap, renders it.
void rend_DrawChunkedBitmap(chunked_bitmap *chunk, int x, int y, ubyte alpha)
{
	int *bm_array = chunk->bm_array;
	int w = chunk->w;
	int h = chunk->h;
	int piece_w=bm_w(bm_array[0],0);
	int piece_h=bm_h(bm_array[0],0);
	int screen_w, screen_h;
	int i,t;
	rend_SetZBufferState (0);
	rend_GetProjectionParameters(&screen_w, &screen_h);
	for (i=0;i<h;i++)
	{
		for (t=0;t<w;t++)
		{
			int dx=x+(piece_w*t);
			int dy=y+(piece_h*i);
			int dw,dh;
			if ((dx+piece_w)>screen_w)
				dw=piece_w-((dx+piece_w)-screen_w);
			else
				dw=piece_w;
			if ((dy+piece_h)>screen_h)
				dh=piece_h-((dy+piece_h)-screen_h);
			else
				dh=piece_h;

			float u2=(float)dw/(float)piece_w;
			float v2=(float)dh/(float)piece_h;
			rend_DrawSimpleBitmap(bm_array[i*w+t],dx,dy);
		}
	}
	rend_SetZBufferState (1);
}

//	given a chunked bitmap, renders it.scaled
void rend_DrawScaledChunkedBitmap(chunked_bitmap *chunk, int x, int y, int neww, int newh, ubyte alpha)
{
	int *bm_array = chunk->bm_array;
	int w = chunk->w;
	int h = chunk->h;
	int piece_w;
	int piece_h;
	int screen_w, screen_h;
	int i,t;

	float scalew,scaleh;

	scalew = ((float)neww)/((float)chunk->pw);
	scaleh = ((float)newh)/((float)chunk->ph);
	piece_w = scalew * ((float)bm_w(bm_array[0],0));
	piece_h = scaleh * ((float)bm_h(bm_array[0],0));
	rend_GetProjectionParameters(&screen_w, &screen_h);
	rend_SetOverlayType (OT_NONE);
	rend_SetLighting (LS_NONE);
	rend_SetColorModel (CM_MONO);
	rend_SetZBufferState (0);
	rend_SetAlphaType (AT_CONSTANT_TEXTURE);
	rend_SetAlphaValue (alpha);
	rend_SetWrapType (WT_WRAP);
	for (i=0;i<h;i++)
	{
		for (t=0;t<w;t++)
		{
			int dx=x+(piece_w*t);
			int dy=y+(piece_h*i);
			int dw,dh;
			if ((dx+piece_w)>screen_w)
				dw=piece_w-((dx+piece_w)-screen_w);
			else
				dw=piece_w;
			if ((dy+piece_h)>screen_h)
				dh=piece_h-((dy+piece_h)-screen_h);
			else
				dh=piece_h;

			float u2=(float)dw/(float)piece_w;
			float v2=(float)dh/(float)piece_h;
			rend_DrawScaledBitmap(dx,dy,dx+dw,dy+dh,bm_array[i*w+t],0,0,u2,v2);

		}
	}
	rend_SetZBufferState (1);
}

// Sets some global preferences for the renderer
int rend_SetPreferredState(renderer_preferred_state *pref_state)
{
	int retval = 1;
	renderer_preferred_state old_state = OpenGL_preferred_state;

	OpenGL_preferred_state = *pref_state;
	if( OpenGL_state.initted )
	{
		int reinit = 0;
		mprintf ((0,"Inside pref state!\n"));

		// Change gamma if needed
		if( pref_state->width!=OpenGL_state.screen_width || pref_state->height!=OpenGL_state.screen_height || old_state.bit_depth!=pref_state->bit_depth)
		{
			reinit=1;
		}

		if( reinit )
		{
			opengl_Close();
			retval = opengl_Init( NULL, &OpenGL_preferred_state );
		}
		else
		{
			if( old_state.gamma !=pref_state->gamma )
			{
				opengl_SetGammaValue( pref_state->gamma );
			}
		}
	}
	else
	{
		OpenGL_preferred_state = *pref_state;
	}

	rend_SetInitOptions();
	return retval;
}

// Sets the gamma for this display
void rend_SetGammaValue(float val)
{
}

// Draws a simple bitmap at the specified x,y location
void rend_DrawSimpleBitmap(int bm_handle,int x,int y)
{
	rend_SetAlphaType(AT_CONSTANT_TEXTURE);
	rend_SetAlphaValue(255);
	rend_SetLighting(LS_NONE);
	rend_SetColorModel(CM_MONO);
	rend_SetOverlayType(OT_NONE);
	rend_SetFiltering(0);
	rend_DrawScaledBitmap(x,y,x+bm_w(bm_handle,0),y+bm_h(bm_handle,0),bm_handle,0,0,1,1);
	rend_SetFiltering(1);
}

// Fills in the passed in pointer with the current rendering state
void rend_GetRenderState(rendering_state *rstate)
{
	memcpy( rstate, &OpenGL_state, sizeof(rendering_state) );
}

// Takes a bitmap and blits it to the screen using linear frame buffer stuff
// X and Y are the destination X,Y
void rend_CopyBitmapToFramebuffer(int bm_handle,int x,int y)
{
	ASSERT( opengl_Framebuffer_ready );

	if( opengl_Framebuffer_ready == 1 )
	{
		bm_CreateChunkedBitmap( bm_handle, &opengl_Chunked_bitmap );
		opengl_Framebuffer_ready = 2;
	}
	else
	{
		opengl_ChangeChunkedBitmap( bm_handle, &opengl_Chunked_bitmap );
	}

	rend_DrawChunkedBitmap( &opengl_Chunked_bitmap, 0, 0, 255 );
}

// Gets a renderer ready for a framebuffer copy, or stops a framebuffer copy
void rend_SetFrameBufferCopyState(bool state)
{
	if( state )
	{
		ASSERT( opengl_Framebuffer_ready == 0 );
		opengl_Framebuffer_ready = 1;
	}
	else
	{
		ASSERT( opengl_Framebuffer_ready != 0 );
		opengl_Framebuffer_ready = 0;

		if( opengl_Framebuffer_ready == 2 )
		{
			bm_DestroyChunkedBitmap( &opengl_Chunked_bitmap );
			opengl_ResetCache();
		}
	}
}

// Changes the resolution of the renderer
void rend_SetResolution(int width,int height)
{
}

// Gets OpenGL ready to work in a window
int rend_InitOpenGLWindow (oeApplication *app,renderer_preferred_state *pref_state)
{
	WindowGL = 1;
	return opengl_Init( app, pref_state );
}

// Shuts down OpenGL in a window
void rend_CloseOpenGLWindow(void)
{
	opengl_Close();
	WindowGL=0;
	OpenGL_window_initted=0;
	mprintf ((1,"SHUTTING DOWN WINDOWED OPENGL!"));
}

// Sets the state of the OpenGLWindow to on or off
static renderer_type Save_rend;
static bool Save_state_limit;
void rend_SetOpenGLWindowState (int state,oeApplication *app,renderer_preferred_state *pref_state)
{
	if (state)
	{
		if (!OpenGL_window_initted)
		{
			if (rend_InitOpenGLWindow (app,pref_state))
				OpenGL_window_initted=1;
			else
				return;
		}
		UseHardware=1;
		Save_rend=Renderer_type;
		Save_state_limit=StateLimited;
		Renderer_type=RENDERER_OPENGL;
		StateLimited=1;
		NoLightmaps=false;
	}
	else
	{
		if (OpenGL_window_initted)
		{
			UseHardware=0;
			Renderer_type=RENDERER_SOFTWARE_16BIT;
			StateLimited=Save_state_limit;
		}
	}
}

// Sets the hardware bias level for coplanar polygons
// This helps reduce z buffer artifacts
void rend_SetCoplanarPolygonOffset(float factor)
{
	if( factor == 0.0f )
	{
		dglDisable( GL_POLYGON_OFFSET_FILL );
	}
	else
	{
		dglEnable( GL_POLYGON_OFFSET_FILL );
		dglPolygonOffset( -1.0f, -1.0f );
	}
}

// Preuploads a texture to the video card
void rend_PreUploadTextureToCard(int handle,int map_type)
{
}

// Frees an uploaded texture from the video card
void rend_FreePreUploadedTexture(int handle,int map_type)
{
}

// Retrieves an error message
char *rend_GetErrorMessage ()
{	
	return (char *)Renderer_error_message;
}

// Sets an error message
void rend_SetErrorMessage (char *str)
{
	ASSERT( strlen(str) < 256 );
	strcpy( Renderer_error_message, str );
}

// Returns 1 if there is mid video memory, 2 if there is low vid memory, or 0 if there is large vid memory
int rend_LowVidMem(void)
{
	return 0;
}

// Returns 1 if the renderer supports bumpmapping
int rend_SupportsBumpmapping(void)
{
	return 0;
}

// Sets a bumpmap to be rendered, or turns off bumpmapping altogether
void rend_SetBumpmapReadyState(int state,int map)
{
}

// returns the direct draw object 
void *rend_RetrieveDirectDrawObj(void **frontsurf, void **backsurf)
{
	*frontsurf = NULL;
	*backsurf = NULL;
	return NULL;
}

// returns rendering statistics for the frame
void rend_GetStatistics(tRendererStats *stats)
{
	if( Renderer_initted )
	{
		stats->poly_count      = OpenGL_last_frame_polys_drawn;
		stats->vert_count      = OpenGL_last_frame_verts_processed;
		stats->texture_uploads = OpenGL_last_uploaded;
	}
	else
	{
		memset( stats, 0, sizeof(tRendererStats) );
	}
}

#endif