Added support for relative line numbers.

Added instructions for, brk and cont. (They are still untested...)
Parser code cleanup. Removed garbage output to stderr.
Reorganize the repository structure.
Updated BLR2 code move it into archive.
Added BLR1 files.

1 files changed, 1524 insertions, 0 deletions

diff --git a/archive/hge/graphics.cpp b/archive/hge/graphics.cpp
new file mode 100644
index 0000000..6ee9578
--- /dev/null
+++ b/archive/hge/graphics.cpp
@@ -0,0 +1,1524 @@
+/*
+** Haaf's Game Engine 1.8
+** Copyright (C) 2003-2007, Relish Games
+** hge.relishgames.com
+**
+** Core functions implementation: graphics
+*/
+
+// !!! FIXME: the texture data when locking/unlocking textures is in GL_BGRA format, not GL_RGBA.
+// !!! FIXME:  ...but this mistake wasn't noticed for several games, since most didn't lock outside
+// !!! FIXME:  of a piece of code that was #ifdef'd for Unix anyhow.
+// !!! FIXME: But if you lock textures and the colors are wrong, that's what happened. We need to
+// !!! FIXME:  sort out all the places where we're passing things around in RGBA to fix this.
+// !!! FIXME:  In the mean time, it's usually easier to just change your application to expect
+// !!! FIXME:  locked textures to be RGBA instead of BGRA.
+
+// !!! FIXME: ...apparently we're locking textures upside down, too?
+
+#include "hge_impl.h"
+
+#define SUPPORT_CXIMAGE 1
+#if SUPPORT_CXIMAGE
+// conflict with Mac OS X 10.3.9 SDK...
+#ifdef _T
+#undef _T
+#endif
+#include "CxImage/ximage.h"
+#else
+/* Use DevIL instead of CXImage */
+#include <IL/il.h>
+#include <IL/ilu.h>
+#endif
+
+// avoiding glext.h here ...
+#ifndef GL_TEXTURE_RECTANGLE_ARB
+#define GL_TEXTURE_RECTANGLE_ARB 0x84F5
+#endif
+#ifndef GL_FRAMEBUFFER_EXT
+#define GL_FRAMEBUFFER_EXT 0x8D40
+#endif
+#ifndef GL_RENDERBUFFER_EXT
+#define GL_RENDERBUFFER_EXT 0x8D41
+#endif
+#ifndef GL_COLOR_ATTACHMENT0_EXT
+#define GL_COLOR_ATTACHMENT0_EXT 0x8CE0
+#endif
+#ifndef GL_DEPTH_ATTACHMENT_EXT
+#define GL_DEPTH_ATTACHMENT_EXT 0x8D00
+#endif
+#ifndef GL_FRAMEBUFFER_COMPLETE_EXT
+#define GL_FRAMEBUFFER_COMPLETE_EXT 0x8CD5
+#endif
+#ifndef GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
+#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3
+#endif
+#ifndef GL_YCBCR_422_APPLE
+#define GL_YCBCR_422_APPLE 0x85B9
+#endif
+#ifndef GL_UNSIGNED_SHORT_8_8_APPLE
+#define GL_UNSIGNED_SHORT_8_8_APPLE 0x85BA
+#endif
+#ifndef GL_UNSIGNED_SHORT_8_8_REV_APPLE
+#define GL_UNSIGNED_SHORT_8_8_REV_APPLE 0x85BB
+#endif
+static const char* GRAPHICS_SRC_FN="hge/graphics.cpp";
+struct gltexture
+{
+	GLuint name;
+	GLuint width;
+	GLuint height;
+	GLuint potw;  // Power-of-two width.
+	GLuint poth;  // Power-of-two height.
+	const char *filename;  // if backed by a file, not a managed buffer.
+	DWORD *pixels;  // original rgba data.
+	DWORD *lock_pixels;  // for locked texture
+	bool is_render_target;
+	bool lost;
+	bool lock_readonly;
+	GLint lock_x;
+	GLint lock_y;
+	GLint lock_width;
+	GLint lock_height;
+};
+
+static DWORD *_DecodeImage(BYTE *data, const char *fname, DWORD size, int &width, int &height)
+{
+	width = height = 0;
+
+	DWORD *pixels = NULL;
+	const size_t fnamelen = fname ? strlen(fname) : 0;
+	if ( (fnamelen > 5) && (strcasecmp((fname + fnamelen) - 5, ".rgba") == 0) )
+	{
+		DWORD *ptr = (DWORD *) data;
+		DWORD w = ptr[0];
+		DWORD h = ptr[1];
+		BYTESWAP(w);
+		BYTESWAP(h);
+		if ( ((w * h * 4) + 8) == size )  // not truncated?
+		{
+			width = (int) w;
+			height = (int) h;
+			pixels = new DWORD[width * height];
+			memcpy(pixels, ptr + 2, w * h * 4);  // !!! FIXME: ignores pitch.
+		}
+		return pixels;
+	}
+
+#if SUPPORT_CXIMAGE
+	CxImage img;
+	img.Decode(data, size, CXIMAGE_FORMAT_UNKNOWN);
+	if (img.IsValid())
+	{
+		width = img.GetWidth();
+		height = img.GetHeight();
+		pixels = new DWORD[width * height];
+		BYTE *wptr = (BYTE *) pixels;
+		const bool hasalpha = img.AlphaIsValid();
+		for (int y = 0; y < height; y++)
+		{
+			for (int x = 0; x < width; x++)
+			{
+				const RGBQUAD rgb = img.GetPixelColor(x, y, true);
+				*(wptr++) = rgb.rgbRed;
+				*(wptr++) = rgb.rgbGreen;
+				*(wptr++) = rgb.rgbBlue;
+				*(wptr++) = hasalpha ? rgb.rgbReserved : 0xFF;  // alpha.
+			}
+		}
+	}
+#else
+	ilInit();
+	iluInit();
+
+	ILuint id;
+	ilGenImages(1, &id);
+
+	if(ilLoadImage(fname)) {
+		printf("success: %s\n", fname);
+		ILinfo info;
+		iluGetImageInfo(&info);
+		width = info.Width;
+		height = info.Height;
+		size = info.SizeOfData;
+		pixels = new DWORD[width * height];
+		ilCopyPixels(0, 0, 0, width, height, 0, IL_RGBA, IL_UNSIGNED_INT, pixels);
+		ilShutDown();
+	}
+#endif
+
+	return pixels;
+}
+
+
+void HGE_Impl::_BindTexture(gltexture *t)
+{
+	// The Direct3D renderer is using managed textures, so they aren't every
+	//  actually "lost" ... we may have to rebuild them here, though.
+	if ((t != NULL) && (t->lost))
+		_ConfigureTexture(t, t->width, t->height, t->pixels);
+
+	if ( ((HTEXTURE)t) != CurTexture )
+	{
+		pOpenGLDevice->glBindTexture(pOpenGLDevice->TextureTarget, t ? t->name : 0);
+		CurTexture = (HTEXTURE) t;
+	}
+}
+
+void CALL HGE_Impl::Gfx_Clear(DWORD color)
+{
+	GLbitfield flags = GL_COLOR_BUFFER_BIT;
+	if ( ((pCurTarget) && (pCurTarget->depth)) || bZBuffer )
+		flags |= GL_DEPTH_BUFFER_BIT;
+
+	const GLfloat a = ((GLfloat) ((color >> 24) & 0xFF)) / 255.0f;
+	const GLfloat r = ((GLfloat) ((color >> 16) & 0xFF)) / 255.0f;
+	const GLfloat g = ((GLfloat) ((color >>  8) & 0xFF)) / 255.0f;
+	const GLfloat b = ((GLfloat) ((color >>  0) & 0xFF)) / 255.0f;
+	pOpenGLDevice->glClearColor(r, g, b, a);
+	pOpenGLDevice->glClear(flags);
+}
+
+void CALL HGE_Impl::Gfx_SetClipping(int x, int y, int w, int h)
+{
+	int scr_width, scr_height;
+	struct { int X; int Y; int Width; int Height; float MinZ; float MaxZ; } vp;
+
+	if(!pCurTarget) {
+		scr_width=pHGE->System_GetStateInt(HGE_SCREENWIDTH);
+		scr_height=pHGE->System_GetStateInt(HGE_SCREENHEIGHT);
+	}
+	else {
+		scr_width=Texture_GetWidth(pCurTarget->tex);
+		scr_height=Texture_GetHeight(pCurTarget->tex);
+	}
+
+	if(!w) {
+		vp.X=0;
+		vp.Y=0;
+		vp.Width=scr_width;
+		vp.Height=scr_height;
+	}
+	else
+	{
+		if(x<0) { w+=x; x=0; }
+		if(y<0) { h+=y; y=0; }
+
+		if(x+w > scr_width) w=scr_width-x;
+		if(y+h > scr_height) h=scr_height-y;
+
+		vp.X=x;
+		vp.Y=y;
+		vp.Width=w;
+		vp.Height=h;
+	}
+
+	if ((clipX == vp.X) && (clipY == vp.Y) && (clipW == vp.Width) && (clipH == vp.Height))
+		return;   // nothing to do here, don't call into the GL.
+
+	vp.MinZ=0.0f;
+	vp.MaxZ=1.0f;
+
+	_render_batch();
+
+	clipX = vp.X;
+	clipY = vp.Y;
+	clipW = vp.Width;
+	clipH = vp.Height;
+	pOpenGLDevice->glScissor(vp.X, (scr_height-vp.Y)-vp.Height, vp.Width, vp.Height);
+}
+
+void CALL HGE_Impl::Gfx_SetTransform(float x, float y, float dx, float dy, float rot, float hscale, float vscale)
+{
+	if ((x == 0.0f) && (y == 0.0f) && (dx == 0.0f) && (dy == 0.0f) && (rot == 0.0f) && (hscale == 0.0f) && (vscale == 0.0f))
+	{
+		//reset everything
+		pOpenGLDevice->glMatrixMode(GL_MODELVIEW);
+		pOpenGLDevice->glLoadIdentity();
+		bTransforming=false;
+		return;
+	}
+
+	_render_batch();
+	bTransforming = true;
+
+	pOpenGLDevice->glMatrixMode(GL_MODELVIEW);
+	//we have to reset the matrix in all cases.
+	//or this would cause insane transforming...
+	pOpenGLDevice->glLoadIdentity();
+	pOpenGLDevice->glTranslatef(-x, -y, 0.0f);
+	pOpenGLDevice->glScalef(hscale, vscale, 1.0f);
+	pOpenGLDevice->glRotatef(rot, 0.0f, 0.0f, 1.0f);
+	pOpenGLDevice->glTranslatef(x+dx, y+dy, 0.0f);
+}
+
+bool CALL HGE_Impl::Gfx_BeginScene(HTARGET targ)
+{
+	CRenderTargetList *target=(CRenderTargetList *)targ;
+
+	if(VertArray)
+	{
+		_PostError("Gfx_BeginScene: Scene is already being rendered");
+		return false;
+	}
+
+	if(target != pCurTarget)
+	{
+		if (pOpenGLDevice->have_GL_EXT_framebuffer_object)
+			pOpenGLDevice->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, (target) ? target->frame : 0);
+
+		if ( ((target) && (target->depth)) || (bZBuffer) )
+			pOpenGLDevice->glEnable(GL_DEPTH_TEST);
+		else
+			pOpenGLDevice->glDisable(GL_DEPTH_TEST);
+
+		// d3d's SetRenderTarget() forces the viewport to surface size...
+		if (target)
+		{
+			pOpenGLDevice->glScissor(0, 0, target->width, target->height);
+			pOpenGLDevice->glViewport(0, 0, target->width, target->height);
+			_SetProjectionMatrix(target->width, target->height);
+		}
+		else
+		{
+			pOpenGLDevice->glScissor(0, 0, nScreenWidth, nScreenHeight);
+			pOpenGLDevice->glViewport(0, 0, nScreenWidth, nScreenHeight);
+			_SetProjectionMatrix(nScreenWidth, nScreenHeight);
+		}
+
+		pOpenGLDevice->glMatrixMode(GL_MODELVIEW);
+		pOpenGLDevice->glLoadIdentity();
+
+		pCurTarget=target;
+	}
+
+	VertArray = pVB;
+	return true;
+}
+
+void CALL HGE_Impl::Gfx_EndScene()
+{
+	_render_batch(true);
+
+	// no "real" render targets? Push the framebuffer to a texture.
+	// This is not going to work in lots of legitimate scenarios, but it will
+	//  most of the time, so it's better than nothing when you lack FBOs.
+	if ((pCurTarget) && (!pOpenGLDevice->have_GL_EXT_framebuffer_object))
+	{
+		gltexture *pTex = (gltexture *) pCurTarget->tex;
+		if ((pTex != NULL) && (pTex->lost))
+			_ConfigureTexture(pTex, pTex->width, pTex->height, pTex->pixels);
+
+		const int width = pCurTarget->width;
+		const int height = pCurTarget->height;
+		pOpenGLDevice->glFinish();
+		DWORD *pixels = new DWORD[width * height];
+		pOpenGLDevice->glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+		pOpenGLDevice->glBindTexture(pOpenGLDevice->TextureTarget, pTex->name);
+		pOpenGLDevice->glTexSubImage2D(pOpenGLDevice->TextureTarget, 0, 0, 0, width, height,
+		                               GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+		pOpenGLDevice->glBindTexture(pOpenGLDevice->TextureTarget, CurTexture ? (((gltexture *) CurTexture)->name) : 0);
+		delete[] pixels;
+	}
+
+	if(!pCurTarget) SDL_GL_SwapBuffers();
+	//const GLenum err = pOpenGLDevice->glGetError();
+	//if (err != GL_NO_ERROR) printf("GL error! 0x%X\n", (int) err);
+	//Gfx_Clear(0xFF | (0xFF<<24) | (random() & 0xFF << 16) | (random() & 0xFF << 8));
+	//Gfx_Clear(0xFF000000);
+}
+
+void HGE_Impl::_SetTextureFilter()
+{
+	const GLenum filter = (bTextureFilter) ? GL_LINEAR : GL_NEAREST;
+	pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget, GL_TEXTURE_MIN_FILTER, filter);
+	pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget, GL_TEXTURE_MAG_FILTER, filter);
+}
+
+
+bool HGE_Impl::_PrimsOutsideClipping(const hgeVertex *v, const int verts)
+{
+	if (bTransforming)
+		return false;  // screw it, let the GL do the clipping.
+
+	const int maxX = clipX + clipW;
+	const int maxY = clipY + clipH;
+	for (int i = 0; i < verts; i++, v++)
+	{
+		const int x = v->x;
+		const int y = v->y;
+		if ((x > clipX) && (x < maxX) && (y > clipY) && (y < maxY))
+			return false;
+	}
+	return true;
+}
+
+
+void CALL HGE_Impl::Gfx_RenderLine(float x1, float y1, float x2, float y2, DWORD color, float z)
+{
+	if (VertArray)
+	{
+		if(CurPrimType!=HGEPRIM_LINES || nPrim>=VERTEX_BUFFER_SIZE/HGEPRIM_LINES || CurTexture || CurBlendMode!=BLEND_DEFAULT)
+		{
+			_render_batch();
+
+			CurPrimType=HGEPRIM_LINES;
+			if(CurBlendMode != BLEND_DEFAULT) _SetBlendMode(BLEND_DEFAULT);
+			_BindTexture(NULL);
+		}
+
+		int i=nPrim*HGEPRIM_LINES;
+		VertArray[i].x = x1; VertArray[i+1].x = x2;
+		VertArray[i].y = y1; VertArray[i+1].y = y2;
+		VertArray[i].z     = VertArray[i+1].z = z;
+		VertArray[i].col   = VertArray[i+1].col = color;
+		VertArray[i].tx    = VertArray[i+1].tx =
+		VertArray[i].ty    = VertArray[i+1].ty = 0.0f;
+
+		if (!_PrimsOutsideClipping(&VertArray[i], HGEPRIM_LINES))
+			nPrim++;
+	}
+}
+
+template <class T> static inline const T Min(const T a, const T b) { return a < b ? a : b; }
+template <class T> static inline const T Max(const T a, const T b) { return a > b ? a : b; }
+
+void CALL HGE_Impl::Gfx_RenderTriple(const hgeTriple *triple)
+{
+	if (VertArray)
+	{
+		const hgeVertex *v = triple->v;
+		if (_PrimsOutsideClipping(v, HGEPRIM_TRIPLES))
+		{
+			// check for overlap, despite triangle points being outside clipping...
+			const int maxX = clipX + clipW;
+			const int maxY = clipY + clipH;
+			const int leftmost = Min(Min(v[0].x, v[1].x), v[2].x);
+			const int rightmost = Max(Max(v[0].x, v[1].x), v[2].x);
+			const int topmost = Min(Min(v[0].y, v[1].y), v[2].y);
+			const int bottommost = Max(Max(v[0].y, v[1].y), v[2].y);
+			if ( ((clipX < leftmost) || (clipX > rightmost)) &&
+			     ((maxX < leftmost) || (maxX > rightmost)) &&
+			     ((clipY < topmost) || (clipY > bottommost)) &&
+			     ((maxY < topmost) || (maxY > bottommost)) )
+				return;  // no, this is really totally clipped.
+		}
+
+		if(CurPrimType!=HGEPRIM_TRIPLES || nPrim>=VERTEX_BUFFER_SIZE/HGEPRIM_TRIPLES || CurTexture!=triple->tex || CurBlendMode!=triple->blend)
+		{
+			_render_batch();
+
+			CurPrimType=HGEPRIM_TRIPLES;
+			if(CurBlendMode != triple->blend) _SetBlendMode(triple->blend);
+			_BindTexture((gltexture *) triple->tex);
+		}
+
+		memcpy(&VertArray[nPrim*HGEPRIM_TRIPLES], triple->v, sizeof(hgeVertex)*HGEPRIM_TRIPLES);
+		nPrim++;
+	}
+}
+
+void CALL HGE_Impl::Gfx_RenderQuad(const hgeQuad *quad)
+{
+	if (VertArray)
+	{
+		const hgeVertex *v = quad->v;
+		if (_PrimsOutsideClipping(v, HGEPRIM_QUADS))
+		{
+			// check for overlap, despite quad points being outside clipping...
+			const int maxX = clipX + clipW;
+			const int maxY = clipY + clipH;
+			const int leftmost = Min(Min(Min(v[0].x, v[1].x), v[2].x), v[3].x);
+			const int rightmost = Max(Max(Max(v[0].x, v[1].x), v[2].x), v[3].x);
+			const int topmost = Min(Min(Min(v[0].y, v[1].y), v[2].y), v[3].y);
+			const int bottommost = Max(Max(Max(v[0].y, v[1].y), v[2].y), v[3].y);
+			if ( ((clipX < leftmost) || (clipX > rightmost)) &&
+			     ((maxX < leftmost) || (maxX > rightmost)) &&
+			     ((clipY < topmost) || (clipY > bottommost)) &&
+			     ((maxY < topmost) || (maxY > bottommost)) )
+				return;  // no, this is really totally clipped.
+		}
+
+		if(CurPrimType!=HGEPRIM_QUADS || nPrim>=VERTEX_BUFFER_SIZE/HGEPRIM_QUADS || CurTexture!=quad->tex || CurBlendMode!=quad->blend)
+		{
+			_render_batch();
+
+			CurPrimType=HGEPRIM_QUADS;
+			if(CurBlendMode != quad->blend) _SetBlendMode(quad->blend);
+			_BindTexture((gltexture *) quad->tex);
+		}
+
+		memcpy(&VertArray[nPrim*HGEPRIM_QUADS], quad->v, sizeof(hgeVertex)*HGEPRIM_QUADS);
+		nPrim++;
+	}
+}
+
+hgeVertex* CALL HGE_Impl::Gfx_StartBatch(int prim_type, HTEXTURE tex, int blend, int *max_prim)
+{
+	if(VertArray)
+	{
+		_render_batch();
+
+		CurPrimType=prim_type;
+		if(CurBlendMode != blend) _SetBlendMode(blend);
+		_BindTexture((gltexture *) tex);
+		*max_prim=VERTEX_BUFFER_SIZE / prim_type;
+		return VertArray;
+	}
+	else return 0;
+}
+
+void CALL HGE_Impl::Gfx_FinishBatch(int nprim)
+{
+	nPrim = nprim;
+}
+
+bool HGE_Impl::_BuildTarget(CRenderTargetList *pTarget, GLuint texname, int width, int height, bool zbuffer)
+{
+	bool okay = true;  // no FBOs? Fake success by default.
+	if (pOpenGLDevice->have_GL_EXT_framebuffer_object)
+	{
+		pOpenGLDevice->glGenFramebuffersEXT(1, &pTarget->frame);
+		if (zbuffer)
+			pOpenGLDevice->glGenRenderbuffersEXT(1, &pTarget->depth);
+		pOpenGLDevice->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, pTarget->frame);
+		pOpenGLDevice->glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, pOpenGLDevice->TextureTarget, texname, 0);
+		if (zbuffer)
+		{
+			pOpenGLDevice->glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, pTarget->depth);
+			pOpenGLDevice->glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, width, height);
+			pOpenGLDevice->glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, pTarget->depth);
+		}
+
+		GLenum rc = pOpenGLDevice->glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
+		if ((rc == GL_FRAMEBUFFER_COMPLETE_EXT) && (pOpenGLDevice->glGetError() == GL_NO_ERROR))
+		{
+			pOpenGLDevice->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+			okay = true;
+		}
+		else
+		{
+			pOpenGLDevice->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+			pOpenGLDevice->glDeleteRenderbuffersEXT(1, &pTarget->depth);
+			pOpenGLDevice->glDeleteFramebuffersEXT(1, &pTarget->frame);
+		}
+		pOpenGLDevice->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, pCurTarget ? pCurTarget->frame : 0);
+	}
+
+	return okay;
+}
+
+HTARGET CALL HGE_Impl::Target_Create(int width, int height, bool zbuffer)
+{
+	bool okay = false;
+	CRenderTargetList *pTarget = new CRenderTargetList;
+	memset(pTarget, '\0', sizeof (CRenderTargetList));
+
+	pTarget->tex = _BuildTexture(width, height, NULL);
+	gltexture *gltex = (gltexture *) pTarget->tex;
+	gltex->is_render_target = true;
+	gltex->lost = false;
+	_ConfigureTexture(gltex, width, height, NULL);
+
+	pTarget->width = width;
+	pTarget->height = height;
+
+	okay = _BuildTarget(pTarget, gltex->name, width, height, zbuffer);
+	if (!okay)
+	{
+		System_Log("%s: OpenGL: Failed to create render target!",GRAPHICS_SRC_FN);
+		Texture_Free(pTarget->tex);
+		delete pTarget;
+		return 0;
+	}
+
+	pTarget->next=pTargets;
+	pTargets=pTarget;
+
+	return (HTARGET)pTarget;
+}
+
+void CALL HGE_Impl::Target_Free(HTARGET target)
+{
+	CRenderTargetList *pTarget=pTargets, *pPrevTarget=NULL;
+
+	while(pTarget)
+	{
+		if((CRenderTargetList *)target == pTarget)
+		{
+			if(pPrevTarget)
+				pPrevTarget->next = pTarget->next;
+			else
+				pTargets = pTarget->next;
+
+			if (pOpenGLDevice->have_GL_EXT_framebuffer_object)
+			{
+				if (pCurTarget == (CRenderTargetList *)target)
+					pOpenGLDevice->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+				if (pTarget->depth)
+					pOpenGLDevice->glDeleteRenderbuffersEXT(1, &pTarget->depth);
+				pOpenGLDevice->glDeleteFramebuffersEXT(1, &pTarget->frame);
+			}
+
+			if (pCurTarget == (CRenderTargetList *)target)
+				pCurTarget = 0;
+
+			Texture_Free(pTarget->tex);
+			delete pTarget;
+			return;
+		}
+
+		pPrevTarget = pTarget;
+		pTarget = pTarget->next;
+	}
+}
+
+HTEXTURE CALL HGE_Impl::Target_GetTexture(HTARGET target)
+{
+	CRenderTargetList *targ=(CRenderTargetList *)target;
+	if(target) return targ->tex;
+	else return 0;
+}
+
+static inline bool _IsPowerOfTwo(const GLuint x)
+{
+	return ((x & (x - 1)) == 0);
+}
+
+static inline GLuint _NextPowerOfTwo(GLuint x)
+{
+	x--;
+	for (unsigned i = 1; i < (sizeof(GLuint) * 8); i <<= 1)
+		x |= x >> i;
+	return x + 1;
+}
+
+void HGE_Impl::_ConfigureTexture(gltexture *t, int width, int height, DWORD *pixels)
+{
+	GLuint tex = 0;
+	pOpenGLDevice->glGenTextures(1, &tex);
+
+	t->lost = false;
+	t->name = tex;
+	t->width = width;
+	t->height = height;
+	t->pixels = pixels;
+	t->potw = 0;
+	t->poth = 0;
+
+	// see if we're backed by a file and not RAM.
+	const bool loadFromFile = ((pixels == NULL) && (t->filename != NULL));
+	if (loadFromFile)
+	{
+		DWORD size = 0;
+		BYTE *data = (BYTE *) pHGE->Resource_Load(t->filename, &size);
+		if (data != NULL)
+		{
+			int w, h;
+			pixels = _DecodeImage(data, t->filename, size, w, h);
+			if ((w != width) || (h != height))  // yikes, file changed?
+			{
+				delete[] pixels;
+				pixels = NULL;
+			}
+			Resource_Free(data);
+		}
+	}
+
+	pOpenGLDevice->glBindTexture(pOpenGLDevice->TextureTarget, tex);
+	if (pOpenGLDevice->TextureTarget != GL_TEXTURE_RECTANGLE_ARB)
+	{
+		pOpenGLDevice->glTexParameterf(pOpenGLDevice->TextureTarget, GL_TEXTURE_MIN_LOD, 0.0f);
+		pOpenGLDevice->glTexParameterf(pOpenGLDevice->TextureTarget, GL_TEXTURE_MAX_LOD, 0.0f);
+		pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget, GL_TEXTURE_BASE_LEVEL, 0);
+		pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget, GL_TEXTURE_MAX_LEVEL, 0);
+	}
+	const GLenum intfmt = pOpenGLDevice->have_GL_EXT_texture_compression_s3tc ? GL_COMPRESSED_RGBA_S3TC_DXT5_EXT : GL_RGBA;
+	if ((pOpenGLDevice->have_GL_ARB_texture_rectangle) || (pOpenGLDevice->have_GL_ARB_texture_non_power_of_two) || (_IsPowerOfTwo(width) && _IsPowerOfTwo(height))) {
+		pOpenGLDevice->glTexImage2D(pOpenGLDevice->TextureTarget, 0, intfmt, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+	}
+	else
+	{
+		t->potw = _NextPowerOfTwo(width);
+		t->poth = _NextPowerOfTwo(height);
+		pOpenGLDevice->glTexImage2D(pOpenGLDevice->TextureTarget, 0, intfmt, t->potw, t->poth, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+		pOpenGLDevice->glTexSubImage2D(pOpenGLDevice->TextureTarget, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+	}
+
+	pOpenGLDevice->glBindTexture(pOpenGLDevice->TextureTarget, CurTexture ? (((gltexture *) CurTexture)->name) : 0);
+
+	if (loadFromFile)
+		delete[] pixels;
+}
+
+HTEXTURE HGE_Impl::_BuildTexture(int width, int height, DWORD *pixels)
+{
+	gltexture *retval = new gltexture;
+	memset(retval, '\0', sizeof (gltexture));
+	retval->lost = true;  // we'll actually generate a texture and upload when forced.
+	retval->width = width;
+	retval->height = height;
+	retval->pixels = pixels;
+	return (HTEXTURE)retval;
+}
+
+HTEXTURE CALL HGE_Impl::Texture_Create(int width, int height)
+{
+	DWORD *pixels = new DWORD[width * height];
+	memset(pixels, '\0', sizeof (DWORD) * width * height);
+	HTEXTURE retval = _BuildTexture(width, height, pixels);
+
+	// the Direct3D renderer doesn't add these to the (textures) list, but we need them for when we "lose" the GL context.
+	if (retval != 0)
+	{
+		CTextureList *texItem=new CTextureList;
+		texItem->tex=retval;
+		texItem->width=width;
+		texItem->height=height;
+		texItem->next=textures;
+		textures=texItem;
+	}
+
+	return retval;
+}
+
+HTEXTURE CALL HGE_Impl::Texture_Load(const char *filename, DWORD size, bool bMipmap)
+{
+	HTEXTURE retval = 0;
+	int width = 0;
+	int height = 0;
+
+	void *data;
+	DWORD _size;
+	CTextureList *texItem;
+	const char *fname = NULL;
+	if(size) { data=(void *)filename; _size=size; }
+	else
+	{
+		fname = filename;
+		data=pHGE->Resource_Load(filename, &_size);
+		if(!data) return 0;
+	}
+
+	DWORD *pixels = _DecodeImage((BYTE *) data, fname, _size, width, height);
+	if (pixels != NULL)
+		retval = _BuildTexture(width, height, pixels);
+
+	if(!size) Resource_Free(data);
+
+	if (retval == 0)
+	{
+		STUBBED("texture load fail!");
+		_PostError("Can't create texture");
+	}
+	else
+	{
+		texItem=new CTextureList;
+		texItem->tex=retval;
+		texItem->width=width;
+		texItem->height=height;
+		texItem->next=textures;
+		textures=texItem;
+
+		// force an upload to the GL and lose our copy if it's backed by
+		//  a file. We won't keep it here to conserve system RAM.
+		if (!size)
+		{
+			gltexture *t = (gltexture *) retval;
+			_ConfigureTexture(t, t->width, t->height, t->pixels);
+			delete[] t->pixels;
+			t->pixels = NULL;
+			t->filename = strcpy(new char[strlen(filename) + 1], filename);
+		}
+	}
+
+	return retval;
+}
+
+void CALL HGE_Impl::Texture_Free(HTEXTURE tex)
+{
+	if (pOpenGLDevice == NULL)
+		return;  // in case we already shut down.
+
+	CTextureList *texItem=textures, *texPrev=0;
+
+	while(texItem)
+	{
+		if(texItem->tex==tex)
+		{
+			if(texPrev) texPrev->next=texItem->next;
+			else textures=texItem->next;
+			delete texItem;
+			break;
+		}
+		texPrev=texItem;
+		texItem=texItem->next;
+	}
+	if(tex)
+	{
+		gltexture *pTex = (gltexture *) tex;
+		delete[] pTex->filename;
+		delete[] pTex->lock_pixels;
+		delete[] pTex->pixels;
+		pOpenGLDevice->glDeleteTextures(1, &pTex->name);
+		delete pTex;
+	}
+}
+
+int CALL HGE_Impl::Texture_GetWidth(HTEXTURE tex, bool bOriginal)
+{
+	CTextureList *texItem=textures;
+
+	if(bOriginal)
+	{
+		while(texItem)
+		{
+			if(texItem->tex==tex) return texItem->width;
+			texItem=texItem->next;
+		}
+	}
+	else
+	{
+		return ((gltexture*)tex)->width;
+	}
+	return 0;
+}
+
+
+int CALL HGE_Impl::Texture_GetHeight(HTEXTURE tex, bool bOriginal)
+{
+	CTextureList *texItem=textures;
+
+	if(bOriginal)
+	{
+		while(texItem)
+		{
+			if(texItem->tex==tex) return texItem->height;
+			texItem=texItem->next;
+		}
+	}
+	else
+	{
+		return ((gltexture*)tex)->height;
+	}
+	return 0;
+}
+
+// HGE extension!
+// fast path for pushing YUV video to a texture instead of having to
+//  lock/convert-to-rgba/unlock...current HGE semantics involve a
+//  lot of unnecessary overhead on this, not to mention the conversion
+//  on the CPU is painful on PowerPC chips.
+// This lets us use OpenGL extensions to move data to the hardware
+//  without conversion.
+// Don't taunt this function. Side effects are probably rampant.
+bool CALL HGE_Impl::HGEEXT_Texture_PushYUV422(HTEXTURE tex, const BYTE *yuv)
+{
+	if (!pOpenGLDevice->have_GL_APPLE_ycbcr_422)
+		return false;
+
+	gltexture *pTex=(gltexture*)tex;
+	assert(!pTex->lock_pixels);
+
+	if (pTex->lost)  // just reupload the whole thing.
+		_ConfigureTexture(pTex, pTex->width, pTex->height, pTex->pixels);
+
+	// Any existing pixels aren't valid anymore.
+	if (pTex->pixels)
+	{
+		delete[] pTex->pixels;
+		pTex->pixels = NULL;
+	}
+
+	pOpenGLDevice->glBindTexture(pOpenGLDevice->TextureTarget, pTex->name);
+	pOpenGLDevice->glTexSubImage2D(pOpenGLDevice->TextureTarget, 0, 0, 0,
+	                               pTex->width, pTex->height, GL_YCBCR_422_APPLE,
+                                   GL_UNSIGNED_SHORT_8_8_APPLE, yuv);
+	pOpenGLDevice->glBindTexture(pOpenGLDevice->TextureTarget, CurTexture ? (((gltexture *) CurTexture)->name) : 0);
+	return true;
+}
+
+DWORD * CALL HGE_Impl::Texture_Lock(HTEXTURE tex, bool bReadOnly, int left, int top, int width, int height)
+{
+	gltexture *pTex=(gltexture*)tex;
+
+	if (pTex->lock_pixels)
+	{
+		assert(false && "multiple lock of texture...");
+		return 0;
+	}
+
+	// see if we're backed by a file and not RAM.
+	const bool loadFromFile = ((pTex->pixels == NULL) && (pTex->filename != NULL));
+	if (loadFromFile)
+	{
+		DWORD size = 0;
+		BYTE *data = (BYTE *) pHGE->Resource_Load(pTex->filename, &size);
+		if (data != NULL)
+		{
+			int w, h;
+			pTex->pixels = _DecodeImage(data, pTex->filename, size, w, h);
+			if ((w != (int)pTex->width) || (h != (int)pTex->height))  // yikes, file changed?
+			{
+				delete[] pTex->pixels;
+				pTex->pixels = NULL;
+			}
+			Resource_Free(data);
+		}
+		if (pTex->pixels != NULL)
+		{
+			// can't go back to file after we lock, since app might change data.
+			if (!bReadOnly)
+			{
+				delete[] pTex->filename;
+				pTex->filename = NULL;
+			}
+		}
+	}
+
+	if ((pTex->pixels == NULL) && (!pTex->is_render_target))  // can't lock this texture...?!
+		return 0;
+
+	// !!! FIXME: is this right?
+	if((width == 0) && (height == 0))
+	{
+		width = pTex->width;
+		height = pTex->height;
+	}
+
+	// !!! FIXME: do something with this?
+	assert(width > 0);
+	assert(width <= (int)pTex->width);
+	assert(height > 0);
+	assert(height <= (int)pTex->height);
+	assert(left >= 0);
+	assert(left <= width);
+	assert(top >= 0);
+	assert(top <= height);
+
+	pTex->lock_readonly = bReadOnly;
+	pTex->lock_x = left;
+	pTex->lock_y = top;
+	pTex->lock_width = width;
+	pTex->lock_height = height;
+	pTex->lock_pixels = new DWORD[width * height];
+
+	DWORD *dst = pTex->lock_pixels;
+
+	if (pTex->is_render_target)
+	{
+		assert(false && "need to bind fbo before glReadPixels...");
+		DWORD *upsideDown = new DWORD[width * height];
+		DWORD *src = upsideDown + ((height-1) * width);
+		pOpenGLDevice->glReadPixels(left, (pTex->height-top)-height, width, height, GL_RGBA, GL_UNSIGNED_BYTE, upsideDown);
+		for (int i = 0; i < height; i++)
+		{
+			memcpy(dst, src, width * sizeof (DWORD));
+			dst += width;
+			src -= width;
+		}
+		delete[] upsideDown;
+	}
+	else
+	{
+		DWORD *src = pTex->pixels + ((top*pTex->width) + left);
+		for (int i = 0; i < height; i++)
+		{
+			memcpy(dst, src, width * sizeof (DWORD));
+			dst += width;
+			src += pTex->width;
+		}
+	}
+
+	return pTex->lock_pixels;
+}
+
+
+void CALL HGE_Impl::Texture_Unlock(HTEXTURE tex)
+{
+	gltexture *pTex=(gltexture*)tex;
+
+	if (pTex->lock_pixels == NULL) return;  // not locked.
+
+	if (!pTex->lock_readonly)  // have to reupload to the hardware.
+	{
+		// need to update pTex->pixels ...
+		const DWORD *src = pTex->lock_pixels;
+		DWORD *dst = pTex->pixels + ((pTex->lock_y*pTex->width) + pTex->lock_x);
+		for (int i = 0; i < pTex->lock_height; i++)
+		{
+			memcpy(dst, src, pTex->lock_width * sizeof (DWORD));
+			dst += pTex->width;
+			src += pTex->lock_width;
+		}
+
+		if (pTex->lost)  // just reupload the whole thing.
+			_ConfigureTexture(pTex, pTex->width, pTex->height, pTex->pixels);
+		else
+		{
+			pOpenGLDevice->glBindTexture(pOpenGLDevice->TextureTarget, pTex->name);
+			pOpenGLDevice->glTexSubImage2D(pOpenGLDevice->TextureTarget, 0, pTex->lock_x,
+			                               (pTex->height-pTex->lock_y)-pTex->lock_height,
+			                               pTex->lock_width, pTex->lock_height, GL_RGBA,
+			                               GL_UNSIGNED_BYTE, pTex->lock_pixels);
+			pOpenGLDevice->glBindTexture(pOpenGLDevice->TextureTarget, CurTexture ? (((gltexture *) CurTexture)->name) : 0);
+		}
+	}
+
+	// if we were read-only and we're backed by a file, ditch the uncompressed copy in system RAM.
+	if ((pTex->filename != NULL) && (pTex->lock_readonly))
+	{
+		delete[] pTex->pixels;
+		pTex->pixels = NULL;
+	}
+
+	delete[] pTex->lock_pixels;
+	pTex->lock_pixels = NULL;
+	pTex->lock_readonly = false;
+	pTex->lock_x = -1;
+	pTex->lock_y = -1;
+	pTex->lock_width = -1;
+	pTex->lock_height = -1;
+}
+
+//////// Implementation ////////
+
+#define DEBUG_VERTICES 0
+#if DEBUG_VERTICES
+static inline void print_vertex(const hgeVertex *v)
+{
+    printf("  (%f, %f, %f), 0x%X, (%f, %f)\n", v->x, v->y, v->z, v->col, v->tx, v->ty);
+}
+#endif
+
+void HGE_Impl::_render_batch(bool bEndScene)
+{
+	if(VertArray)
+	{
+		if(nPrim)
+		{
+			const float h = (float) ((pCurTarget) ? pCurTarget->height : nScreenHeight);
+
+			// texture rectangles range from 0 to size, not 0 to 1.  :/
+			float texwmult = 1.0f;
+			float texhmult = 1.0f;
+
+			if (CurTexture)
+			{
+				_SetTextureFilter();
+				const gltexture *pTex = ((gltexture *)CurTexture);
+				if (pOpenGLDevice->TextureTarget == GL_TEXTURE_RECTANGLE_ARB)
+				{
+					texwmult = pTex->width;
+					texhmult = pTex->height;
+				}
+				else if ((pTex->potw != 0) && (pTex->poth != 0))
+				{
+					texwmult = ( ((float)pTex->width) / ((float)pTex->potw) );
+					texhmult = ( ((float)pTex->height) / ((float)pTex->poth) );
+				}
+			}
+
+			for (int i = 0; i < nPrim*CurPrimType; i++)
+			{
+				// (0, 0) is the lower left in OpenGL, upper left in D3D.
+				VertArray[i].y = h - VertArray[i].y;
+
+				// Z axis is inverted in OpenGL from D3D.
+				VertArray[i].z = -VertArray[i].z;
+
+				// (0, 0) is lower left texcoord in OpenGL, upper left in D3D.
+				// Also, scale for texture rectangles vs. 2D textures.
+				VertArray[i].tx *= texwmult;
+				VertArray[i].ty = (1.0f - VertArray[i].ty) * texhmult;
+
+				// Colors are RGBA in OpenGL, ARGB in Direct3D.
+				const DWORD color = VertArray[i].col;
+				BYTE *col = (BYTE *) &VertArray[i].col;
+				const BYTE a = ((color >> 24) & 0xFF);
+				const BYTE r = ((color >> 16) & 0xFF);
+				const BYTE g = ((color >>  8) & 0xFF);
+				const BYTE b = ((color >>  0) & 0xFF);
+				col[0] = r;
+				col[1] = g;
+				col[2] = b;
+				col[3] = a;
+			}
+
+			switch(CurPrimType)
+			{
+				case HGEPRIM_QUADS:
+					pOpenGLDevice->glDrawElements(GL_TRIANGLES, nPrim * 6, GL_UNSIGNED_SHORT, pIB);
+					#if DEBUG_VERTICES
+					for (int i = 0; i < nPrim*6; i+=3)
+					{
+						printf("QUAD'S TRIANGLE:\n");
+						print_vertex(&pVB[pIB[i+0]]);
+						print_vertex(&pVB[pIB[i+1]]);
+						print_vertex(&pVB[pIB[i+2]]);
+					}
+					printf("DONE.\n");
+					#endif
+					break;
+
+				case HGEPRIM_TRIPLES:
+					pOpenGLDevice->glDrawArrays(GL_TRIANGLES, 0, nPrim * 3);
+					break;
+
+				case HGEPRIM_LINES:
+					pOpenGLDevice->glDrawArrays(GL_LINES, 0, nPrim * 2);
+					break;
+			}
+
+			nPrim=0;
+		}
+		if(bEndScene) VertArray = 0;
+		else VertArray = pVB;
+	}
+}
+
+void HGE_Impl::_SetBlendMode(int blend)
+{
+	if((blend & BLEND_ALPHABLEND) != (CurBlendMode & BLEND_ALPHABLEND))
+	{
+		if(blend & BLEND_ALPHABLEND) pOpenGLDevice->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+		else pOpenGLDevice->glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+	}
+
+	if((blend & BLEND_ZWRITE) != (CurBlendMode & BLEND_ZWRITE))
+	{
+		if(blend & BLEND_ZWRITE) pOpenGLDevice->glDepthMask(GL_TRUE);
+		else pOpenGLDevice->glDepthMask(GL_FALSE);
+	}
+
+	if((blend & BLEND_COLORADD) != (CurBlendMode & BLEND_COLORADD))
+	{
+		if(blend & BLEND_COLORADD) pOpenGLDevice->glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD);
+		else pOpenGLDevice->glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+	}
+
+	CurBlendMode = blend;
+}
+
+void HGE_Impl::_SetProjectionMatrix(int width, int height)
+{
+	pOpenGLDevice->glMatrixMode(GL_PROJECTION);
+	pOpenGLDevice->glLoadIdentity();
+	pOpenGLDevice->glOrtho(0, (float)width, 0, (float)height, 0.0f, 1.0f);
+	bTransforming = false;
+	clipX = 0;
+	clipY = 0;
+	clipW = width;
+	clipH = height;
+}
+
+void HGE_Impl::_UnloadOpenGLEntryPoints()
+{
+	#define GL_PROC(ext,fn,call,ret,params) pOpenGLDevice->fn = NULL;
+	#include "hge_glfuncs.h"
+	#undef GL_PROC
+}
+
+bool HGE_Impl::_HaveOpenGLExtension(const char *extlist, const char *ext)
+{
+	const char *ptr = strstr(extlist, ext);
+	if (ptr == NULL)
+		return false;
+
+	const char endchar = ptr[strlen(ext)];
+	if ((endchar == '\0') || (endchar == ' '))
+		return true;  // extension is in the list.
+
+	return false;  // just not supported, fail.
+}
+
+bool HGE_Impl::_LoadOpenGLEntryPoints()
+{
+	System_Log("%s: OpenGL: loading entry points and examining extensions...",GRAPHICS_SRC_FN);
+
+	// these can be reset to false below...
+	pOpenGLDevice->have_base_opengl = true;
+	pOpenGLDevice->have_GL_ARB_texture_rectangle = true;
+	pOpenGLDevice->have_GL_ARB_texture_non_power_of_two = true;
+	pOpenGLDevice->have_GL_EXT_framebuffer_object = true;
+	pOpenGLDevice->have_GL_EXT_texture_compression_s3tc = true;
+	pOpenGLDevice->have_GL_ARB_vertex_buffer_object = true;
+	pOpenGLDevice->have_GL_APPLE_ycbcr_422 = true;
+
+	#define GL_PROC(ext,fn,call,ret,params) \
+		if (pOpenGLDevice->have_##ext) { \
+			if ((pOpenGLDevice->fn = (_HGE_PFN_##fn) SDL_GL_GetProcAddress(#fn)) == NULL) { \
+				System_Log("Failed to load OpenGL entry point '" #fn "'"); \
+				pOpenGLDevice->have_##ext = false; \
+			} \
+		} else {}
+	#include "hge_glfuncs.h"
+	#undef GL_PROC
+
+	if (!pOpenGLDevice->have_base_opengl)
+	{
+		_UnloadOpenGLEntryPoints();
+		return false;
+	}
+
+	System_Log("%s: GL_RENDERER: %s",GRAPHICS_SRC_FN, (const char *) pOpenGLDevice->glGetString(GL_RENDERER));
+	System_Log("%s: GL_VENDOR: %s",GRAPHICS_SRC_FN, (const char *) pOpenGLDevice->glGetString(GL_VENDOR));
+	System_Log("%s: GL_VERSION: %s",GRAPHICS_SRC_FN, (const char *) pOpenGLDevice->glGetString(GL_VERSION));
+
+	const char *verstr = (const char *) pOpenGLDevice->glGetString(GL_VERSION);
+	int maj = 0;
+	int min = 0;
+	sscanf(verstr, "%d.%d", &maj, &min);
+
+	if ( (maj < 1) || ((maj == 1) && (min < 2)) )
+	{
+		_PostError("OpenGL implementation must be at least version 1.2");
+		_UnloadOpenGLEntryPoints();
+		return false;
+	}
+
+	const char *exts = (const char *) pOpenGLDevice->glGetString(GL_EXTENSIONS);
+
+	// NPOT texture support ...
+
+	if (_HaveOpenGLExtension(exts, "GL_ARB_texture_rectangle"))
+		pOpenGLDevice->have_GL_ARB_texture_rectangle = true;
+	else if (_HaveOpenGLExtension(exts, "GL_EXT_texture_rectangle"))
+		pOpenGLDevice->have_GL_ARB_texture_rectangle = true;
+	else if (_HaveOpenGLExtension(exts, "GL_NV_texture_rectangle"))
+		pOpenGLDevice->have_GL_ARB_texture_rectangle = true;
+	else
+		pOpenGLDevice->have_GL_ARB_texture_rectangle = false;
+
+	if (maj >= 2)
+		pOpenGLDevice->have_GL_ARB_texture_non_power_of_two = true;
+	else if (_HaveOpenGLExtension(exts, "GL_ARB_texture_non_power_of_two"))
+		pOpenGLDevice->have_GL_ARB_texture_non_power_of_two = true;
+	else
+		pOpenGLDevice->have_GL_ARB_texture_non_power_of_two = false;
+
+	if (pOpenGLDevice->have_GL_ARB_texture_rectangle)
+	{
+		System_Log("%s: OpenGL: Using GL_ARB_texture_rectangle",GRAPHICS_SRC_FN);
+		pOpenGLDevice->TextureTarget = GL_TEXTURE_RECTANGLE_ARB;
+	}
+	else if (pOpenGLDevice->have_GL_ARB_texture_non_power_of_two)
+	{
+		System_Log("%s: OpenGL: Using GL_ARB_texture_non_power_of_two",GRAPHICS_SRC_FN);
+		pOpenGLDevice->TextureTarget = GL_TEXTURE_2D;
+	}
+	else
+	{
+		// We can fake this with POT textures. Get a real OpenGL!
+		System_Log("%s: OpenGL: Using power-of-two textures. This costs more memory!",GRAPHICS_SRC_FN);
+		pOpenGLDevice->TextureTarget = GL_TEXTURE_2D;
+	}
+
+	// render-to-texture support ...
+
+	// is false if an entry point is missing, but we still need to check for the extension string...
+	if (pOpenGLDevice->have_GL_EXT_framebuffer_object)
+	{
+		// Disable this on Mac OS X Tiger, since some drivers appear to be buggy.
+		if ((pHGE->MacOSXVersion) && (pHGE->MacOSXVersion < 0x1050))
+			pOpenGLDevice->have_GL_EXT_framebuffer_object = false;
+		else if (_HaveOpenGLExtension(exts, "GL_EXT_framebuffer_object"))
+			pOpenGLDevice->have_GL_EXT_framebuffer_object = true;
+		else
+			pOpenGLDevice->have_GL_EXT_framebuffer_object = false;
+	}
+
+	if (pOpenGLDevice->have_GL_EXT_framebuffer_object)
+		System_Log("%s: OpenGL: Using GL_EXT_framebuffer_object",GRAPHICS_SRC_FN);
+	else
+		System_Log("%s: OpenGL: WARNING! No render-to-texture support. Things may render badly.",GRAPHICS_SRC_FN);
+
+
+	// Texture compression ...
+
+	if (bForceTextureCompression &&
+	    _HaveOpenGLExtension(exts, "GL_ARB_texture_compression") &&
+	    _HaveOpenGLExtension(exts, "GL_EXT_texture_compression_s3tc"))
+		pOpenGLDevice->have_GL_EXT_texture_compression_s3tc = true;
+	else
+		pOpenGLDevice->have_GL_EXT_texture_compression_s3tc = false;
+
+	if (pOpenGLDevice->have_GL_EXT_texture_compression_s3tc)
+		System_Log("%s: OpenGL: Using GL_EXT_texture_compression_s3tc",GRAPHICS_SRC_FN);
+	else if (bForceTextureCompression)
+	{
+		bForceTextureCompression = false;  // oh well.
+		System_Log("%s: OpenGL: WARNING: no texture compression support, in a low-memory system.",GRAPHICS_SRC_FN);
+		System_Log("%s: OpenGL:  Performance may be very bad!",GRAPHICS_SRC_FN);
+	}
+
+	// YUV textures...
+
+	if (_HaveOpenGLExtension(exts, "GL_APPLE_ycbcr_422"))
+		pOpenGLDevice->have_GL_APPLE_ycbcr_422 = true;
+	else
+		pOpenGLDevice->have_GL_APPLE_ycbcr_422 = false;
+
+	if (pOpenGLDevice->have_GL_APPLE_ycbcr_422)
+		System_Log("%s: OpenGL: Using GL_APPLE_ycbcr_422 to render YUV frames.",GRAPHICS_SRC_FN);
+	else
+		System_Log("%s: OpenGL: WARNING: no YUV texture support; videos may render slowly.",GRAPHICS_SRC_FN);
+
+	// VBOs...
+
+	// is false if an entry point is missing, but we still need to check for the extension string...
+	if (pOpenGLDevice->have_GL_ARB_vertex_buffer_object)
+	{
+		if (_HaveOpenGLExtension(exts, "GL_ARB_vertex_buffer_object"))
+			pOpenGLDevice->have_GL_ARB_vertex_buffer_object = true;
+		else
+			pOpenGLDevice->have_GL_ARB_vertex_buffer_object = false;
+	}
+
+	if (pOpenGLDevice->have_GL_ARB_vertex_buffer_object)
+		System_Log("%s: OpenGL: Using GL_ARB_vertex_buffer_object",GRAPHICS_SRC_FN);
+	else
+		System_Log("%s: OpenGL: WARNING! No VBO support; performance may suffer.",GRAPHICS_SRC_FN);
+
+	return true;
+}
+
+bool HGE_Impl::_GfxInit()
+{
+	CurTexture = 0;
+
+// Init OpenGL ... SDL should have created a context at this point.
+	assert(pOpenGLDevice == NULL);
+	pOpenGLDevice = new COpenGLDevice;
+	if (!_LoadOpenGLEntryPoints())
+		return false;   // already called _PostError().
+
+	nScreenBPP=SDL_GetVideoSurface()->format->BitsPerPixel;
+
+	_AdjustWindow();
+
+	System_Log("%s: Mode: %d x %d\n",GRAPHICS_SRC_FN,nScreenWidth,nScreenHeight);
+// Create vertex batch buffer
+
+	VertArray=0;
+	textures=0;
+	IndexBufferObject=0;
+
+// Init all stuff that can be lost
+
+	if(!_init_lost()) return false;
+
+	// make sure the framebuffers are cleared and force to screen
+	pOpenGLDevice->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	SDL_GL_SwapBuffers();
+	pOpenGLDevice->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	SDL_GL_SwapBuffers();
+
+	return true;
+}
+
+void HGE_Impl::_AdjustWindow()
+{
+	// no-op.
+}
+
+void HGE_Impl::_Resize(int width, int height)
+{
+	if(hwndParent)
+	{
+		//if(procFocusLostFunc) procFocusLostFunc();
+		STUBBED("resize");
+		#if 0
+		d3dppW.BackBufferWidth=width;
+		d3dppW.BackBufferHeight=height;
+		nScreenWidth=width;
+		nScreenHeight=height;
+
+		_SetProjectionMatrix(nScreenWidth, nScreenHeight);
+		_GfxRestore();
+		#endif
+
+		//if(procFocusGainFunc) procFocusGainFunc();
+	}
+}
+
+void HGE_Impl::_GfxDone()
+{
+	//CRenderTargetList *target=pTargets;
+
+	while(textures)	Texture_Free(textures->tex);
+	while(pTargets)	Target_Free((HTARGET) pTargets);
+	textures=0;
+	pTargets=0;
+
+	VertArray = 0;
+	delete[] pVB;
+	pVB=0;
+	delete[] pIB;
+	pIB=0;
+
+	if(pOpenGLDevice)
+	{
+		if (pOpenGLDevice->have_GL_ARB_vertex_buffer_object)
+		{
+			if (IndexBufferObject != 0)
+			{
+				pOpenGLDevice->glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, 0);
+				pOpenGLDevice->glDeleteBuffersARB(1, &IndexBufferObject);
+				IndexBufferObject = 0;
+			}
+		}
+
+		delete pOpenGLDevice;
+		pOpenGLDevice=0;
+	}
+}
+
+
+bool HGE_Impl::_GfxRestore()
+{
+	if(!pOpenGLDevice) return false;
+
+	delete[] pVB;
+	pVB=0;
+
+	delete[] pIB;
+	pIB=0;
+
+	_UnloadOpenGLEntryPoints();
+	if (!_LoadOpenGLEntryPoints())
+		return false;
+
+	if(!_init_lost()) return false;
+
+	if(procGfxRestoreFunc) return procGfxRestoreFunc();
+
+	return true;
+}
+
+
+bool HGE_Impl::_init_lost()
+{
+	_BindTexture(NULL);  // make sure nothing is bound, so everything that we do bind regenerates.
+
+	for (CTextureList *item = textures; item != NULL; item = item->next)
+	{
+		gltexture *t = (gltexture *) item->tex;
+		if (t == NULL) continue;
+		t->lost = true;
+		t->name = 0;
+	}
+
+	CRenderTargetList *target=pTargets;
+	while(target)
+	{
+		gltexture *tex = (gltexture *) target->tex;
+		_BindTexture(tex);  // force texture recreation.
+		_BindTexture(NULL);
+		_BuildTarget(target, tex ? tex->name : 0, target->width, target->height, target->depth != 0);
+		target=target->next;
+	}
+
+// Create Vertex buffer
+	// We just use a client-side array, since you can reasonably count on support
+	//  existing in any GL, and it basically offers the same functionality that
+	//  HGE uses in Direct3D: it locks the vertex buffer, unlocks in time to
+	//  draw something, then relocks again immediately...more or less, that method
+	//  offers the same performance metrics as a client-side array.
+	// We _will_ stuff the indices in a buffer object, though, if possible,
+	//  since they never change...this matches the D3D behaviour better, since
+	//  they lock, store, and forget about it, but without a buffer object,
+	//  we'd have to pass the array over the bus every glDrawElements() call.
+	//  It's not worth the tapdance for vertex buffer objects though, due to
+	//  HGE's usage patterns.
+	pVB = new hgeVertex[VERTEX_BUFFER_SIZE];
+
+// Create and setup Index buffer
+	pIB = new GLushort[VERTEX_BUFFER_SIZE*6/4];
+	GLushort *pIndices = pIB;
+	int n = 0;
+	for(int i=0; i<VERTEX_BUFFER_SIZE/4; i++) {
+		*pIndices++=n;
+		*pIndices++=n+1;
+		*pIndices++=n+2;
+		*pIndices++=n+2;
+		*pIndices++=n+3;
+		*pIndices++=n;
+		n+=4;
+	}
+
+	#if !DEBUG_VERTICES  // need pIB for DEBUG_VERTICES.
+	if (pOpenGLDevice->have_GL_ARB_vertex_buffer_object)
+	{
+		// stay bound forever. The Index Buffer Object never changes.
+		pOpenGLDevice->glGenBuffersARB(1, &IndexBufferObject);
+		pOpenGLDevice->glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, IndexBufferObject);
+		pOpenGLDevice->glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER, sizeof (GLushort) * ((VERTEX_BUFFER_SIZE*6)/4), pIB, GL_STATIC_DRAW);
+		delete[] pIB;
+		pIB=0;
+	}
+	#endif
+
+	// always use client-side arrays; set it up once at startup.
+	pOpenGLDevice->glVertexPointer(3, GL_FLOAT, sizeof (hgeVertex), &pVB[0].x);
+	pOpenGLDevice->glColorPointer(4, GL_UNSIGNED_BYTE, sizeof (hgeVertex), &pVB[0].col);
+	pOpenGLDevice->glTexCoordPointer(2, GL_FLOAT, sizeof (hgeVertex), &pVB[0].tx);
+	pOpenGLDevice->glEnableClientState(GL_VERTEX_ARRAY);
+	pOpenGLDevice->glEnableClientState(GL_COLOR_ARRAY);
+	pOpenGLDevice->glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+
+// Set common render states
+
+	pOpenGLDevice->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+	pOpenGLDevice->glPixelStorei(GL_PACK_ALIGNMENT, 1);
+
+	//pD3DDevice->SetRenderState( D3DRS_LASTPIXEL, FALSE );
+	pOpenGLDevice->glDisable(GL_TEXTURE_2D);
+	if (pOpenGLDevice->have_GL_ARB_texture_rectangle)
+		pOpenGLDevice->glDisable(GL_TEXTURE_RECTANGLE_ARB);
+	pOpenGLDevice->glEnable(pOpenGLDevice->TextureTarget);
+	pOpenGLDevice->glEnable(GL_SCISSOR_TEST);
+	pOpenGLDevice->glDisable(GL_CULL_FACE);
+	pOpenGLDevice->glDisable(GL_LIGHTING);
+	pOpenGLDevice->glDepthFunc(GL_GEQUAL);
+
+	if (bZBuffer)
+		pOpenGLDevice->glEnable(GL_DEPTH_TEST);
+	else
+		pOpenGLDevice->glDisable(GL_DEPTH_TEST);
+
+	pOpenGLDevice->glEnable(GL_BLEND);
+	pOpenGLDevice->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+	pOpenGLDevice->glEnable(GL_ALPHA_TEST);
+	pOpenGLDevice->glAlphaFunc(GL_GEQUAL, 1.0f / 255.0f);
+
+	pOpenGLDevice->glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+
+	_SetTextureFilter();
+
+	// !!! FIXME: this isn't what HGE's Direct3D code does, but the game I'm working with
+	// !!! FIXME:  forces clamping outside of HGE, so I just wedged it in here.
+	// Apple says texture rectangle on ATI X1000 chips only supports CLAMP_TO_EDGE.
+	// Texture rectangle only supports CLAMP* wrap modes anyhow.
+	pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	pOpenGLDevice->glTexParameteri(pOpenGLDevice->TextureTarget, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
+
+	nPrim=0;
+	CurPrimType=HGEPRIM_QUADS;
+	CurBlendMode = BLEND_DEFAULT;
+	CurTexture = 0;
+
+	pOpenGLDevice->glScissor(0, 0, nScreenWidth, nScreenHeight);
+	pOpenGLDevice->glViewport(0, 0, nScreenWidth, nScreenHeight);
+
+	// make sure the framebuffer is cleared and force to screen
+	pOpenGLDevice->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+	_SetProjectionMatrix(nScreenWidth, nScreenHeight);
+	pOpenGLDevice->glMatrixMode(GL_MODELVIEW);
+	pOpenGLDevice->glLoadIdentity();
+
+	return true;
+}