mesa: Remove obsolete Windows gldirect and ICD drivers

Acked-by: Kristian Høgsberg <[email protected]>
Acked-by: Marek Olšák <[email protected]>
Acked-by: Alan Coopersmith <[email protected]>
Acked-by: Jakob Bornecrantz <[email protected]>
Acked-by: Dave Airlie <[email protected]>
Build-Tested-by: Jakob Bornecrantz <[email protected]>
Tested-by: Eugeni Dodonov <[email protected]>

1 files changed, 0 insertions, 2964 deletions

diff --git a/src/mesa/drivers/windows/gldirect/dglwgl.c b/src/mesa/drivers/windows/gldirect/dglwgl.c
deleted file mode 100644
index c46cfe162f9..00000000000
--- a/src/mesa/drivers/windows/gldirect/dglwgl.c
+++ /dev/null
@@ -1,2964 +0,0 @@
-/****************************************************************************
-*
-*                        Mesa 3-D graphics library
-*                        Direct3D Driver Interface
-*
-*  ========================================================================
-*
-*   Copyright (C) 1991-2004 SciTech Software, Inc. All rights reserved.
-*
-*   Permission is hereby granted, free of charge, to any person obtaining a
-*   copy of this software and associated documentation files (the "Software"),
-*   to deal in the Software without restriction, including without limitation
-*   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-*   and/or sell copies of the Software, and to permit persons to whom the
-*   Software is furnished to do so, subject to the following conditions:
-*
-*   The above copyright notice and this permission notice shall be included
-*   in all copies or substantial portions of the Software.
-*
-*   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-*   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-*   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
-*   SCITECH SOFTWARE INC BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-*   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
-*   OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-*   SOFTWARE.
-*
-*  ======================================================================
-*
-* Language:     ANSI C
-* Environment:  Windows 9x (Win32)
-*
-* Description:  OpenGL window  functions (wgl*).
-*
-****************************************************************************/
-
-#include "dglwgl.h"
-#ifdef _USE_GLD3_WGL
-#include "gld_driver.h"
-#endif
-
-#include "gl/glu.h"	// MUST USE MICROSOFT'S GLU32!
-
-#ifndef _USE_GLD3_WGL
-extern DGL_mesaFuncs mesaFuncs;
-#endif
-
-// Need to export wgl* functions if using GLD3,
-// otherwise export GLD2 DGL_* functions.
-#ifdef _USE_GLD3_WGL
-#define _GLD_WGL_EXPORT(a) wgl##a
-#else
-#define _GLD_WGL_EXPORT(a) DGL_##a
-#endif
-
-// Calls into Mesa 4.x are different
-#ifdef _USE_GLD3_WGL
-#include "dlist.h"
-#include "drawpix.h"
-#include "get.h"
-#include "matrix.h"
-// NOTE: All the _GLD* macros now call the gl* functions direct.
-//       This ensures that the correct internal pathway is taken. KeithH
-#define _GLD_glNewList		glNewList
-#define _GLD_glBitmap		glBitmap
-#define _GLD_glEndList		glEndList
-#define _GLD_glDeleteLists	glDeleteLists
-#define _GLD_glGetError		glGetError
-#define _GLD_glTranslatef	glTranslatef
-#define _GLD_glBegin		glBegin
-#define _GLD_glVertex2fv	glVertex2fv
-#define _GLD_glEnd			glEnd
-#define _GLD_glNormal3f		glNormal3f
-#define _GLD_glVertex3f		glVertex3f
-#define _GLD_glVertex3fv	glVertex3fv
-#else // _USE_GLD3_WGL
-#define _GLD_glNewList		(*mesaFuncs.glNewList)
-#define _GLD_glBitmap		(*mesaFuncs.glBitmap)
-#define _GLD_glEndList		(*mesaFuncs.glEndList)
-#define _GLD_glDeleteLists	(*mesaFuncs.glDeleteLists)
-#define _GLD_glGetError		(*mesaFuncs.glGetError)
-#define _GLD_glTranslatef	(*mesaFuncs.glTranslatef)
-#define _GLD_glBegin		(*mesaFuncs.glBegin)
-#define _GLD_glVertex2fv	(*mesaFuncs.glVertex2fv)
-#define _GLD_glEnd			(*mesaFuncs.glEnd)
-#define _GLD_glNormal3f		(*mesaFuncs.glNormal3f)
-#define _GLD_glVertex3f		(*mesaFuncs.glVertex3f)
-#define _GLD_glVertex3fv	(*mesaFuncs.glVertex3fv)
-#endif // _USE_GLD3_WGL
-
-// ***********************************************************************
-
-// Emulate SGI DDK calls.
-#define __wglMalloc(a) GlobalAlloc(GPTR, (a))
-#define __wglFree(a) GlobalFree((a))
-
-// ***********************************************************************
-
-// Mesa glu.h and MS glu.h call these different things...
-//#define GLUtesselator GLUtriangulatorObj
-//#define GLU_TESS_VERTEX_DATA GLU_VERTEX_DATA
-
-// For wglFontOutlines
-
-typedef GLUtesselator *(APIENTRY *gluNewTessProto)(void);
-typedef void (APIENTRY *gluDeleteTessProto)(GLUtesselator *tess);
-typedef void (APIENTRY *gluTessBeginPolygonProto)(GLUtesselator *tess, void *polygon_data);
-typedef void (APIENTRY *gluTessBeginContourProto)(GLUtesselator *tess);
-typedef void (APIENTRY *gluTessVertexProto)(GLUtesselator *tess, GLdouble coords[3], void *data);
-typedef void (APIENTRY *gluTessEndContourProto)(GLUtesselator *tess);
-typedef void (APIENTRY *gluTessEndPolygonProto)(GLUtesselator *tess);
-typedef void (APIENTRY *gluTessPropertyProto)(GLUtesselator *tess, GLenum which, GLdouble value);
-typedef void (APIENTRY *gluTessNormalProto)(GLUtesselator *tess, GLdouble x, GLdouble y, GLdouble z);
-typedef void (APIENTRY *gluTessCallbackProto)(GLUtesselator *tess, GLenum which, void (CALLBACK *)());
-
-static HINSTANCE		gluModuleHandle;
-static gluNewTessProto		gluNewTessProc;
-static gluDeleteTessProto	gluDeleteTessProc;
-static gluTessBeginPolygonProto	gluTessBeginPolygonProc;
-static gluTessBeginContourProto	gluTessBeginContourProc;
-static gluTessVertexProto	gluTessVertexProc;
-static gluTessEndContourProto	gluTessEndContourProc;
-static gluTessEndPolygonProto	gluTessEndPolygonProc;
-static gluTessPropertyProto	gluTessPropertyProc;
-static gluTessNormalProto	gluTessNormalProc;
-static gluTessCallbackProto	gluTessCallbackProc;
-
-static HFONT	hNewFont, hOldFont;
-static FLOAT	ScaleFactor;
-
-#define LINE_BUF_QUANT 4000
-#define VERT_BUF_QUANT 4000
-
-static FLOAT*	LineBuf;
-static DWORD	LineBufSize;
-static DWORD	LineBufIndex;
-static FLOAT*	VertBuf;
-static DWORD	VertBufSize;
-static DWORD	VertBufIndex;
-static GLenum	TessErrorOccurred;
-
-static int AppendToLineBuf(
-	FLOAT value);
-
-static int AppendToVertBuf(
-	FLOAT value);
-
-static int DrawGlyph(
-	UCHAR*		glyphBuf,
-	DWORD		glyphSize,
-	FLOAT		chordalDeviation,
-	FLOAT		extrusion,
-	INT		format);
-
-static void FreeLineBuf(void);
-
-static void FreeVertBuf(void);
-
-static long GetWord(
-	UCHAR**		p);
-
-static long GetDWord(
-	UCHAR**		p);
-
-static double GetFixed(
-	UCHAR**		p);
-
-static int InitLineBuf(void);
-
-static int InitVertBuf(void);
-
-static HFONT CreateHighResolutionFont(
-	HDC		hDC);
-
-static int MakeDisplayListFromGlyph(
-	DWORD			listName,
-	UCHAR*			glyphBuf,
-	DWORD			glyphSize,
-	LPGLYPHMETRICSFLOAT	glyphMetricsFloat,
-	FLOAT			chordalDeviation,
-	FLOAT			extrusion,
-	INT			format);
-
-static BOOL LoadGLUTesselator(void);
-static BOOL UnloadGLUTesselator(void);
-
-static int MakeLinesFromArc(
-	FLOAT		x0,
-	FLOAT		y0,
-	FLOAT		x1,
-	FLOAT		y1,
-	FLOAT		x2,
-	FLOAT		y2,
-	DWORD		vertexCountIndex,
-	FLOAT		chordalDeviationSquared);
-
-static int MakeLinesFromGlyph(		UCHAR*		glyphBuf,
-					DWORD		glyphSize,
-					FLOAT		chordalDeviation);
-
-static int MakeLinesFromTTLine(		UCHAR**		pp,
-					DWORD		vertexCountIndex,
-					WORD		pointCount);
-
-static int MakeLinesFromTTPolycurve(	UCHAR**		pp,
-					DWORD		vertexCountIndex,
-					FLOAT		chordalDeviation);
-
-static int MakeLinesFromTTPolygon(	UCHAR**		pp,
-					FLOAT		chordalDeviation);
-
-static int MakeLinesFromTTQSpline(	UCHAR**		pp,
-					DWORD		vertexCountIndex,
-					WORD		pointCount,
-					FLOAT		chordalDeviation);
-
-static void CALLBACK TessCombine(	double		coords[3],
-					void*		vertex_data[4],
-					FLOAT		weight[4],
-					void**		outData);
-
-static void CALLBACK TessError(		GLenum		error);
-
-static void CALLBACK TessVertexOutData(	FLOAT		p[3],
-					GLfloat 	z);
-
-// ***********************************************************************
-
-#ifdef GLD_THREADS
-#pragma message("compiling DGLWGL.C vars for multi-threaded support")
-extern CRITICAL_SECTION CriticalSection;
-extern DWORD dwTLSPixelFormat;			// TLS index for current pixel format
-#endif
-int curPFD = 0;							// Current PFD (static)
-
-// ***********************************************************************
-
-int dglGetPixelFormat(void)
-{
-#ifdef GLD_THREADS
-	int iPixelFormat;
-	// get thread-specific instance
-	if (glb.bMultiThreaded) {
-		__try {
-			iPixelFormat = (int)TlsGetValue(dwTLSPixelFormat);
-		}
-		__except(EXCEPTION_EXECUTE_HANDLER) {
-			iPixelFormat = curPFD;
-		}
-	}
-	// get global static var
-	else {
-		iPixelFormat = curPFD;
-	}
-	return iPixelFormat;
-#else
-	return curPFD;
-#endif
-}
-
-// ***********************************************************************
-
-void dglSetPixelFormat(int iPixelFormat)
-{
-#ifdef GLD_THREADS
-	// set thread-specific instance
-	if (glb.bMultiThreaded) {
-		__try {
-			TlsSetValue(dwTLSPixelFormat, (LPVOID)iPixelFormat);
-		}
-		__except(EXCEPTION_EXECUTE_HANDLER) {
-			curPFD = iPixelFormat;
-		}
-	}
-	// set global static var
-	else {
-		curPFD = iPixelFormat;
-	}
-#else
-	curPFD = iPixelFormat;
-#endif
-}
-
-// ***********************************************************************
-
-int APIENTRY _GLD_WGL_EXPORT(ChoosePixelFormat)(
-	HDC a,
-	CONST PIXELFORMATDESCRIPTOR *ppfd)
-{
-	DGL_pixelFormat			*lpPF = glb.lpPF;
-
-    PIXELFORMATDESCRIPTOR	ppfdBest;
-    int						i;
-	int						bestIndex = -1;
-    int						numPixelFormats;
-	DWORD					dwFlags;
-
-	char					buf[128];
-	char					cat[8];
-
-	DWORD dwAllFlags = 
-					PFD_DRAW_TO_WINDOW |
-					PFD_DRAW_TO_BITMAP |
-					PFD_SUPPORT_GDI |
-					PFD_SUPPORT_OPENGL |
-					PFD_GENERIC_FORMAT |
-					PFD_NEED_PALETTE |
-					PFD_NEED_SYSTEM_PALETTE |
-					PFD_DOUBLEBUFFER |
-					PFD_STEREO |
-					/*PFD_SWAP_LAYER_BUFFERS |*/
-					PFD_DOUBLEBUFFER_DONTCARE |
-					PFD_STEREO_DONTCARE |
-					PFD_SWAP_COPY |
-					PFD_SWAP_EXCHANGE |
-					PFD_GENERIC_ACCELERATED |
-					0;
-
-	// Validate license
-	if (!dglValidate())
-		return 0;
-
-	// List may not be built until dglValidate() is called! KeithH
-	lpPF = glb.lpPF;
-
-	//
-	// Lets print the input pixel format to the log
-	// ** Based on "wglinfo" by Nate Robins **
-	//
-	ddlogMessage(DDLOG_SYSTEM, "ChoosePixelFormat:\n");
-	ddlogMessage(DDLOG_INFO, "Input pixel format for ChoosePixelFormat:\n");
-	ddlogMessage(DDLOG_INFO,
-		"   visual  x  bf lv rg d st  r  g  b a  ax dp st accum buffs  ms\n");
-	ddlogMessage(DDLOG_INFO,
-		" id dep cl sp sz l  ci b ro sz sz sz sz bf th cl  r  g  b  a ns b\n");
-	ddlogMessage(DDLOG_INFO,
-		"-----------------------------------------------------------------\n");
-	sprintf(buf, "  .  ");
-
-	sprintf(cat, "%2d ", ppfd->cColorBits);
-	strcat(buf, cat);
-	if(ppfd->dwFlags & PFD_DRAW_TO_WINDOW)      sprintf(cat, "wn ");
-	else if(ppfd->dwFlags & PFD_DRAW_TO_BITMAP) sprintf(cat, "bm ");
-	else sprintf(cat, ".  ");
-	strcat(buf, cat);
-
-	/* should find transparent pixel from LAYERPLANEDESCRIPTOR */
-	sprintf(cat, " . "); 
-	strcat(buf, cat);
-
-	sprintf(cat, "%2d ", ppfd->cColorBits);
-	strcat(buf, cat);
-
-	/* bReserved field indicates number of over/underlays */
-	if(ppfd->bReserved) sprintf(cat, " %d ", ppfd->bReserved);
-	else sprintf(cat, " . "); 
-	strcat(buf, cat);
-
-	sprintf(cat, " %c ", ppfd->iPixelType == PFD_TYPE_RGBA ? 'r' : 'c');
-	strcat(buf, cat);
-
-	sprintf(cat, "%c ", ppfd->dwFlags & PFD_DOUBLEBUFFER ? 'y' : '.');
-	strcat(buf, cat);
-
-	sprintf(cat, " %c ", ppfd->dwFlags & PFD_STEREO ? 'y' : '.');
-	strcat(buf, cat);
-
-	if(ppfd->cRedBits && ppfd->iPixelType == PFD_TYPE_RGBA) 
-	    sprintf(cat, "%2d ", ppfd->cRedBits);
-	else sprintf(cat, " . ");
-	strcat(buf, cat);
-
-	if(ppfd->cGreenBits && ppfd->iPixelType == PFD_TYPE_RGBA) 
-	    sprintf(cat, "%2d ", ppfd->cGreenBits);
-	else sprintf(cat, " . ");
-	strcat(buf, cat);
-
-	if(ppfd->cBlueBits && ppfd->iPixelType == PFD_TYPE_RGBA) 
-	    sprintf(cat, "%2d ", ppfd->cBlueBits);
-	else sprintf(cat, " . ");
-	strcat(buf, cat);
-	
-	if(ppfd->cAlphaBits && ppfd->iPixelType == PFD_TYPE_RGBA) 
-		sprintf(cat, "%2d ", ppfd->cAlphaBits);
-	else sprintf(cat, " . ");
-	strcat(buf, cat);
-	
-	if(ppfd->cAuxBuffers)     sprintf(cat, "%2d ", ppfd->cAuxBuffers);
-	else sprintf(cat, " . ");
-	strcat(buf, cat);
-	
-	if(ppfd->cDepthBits)      sprintf(cat, "%2d ", ppfd->cDepthBits);
-	else sprintf(cat, " . ");
-	strcat(buf, cat);
-	
-	if(ppfd->cStencilBits)    sprintf(cat, "%2d ", ppfd->cStencilBits);
-	else sprintf(cat, " . ");
-	strcat(buf, cat);
-	
-	if(ppfd->cAccumRedBits)   sprintf(cat, "%2d ", ppfd->cAccumRedBits);
-	else sprintf(cat, " . ");
-	strcat(buf, cat);
-
-	if(ppfd->cAccumGreenBits) sprintf(cat, "%2d ", ppfd->cAccumGreenBits);
-	else sprintf(cat, " . ");
-	strcat(buf, cat);
-	
-	if(ppfd->cAccumBlueBits)  sprintf(cat, "%2d ", ppfd->cAccumBlueBits);
-	else sprintf(cat, " . ");
-	strcat(buf, cat);
-	
-	if(ppfd->cAccumAlphaBits) sprintf(cat, "%2d ", ppfd->cAccumAlphaBits);
-	else sprintf(cat, " . ");
-	strcat(buf, cat);
-	
-	/* no multisample in Win32 */
-	sprintf(cat, " . .\n");
-	strcat(buf, cat);
-
-	ddlogMessage(DDLOG_INFO, buf);
-	ddlogMessage(DDLOG_INFO,
-		"-----------------------------------------------------------------\n");
-	ddlogMessage(DDLOG_INFO, "\n");
-
-	//
-	// Examine the flags for correctness
-	//
-	dwFlags = ppfd->dwFlags;
-    if (dwFlags != (dwFlags & dwAllFlags))
-    {
-		/* error: bad dwFlags */
-		ddlogPrintf(DDLOG_WARN,
-					"ChoosePixelFormat: bad flags (0x%x)",
-					dwFlags & (~dwAllFlags));
-		// Mask illegal flags and continue
-		dwFlags = dwFlags & dwAllFlags;
-    }
-	
-    switch (ppfd->iPixelType) {
-    case PFD_TYPE_RGBA:
-    case PFD_TYPE_COLORINDEX:
-		break;
-    default:
-		/* error: bad iPixelType */
-		ddlogMessage(DDLOG_WARN, "ChoosePixelFormat: bad pixel type\n");
-		return 0;
-    }
-	
-    switch (ppfd->iLayerType) {
-    case PFD_MAIN_PLANE:
-    case PFD_OVERLAY_PLANE:
-    case PFD_UNDERLAY_PLANE:
-		break;
-    default:
-		/* error: bad iLayerType */
-		ddlogMessage(DDLOG_WARN, "ChoosePixelFormat: bad layer type\n");
-		return 0;
-    }
-	
-    numPixelFormats = glb.nPixelFormatCount;
-	
-    /* loop through candidate pixel format descriptors */
-    for (i=0; i<numPixelFormats; ++i) {
-		PIXELFORMATDESCRIPTOR ppfdCandidate;
-		
-		memcpy(&ppfdCandidate, &lpPF[i].pfd, sizeof(PIXELFORMATDESCRIPTOR));
-		
-		/*
-		** Check attributes which must match
-		*/
-		if (ppfd->iPixelType != ppfdCandidate.iPixelType) {
-			continue;
-		}
-
-		if (ppfd->iLayerType != ppfdCandidate.iLayerType) {
-			continue;
-		}
-		
-		if (((dwFlags ^ ppfdCandidate.dwFlags) & dwFlags) &
-			(PFD_DRAW_TO_WINDOW | PFD_DRAW_TO_BITMAP |
-			PFD_SUPPORT_GDI | PFD_SUPPORT_OPENGL))
-		{
-			continue;
-		}
-		
-		if (!(dwFlags & PFD_DOUBLEBUFFER_DONTCARE)) {
-			if ((dwFlags & PFD_DOUBLEBUFFER) !=
-				(ppfdCandidate.dwFlags & PFD_DOUBLEBUFFER))
-			{
-				continue;
-			}
-		}
-		
-//		if (!(dwFlags & PFD_STEREO_DONTCARE)) {
-			if ((dwFlags & PFD_STEREO) !=
-				(ppfdCandidate.dwFlags & PFD_STEREO))
-			{
-				continue;
-			}
-//		}
-		
-        if (ppfd->iPixelType==PFD_TYPE_RGBA
-            && ppfd->cAlphaBits && !ppfdCandidate.cAlphaBits) {
-            continue;
-		}
-		
-        if (ppfd->iPixelType==PFD_TYPE_RGBA
-			&& ppfd->cAccumBits && !ppfdCandidate.cAccumBits) {
-			continue;
-        }
-		
-        if (ppfd->cDepthBits && !ppfdCandidate.cDepthBits) {
-			continue;
-        }
-		
-        if (ppfd->cStencilBits && !ppfdCandidate.cStencilBits) {
-            continue;
-        }
-
-		if (ppfd->cAuxBuffers && !ppfdCandidate.cAuxBuffers) {
-			continue;
-		}
-		
-		/*
-		** See if candidate is better than the previous best choice
-		*/
-		if (bestIndex == -1) {
-			ppfdBest = ppfdCandidate;
-			bestIndex = i;
-			continue;
-		}
-		
-		if ((ppfd->cColorBits > ppfdBest.cColorBits &&
-			ppfdCandidate.cColorBits > ppfdBest.cColorBits) ||
-			(ppfd->cColorBits <= ppfdCandidate.cColorBits &&
-			ppfdCandidate.cColorBits < ppfdBest.cColorBits))
-		{
-			ppfdBest = ppfdCandidate;
-			bestIndex = i;
-			continue;
-		}
-		
-		if (ppfd->iPixelType==PFD_TYPE_RGBA
-            && ppfd->cAlphaBits
-            && ppfdCandidate.cAlphaBits > ppfdBest.cAlphaBits)
-		{
-			ppfdBest = ppfdCandidate;
-			bestIndex = i;
-			continue;
-		}
-		
-		if (ppfd->iPixelType==PFD_TYPE_RGBA
-			&& ppfd->cAccumBits
-            && ppfdCandidate.cAccumBits > ppfdBest.cAccumBits)
-		{
-			ppfdBest = ppfdCandidate;
-			bestIndex = i;
-			continue;
-		}
-		
-		if ((ppfd->cDepthBits > ppfdBest.cDepthBits &&
-			ppfdCandidate.cDepthBits > ppfdBest.cDepthBits) ||
-			(ppfd->cDepthBits <= ppfdCandidate.cDepthBits &&
-			ppfdCandidate.cDepthBits < ppfdBest.cDepthBits))
-		{
-			ppfdBest = ppfdCandidate;
-			bestIndex = i;
-			continue;
-		}
-		
-		if (ppfd->cStencilBits &&
-			ppfdCandidate.cStencilBits > ppfdBest.cStencilBits)
-		{
-			ppfdBest = ppfdCandidate;
-			bestIndex = i;
-			continue;
-		}
-		
-		if (ppfd->cAuxBuffers &&
-			ppfdCandidate.cAuxBuffers > ppfdBest.cAuxBuffers)
-		{
-			ppfdBest = ppfdCandidate;
-			bestIndex = i;
-			continue;
-		}
-    }
-
-	if (bestIndex != -1) {
-		ddlogPrintf(DDLOG_SYSTEM, "Pixel Format %d chosen as best match", bestIndex+1);
-	    return bestIndex + 1;
-	}
-
-	// Return the pixelformat that has the most capabilities.
-	// ** NOTE: This is only possible due to the way the list
-	// of pixelformats is built. **
-	// Now picks best pixelformat. KeithH
-	bestIndex = numPixelFormats;	// most capable double buffer format
-	ddlogPrintf(DDLOG_SYSTEM, "Pixel Format %d chosen by default", bestIndex);
-	return (bestIndex);
-}
-
-// ***********************************************************************
-
-BOOL APIENTRY _GLD_WGL_EXPORT(CopyContext)(
-	HGLRC a,
-	HGLRC b,
-	UINT c)
-{
-	// Validate license
-	if (!dglValidate())
-		return FALSE;
-    UNSUPPORTED("wglCopyContext")
-    return FALSE; // Failed
-}
-
-// ***********************************************************************
-
-HGLRC APIENTRY _GLD_WGL_EXPORT(CreateContext)(
-	HDC a)
-{
-	int ipf;
-
-	// Validate license
-	if (!dglValidate())
-		return 0;
-
-	// Check that the current PFD is valid
-	ipf = dglGetPixelFormat();
-	if (!IsValidPFD(ipf))
-		return (HGLRC)0;
-
-	return dglCreateContext(a, &glb.lpPF[ipf-1]);
-}
-
-// ***********************************************************************
-
-HGLRC APIENTRY _GLD_WGL_EXPORT(CreateLayerContext)(
-	HDC a,
-	int b)
-{
-	// Validate license
-	if (!dglValidate())
-		return 0;
-
-    UNSUPPORTED("wglCreateLayerContext")
-    return NULL; // Failed
-}
-
-// ***********************************************************************
-
-BOOL APIENTRY _GLD_WGL_EXPORT(DeleteContext)(
-	HGLRC a)
-{
-	// Validate license
-	if (!dglValidate())
-		return FALSE;
-
-    return dglDeleteContext(a);
-}
-
-// ***********************************************************************
-
-BOOL APIENTRY _GLD_WGL_EXPORT(DescribeLayerPlane)(
-	HDC hDC,
-	int iPixelFormat,
-	int iLayerPlane,
-	UINT nBytes,
-	LPLAYERPLANEDESCRIPTOR plpd)
-{
-	// Validate license
-	if (!dglValidate())
-		return FALSE;
-
-	UNSUPPORTED("DGL_DescribeLayerPlane")
-
-//	gldLogPrintf(GLDLOG_INFO, "DescribeLayerPlane: %d, %d", iPixelFormat, iLayerPlane);
-
-	return FALSE;
-}
-
-// ***********************************************************************
-
-int APIENTRY _GLD_WGL_EXPORT(DescribePixelFormat)(
-	HDC a,
-	int b,
-	UINT c,
-	LPPIXELFORMATDESCRIPTOR d)
-{
-	UINT nSize;
-
-	// Validate license
-	if (!dglValidate())
-		return 0;
-
-	if (d == NULL) // Calling app requires max number of PF's
-		return glb.nPixelFormatCount;
-
-	// The supplied buffer may be larger than the info that we
-	// will be copying.
-	if (c > sizeof(PIXELFORMATDESCRIPTOR))
-		nSize = sizeof(PIXELFORMATDESCRIPTOR);
-	else
-		nSize = c;
-
-    // Setup an empty PFD before doing validation check
-    memset(d, 0, nSize);
-    d->nSize = nSize;
-    d->nVersion = 1;
-
-	if (!IsValidPFD(b))
-		return 0; // Bail if PFD index is invalid
-
-	memcpy(d, &glb.lpPF[b-1].pfd, nSize);
-
-	return glb.nPixelFormatCount;
-}
-
-// ***********************************************************************
-
-HGLRC APIENTRY _GLD_WGL_EXPORT(GetCurrentContext)(void)
-{
-	// Validate license
-	if (!dglValidate())
-		return 0;
-
-	return dglGetCurrentContext();
-}
-
-// ***********************************************************************
-
-HDC APIENTRY _GLD_WGL_EXPORT(GetCurrentDC)(void)
-{
-	// Validate license
-	if (!dglValidate())
-		return 0;
-
-	return dglGetCurrentDC();
-}
-
-// ***********************************************************************
-
-PROC APIENTRY _GLD_WGL_EXPORT(GetDefaultProcAddress)(
-	LPCSTR a)
-{
-	// Validate license
-	if (!dglValidate())
-		return NULL;
-
-    UNSUPPORTED("DGL_GetDefaultProcAddress")
-    return NULL;
-}
-
-// ***********************************************************************
-
-int APIENTRY _GLD_WGL_EXPORT(GetLayerPaletteEntries)(
-	HDC a,
-	int b,
-	int c,
-	int d,
-	COLORREF *e)
-{
-	// Validate license
-	if (!dglValidate())
-		return 0;
-
-    UNSUPPORTED("DGL_GetLayerPaletteEntries")
-    return 0;
-}
-
-// ***********************************************************************
-
-int APIENTRY _GLD_WGL_EXPORT(GetPixelFormat)(
-	HDC a)
-{
-	// Validate license
-	if (!dglValidate())
-		return 0;
-
-	return dglGetPixelFormat();
-}
-
-// ***********************************************************************
-
-PROC APIENTRY _GLD_WGL_EXPORT(GetProcAddress)(
-	LPCSTR a)
-{
-	PROC dglGetProcAddressD3D(LPCSTR a);
-
-	// Validate license
-	if (!dglValidate())
-		return NULL;
-
-#ifdef _USE_GLD3_WGL
-	return _gldDriver.wglGetProcAddress(a);
-#else
-	return dglGetProcAddressD3D(a);
-#endif
-}
-
-// ***********************************************************************
-
-BOOL APIENTRY _GLD_WGL_EXPORT(MakeCurrent)(
-	HDC a,
-	HGLRC b)
-{
-	// Validate license
-	if (!dglValidate())
-		return FALSE;
-
-	return dglMakeCurrent(a, b);
-}
-
-// ***********************************************************************
-
-BOOL APIENTRY _GLD_WGL_EXPORT(RealizeLayerPalette)(
-	HDC a,
-	int b,
-	BOOL c)
-{
-	// Validate license
-	if (!dglValidate())
-		return FALSE;
-
-    UNSUPPORTED("DGL_RealizeLayerPalette")
-	return FALSE;
-}
-
-// ***********************************************************************
-
-int APIENTRY _GLD_WGL_EXPORT(SetLayerPaletteEntries)(
-	HDC a,
-	int b,
-	int c,
-	int d,
-	CONST COLORREF *e)
-{
-	// Validate license
-	if (!dglValidate())
-		return 0;
-
-    UNSUPPORTED("DGL_SetLayerPaletteEntries")
-	return 0;
-}
-
-// ***********************************************************************
-
-BOOL APIENTRY _GLD_WGL_EXPORT(SetPixelFormat)(
-	HDC a,
-	int b,
-	CONST PIXELFORMATDESCRIPTOR *c)
-{
-	// Validate license
-	if (!dglValidate())
-		return FALSE;
-
-	if (IsValidPFD(b)) {
-		ddlogPrintf(DDLOG_SYSTEM, "SetPixelFormat: PixelFormat %d has been set", b);
-		dglSetPixelFormat(b);
-		return TRUE;
-	} else {
-		ddlogPrintf(DDLOG_ERROR,
-					"SetPixelFormat: PixelFormat %d is invalid and cannot be set", b);
-		return FALSE;
-	}
-}
-
-// ***********************************************************************
-/*
- * Share lists between two gl_context structures.
- * This was added for WIN32 WGL function support, since wglShareLists()
- * must be called *after* wglCreateContext() with valid GLRCs. (DaveM)
- */
-//
-// Copied from GLD2.x. KeithH
-//
-static GLboolean _gldShareLists(
-	struct gl_context *ctx1,
-	struct gl_context *ctx2)
-{
-	/* Sanity check context pointers */
-	if (ctx1 == NULL || ctx2 == NULL)
-		return GL_FALSE;
-	/* Sanity check shared list pointers */
-	if (ctx1->Shared == NULL || ctx2->Shared == NULL)
-		return GL_FALSE;
-	/* Decrement reference count on sharee to release previous list */
-	ctx2->Shared->RefCount--;
-#if 0	/* 3DStudio exits on this memory release */
-	if (ctx2->Shared->RefCount == 0)
-		free_shared_state(ctx2, ctx2->Shared);
-#endif
-	/* Re-assign list from sharer to sharee and increment reference count */
-	ctx2->Shared = ctx1->Shared;
-	ctx1->Shared->RefCount++;
-	return GL_TRUE;
-}
-
-// ***********************************************************************
-
-BOOL APIENTRY _GLD_WGL_EXPORT(ShareLists)(
-	HGLRC a,
-	HGLRC b)
-{
-	DGL_ctx *dgl1, *dgl2;
-
-	// Validate license
-	if (!dglValidate())
-		return FALSE;
-
-	// Mesa supports shared lists, but you need to supply the shared
-	// GL context info when calling gl_create_context(). An auxiliary
-	// function gl_share_lists() has been added to update the shared
-	// list info after the GL contexts have been created. (DaveM)
-	dgl1 = dglGetContextAddress(a);
-	dgl2 = dglGetContextAddress(b);
-	if (dgl1->bAllocated && dgl2->bAllocated) {
-#ifdef _USE_GLD3_WGL
-		return _gldShareLists(dgl1->glCtx, dgl2->glCtx);
-#else
-		return (*mesaFuncs.gl_share_lists)(dgl1->glCtx, dgl2->glCtx);
-#endif
-	}
-	return FALSE;
-}
-
-// ***********************************************************************
-
-BOOL APIENTRY _GLD_WGL_EXPORT(SwapBuffers)(
-	HDC a)
-{
-	// Validate license
-	if (!dglValidate())
-		return FALSE;
-
-	return dglSwapBuffers(a);
-}
-
-// ***********************************************************************
-
-BOOL APIENTRY _GLD_WGL_EXPORT(SwapLayerBuffers)(
-	HDC a,
-	UINT b)
-{
-	// Validate license
-	if (!dglValidate())
-		return FALSE;
-
-	return dglSwapBuffers(a);
-}
-
-// ***********************************************************************
-
-// ***********************************************************************
-// Note: This ResizeBuffers() function may be called from
-// either MESA glViewport() or GLD wglMakeCurrent().
-
-BOOL dglWglResizeBuffers(
-	struct gl_context *ctx,
-	BOOL bDefaultDriver)
-{
-	DGL_ctx						*dgl = NULL;
-	RECT						rcScreenRect;
-	DWORD						dwWidth;
-	DWORD						dwHeight;
-	DDSURFACEDESC2				ddsd2;
-	DDSCAPS2					ddscaps2;
-	IDirectDrawClipper			*lpddClipper = NULL;
-	DWORD						dwFlags;
-	HRESULT						hResult;
-
-	DWORD						dwMemoryType;
-
-	int							i;
-	struct gl_texture_object	*tObj;
-	struct gl_texture_image		*image;
-
-	BOOL						bWasFullscreen;
-	BOOL						bSaveDesktop;
-	BOOL						bFullScrnWin = FALSE;
-	DDSURFACEDESC2 				ddsd2DisplayMode;
-
-	DDBLTFX						ddbltfx;
-	POINT						pt;
-	RECT						rcDst;
-#ifdef _USE_GLD3_WGL
-	GLD_displayMode				glddm;
-#endif
-
-#define DDLOG_CRITICAL_OR_WARN	(bDefaultDriver ? DDLOG_WARN : DDLOG_CRITICAL)
-
-	// Validate license
-	if (!dglValidate())
-		return FALSE;
-
-	// Sanity checks
-	if (ctx == NULL)
-		return FALSE;
-	dgl = ctx->DriverCtx;
-	if (dgl == NULL)
-		return FALSE;
-
-	// Get the window size and calculate its dimensions
-	if (dgl->hWnd == NULL) {
-		// Check for non-window DC = memory DC ?
-		if (GetClipBox(dgl->hDC, &rcScreenRect) == ERROR)
-			SetRect(&rcScreenRect, 0, 0, 0, 0);
-	}
-	else if (!GetClientRect(dgl->hWnd, &rcScreenRect))
-		SetRect(&rcScreenRect, 0, 0, 0, 0);
-	dwWidth = rcScreenRect.right - rcScreenRect.left;
-	dwHeight = rcScreenRect.bottom - rcScreenRect.top;
-    CopyRect(&dgl->rcScreenRect, &rcScreenRect);
-
-	// This will occur on Alt-Tab
-	if ((dwWidth == 0) && (dwHeight == 0)) {
-		//dgl->bCanRender = FALSE;
-		return TRUE; // No resize possible!
-	}
-
-	// Some apps zero only 1 dimension for non-visible window... (DaveM)
-	if ((dwWidth == 0) || (dwHeight == 0)) {
-		dwWidth = 8;
-		dwHeight = 8;
-	}
-
-	// Test to see if a resize is required.
-	// Note that the dimensions will be the same if a prior resize attempt failed.
-	if ((dwWidth == dgl->dwWidth) && (dwHeight == dgl->dwHeight) && bDefaultDriver) {
-		return TRUE; // No resize required
-	}
-
-	ddlogPrintf(DDLOG_SYSTEM, "dglResize: %dx%d", dwWidth, dwHeight);
-#ifndef _USE_GLD3_WGL
-	// Work out where we want our surfaces created
-	dwMemoryType = (bDefaultDriver) ? glb.dwMemoryType : DDSCAPS_SYSTEMMEMORY;
-#endif // _USE_GLD3_WGL
-
-	// Note previous fullscreen vs window display status
-	bWasFullscreen = dgl->bFullscreen;
-
-#ifdef _USE_GLD3_WGL
-	if (_gldDriver.GetDisplayMode(dgl, &glddm)) {
-		if ( (dwWidth == glddm.Width) &&
-				 (dwHeight == glddm.Height) ) {
-			bFullScrnWin = TRUE;
-		}
-		if (bFullScrnWin && glb.bPrimary && !glb.bFullscreenBlit && !glb.bDirectDrawPersistant) {
-			dgl->bFullscreen = TRUE;
-			ddlogMessage(DDLOG_INFO, "Fullscreen window after resize.\n");
-		}
-		else {
-			dgl->bFullscreen = FALSE;
-			ddlogMessage(DDLOG_INFO, "Non-Fullscreen window after resize.\n");
-		}
-		// Cache the display mode dimensions
-		dgl->dwModeWidth = glddm.Width;
-		dgl->dwModeHeight = glddm.Height;
-	}
-
-	// Clamp the effective window dimensions to primary surface.
-	// We need to do this for D3D viewport dimensions even if wide
-	// surfaces are supported. This also is a good idea for handling
-	// whacked-out window dimensions passed for non-drawable windows
-	// like Solid Edge. (DaveM)
-	if (dgl->dwWidth > glddm.Width)
-		dgl->dwWidth = glddm.Width;
-	if (dgl->dwHeight > glddm.Height)
-		dgl->dwHeight = glddm.Height;
-#else // _USE_GLD3_WGL
-	// Window resize may have changed to fullscreen
-	ZeroMemory(&ddsd2DisplayMode, sizeof(ddsd2DisplayMode));
-	ddsd2DisplayMode.dwSize = sizeof(ddsd2DisplayMode);
-	hResult = IDirectDraw4_GetDisplayMode(
-					dgl->lpDD4,
-					&ddsd2DisplayMode);
-	if (SUCCEEDED(hResult)) {
-		if ( (dwWidth == ddsd2DisplayMode.dwWidth) &&
-				 (dwHeight == ddsd2DisplayMode.dwHeight) ) {
-			bFullScrnWin = TRUE;
-		}
-		if (bFullScrnWin && glb.bPrimary && !glb.bFullscreenBlit && !glb.bDirectDrawPersistant) {
-			dgl->bFullscreen = TRUE;
-			ddlogMessage(DDLOG_INFO, "Fullscreen window after resize.\n");
-		}
-		else {
-			dgl->bFullscreen = FALSE;
-			ddlogMessage(DDLOG_INFO, "Non-Fullscreen window after resize.\n");
-		}
-		// Cache the display mode dimensions
-		dgl->dwModeWidth = ddsd2DisplayMode.dwWidth;
-		dgl->dwModeHeight = ddsd2DisplayMode.dwHeight;
-	}
-
-	// Clamp the effective window dimensions to primary surface.
-	// We need to do this for D3D viewport dimensions even if wide
-	// surfaces are supported. This also is a good idea for handling
-	// whacked-out window dimensions passed for non-drawable windows
-	// like Solid Edge. (DaveM)
-	if (dgl->dwWidth > ddsd2DisplayMode.dwWidth)
-		dgl->dwWidth = ddsd2DisplayMode.dwWidth;
-	if (dgl->dwHeight > ddsd2DisplayMode.dwHeight)
-		dgl->dwHeight = ddsd2DisplayMode.dwHeight;
-#endif // _USE_GLD3_WGL
-
-	// Note if fullscreen vs window display has changed?
-	bSaveDesktop = (!bWasFullscreen && !dgl->bFullscreen) ? TRUE : FALSE;
-	// Save the desktop primary surface from being destroyed
-	// whenever remaining in windowed mode, since the stereo mode
-	// switches are expensive...
-
-#ifndef _USE_GLD3_WGL
-	// Don't need to re-allocate persistant buffers. (DaveM)
-	// Though we should clear the back buffers to hide artifacts.
-	if (glb.bDirectDrawPersistant && glb.bPersistantBuffers) {
-		dgl->dwWidth = dwWidth;
-		dgl->dwHeight = dwHeight;
-		ZeroMemory(&ddbltfx, sizeof(ddbltfx));
-		ddbltfx.dwSize = sizeof(ddbltfx);
-		ddbltfx.dwFillColor = dgl->dwClearColorPF;
-		IDirectDrawSurface4_Blt(dgl->lpBack4, &rcScreenRect, NULL, NULL,
-			DDBLT_WAIT | DDBLT_COLORFILL, &ddbltfx);
-		return TRUE;
-	}
-
-	// Ensure all rendering is complete
-	if (ctx->Driver.Finish)
-		(*ctx->Driver.Finish)(ctx);
-	if (dgl->bSceneStarted == TRUE) {
-		IDirect3DDevice3_EndScene(dgl->lpDev3);
-		dgl->bSceneStarted = FALSE;
-	}
-#endif // _USE_GLD3_WGL
-	dgl->bCanRender = FALSE;
-
-#ifdef GLD_THREADS
-	// Serialize access to DirectDraw and DDS operations
-	if (glb.bMultiThreaded)
-		EnterCriticalSection(&CriticalSection);
-#endif
-
-#ifndef _USE_GLD3_WGL
-	// Release existing surfaces
-	RELEASE(dgl->lpDev3);
-	RELEASE(dgl->lpDepth4);
-	RELEASE(dgl->lpBack4);
-	if (glb.bDirectDrawPersistant && glb.bDirectDrawPrimary)
-        ;
-	else
-	RELEASE(dgl->lpFront4);
-#endif // _USE_GLD3_WGL
-	dgl->dwWidth = dwWidth;
-	dgl->dwHeight = dwHeight;
-
-	// Set defaults
-	dgl->dwModeWidth = dgl->dwWidth;
-	dgl->dwModeHeight = dgl->dwHeight;
-
-#ifdef _USE_GLD3_WGL
-	if (!_gldDriver.ResizeDrawable(dgl, bDefaultDriver, glb.bDirectDrawPersistant, glb.bPersistantBuffers))
-		goto cleanup_and_return_with_error;
-#else // _USE_GLD3_WGL
-
-	if (dgl->bFullscreen) {
-		//
-		// FULLSCREEN
-		//
-
-        // Disable warning popups when in fullscreen mode
-        ddlogWarnOption(FALSE);
-
-		// Have to release the persistant DirectDraw primary surface
-		// if switching to fullscreen mode. So if application wants
-		// persistant display in fullscreen mode, a fullscreen-size
-		// window should be used instead via fullscreen-blit option.
-		if (glb.bDirectDrawPersistant && glb.bDirectDrawPrimary) {
-			RELEASE(glb.lpPrimary4);
-			glb.bDirectDrawPrimary = FALSE;
-		}
-
-		dwFlags = DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_ALLOWREBOOT;
-		if (glb.bFastFPU)
-			dwFlags |= DDSCL_FPUSETUP;	// optional
-		hResult = IDirectDraw4_SetCooperativeLevel(dgl->lpDD4, dgl->hWnd, dwFlags);
-		if (FAILED(hResult)) {
-			ddlogError(DDLOG_CRITICAL_OR_WARN, "dglResize: Unable to set Exclusive Fullscreen mode", hResult);
-			goto cleanup_and_return_with_error;
-		}
-
-		hResult = IDirectDraw4_SetDisplayMode(dgl->lpDD4,
-											  dgl->dwModeWidth,
-											  dgl->dwModeHeight,
-											  dgl->dwBPP,
-											  0,
-											  0);
-		if (FAILED(hResult)) {
-			ddlogError(DDLOG_CRITICAL_OR_WARN, "dglResize: SetDisplayMode failed", hResult);
-			goto cleanup_and_return_with_error;
-		}
-
-		// ** The display mode has changed, so dont use MessageBox! **
-
-		ZeroMemory(&ddsd2, sizeof(ddsd2));
-		ddsd2.dwSize = sizeof(ddsd2);
-
-		if (dgl->bDoubleBuffer) {
-			// Double buffered
-			// Primary surface
-			ddsd2.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
-			ddsd2.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE |
-								   DDSCAPS_FLIP |
-								   DDSCAPS_COMPLEX |
-								   DDSCAPS_3DDEVICE |
-								   dwMemoryType;
-			ddsd2.dwBackBufferCount = 1;
-			hResult = IDirectDraw4_CreateSurface(dgl->lpDD4, &ddsd2, &dgl->lpFront4, NULL);
-			if (FAILED(hResult)) {
-				ddlogError(DDLOG_CRITICAL_OR_WARN, "dglResize: CreateSurface (primary) failed", hResult);
-				goto cleanup_and_return_with_error;
-			}
-			// Render target surface
-			ZeroMemory(&ddscaps2, sizeof(ddscaps2)); // Clear the entire struct.
-			ddscaps2.dwCaps = DDSCAPS_BACKBUFFER;
-			hResult = IDirectDrawSurface4_GetAttachedSurface(dgl->lpFront4, &ddscaps2, &dgl->lpBack4);
-			if (FAILED(hResult)) {
-				ddlogError(DDLOG_CRITICAL_OR_WARN, "dglResize: GetAttachedSurface failed", hResult);
-				goto cleanup_and_return_with_error;
-			}
-		} else {
-			// Single buffered
-			// Primary surface
-			ddsd2.dwFlags = DDSD_CAPS;
-			ddsd2.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE |
-								   //DDSCAPS_3DDEVICE |
-								   dwMemoryType;
-
-			hResult = IDirectDraw4_CreateSurface(dgl->lpDD4, &ddsd2, &dgl->lpFront4, NULL);
-			if (FAILED(hResult)) {
-				ddlogError(DDLOG_CRITICAL_OR_WARN, "dglResize: CreateSurface (primary) failed", hResult);
-				goto cleanup_and_return_with_error;
-			}
-
-			dgl->lpBack4 = NULL;
-		}
-	} else {
-		// WINDOWED
-
-        // OK to enable warning popups in windowed mode
-        ddlogWarnOption(glb.bMessageBoxWarnings);
-
-		// Ditto if persistant DirectDraw primary
-		if (glb.bDirectDrawPersistant && glb.bDirectDrawPrimary)
-			goto DoClipperOnly;
-
-		// WINDOWED
-		dwFlags = DDSCL_NORMAL;
-		if (glb.bMultiThreaded)
-			dwFlags |= DDSCL_MULTITHREADED;
-		if (glb.bFastFPU)
-			dwFlags |= DDSCL_FPUSETUP;	// optional
-		hResult = IDirectDraw4_SetCooperativeLevel(dgl->lpDD4,
-												  dgl->hWnd,
-												  dwFlags);
-		if (FAILED(hResult)) {
-			ddlogError(DDLOG_CRITICAL_OR_WARN, "dglResize: Unable to set Normal coop level", hResult);
-			goto cleanup_and_return_with_error;
-		}
-		// Primary surface
-		ZeroMemory(&ddsd2, sizeof(ddsd2));
-		ddsd2.dwSize = sizeof(ddsd2);
-		ddsd2.dwFlags = DDSD_CAPS;
-		ddsd2.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
-		hResult = IDirectDraw4_CreateSurface(dgl->lpDD4, &ddsd2, &dgl->lpFront4, NULL);
-		if (FAILED(hResult)) {
-			ddlogError(DDLOG_CRITICAL_OR_WARN, "dglResize: CreateSurface (primary) failed", hResult);
-			goto cleanup_and_return_with_error;
-		}
-
-		// Cache the primary surface for persistant DirectDraw state
-		if (glb.bDirectDrawPersistant && !glb.bDirectDrawPrimary) {
-			glb.lpPrimary4 = dgl->lpFront4;
-			IDirectDrawSurface4_AddRef(glb.lpPrimary4);
-			glb.bDirectDrawPrimary = TRUE;
-		}
-
-		// Clipper object
-		hResult = DirectDrawCreateClipper(0, &lpddClipper, NULL);
-		if (FAILED(hResult)) {
-			ddlogError(DDLOG_CRITICAL_OR_WARN, "dglResize: CreateClipper failed", hResult);
-			goto cleanup_and_return_with_error;
-		}
-		hResult = IDirectDrawClipper_SetHWnd(lpddClipper, 0, dgl->hWnd);
-		if (FAILED(hResult)) {
-			RELEASE(lpddClipper);
-			ddlogError(DDLOG_CRITICAL_OR_WARN, "dglResize: SetHWnd failed", hResult);
-			goto cleanup_and_return_with_error;
-		}
-		hResult = IDirectDrawSurface4_SetClipper(dgl->lpFront4, lpddClipper);
-		RELEASE(lpddClipper); // We have finished with it.
-		if (FAILED(hResult)) {
-			ddlogError(DDLOG_CRITICAL_OR_WARN, "dglResize: SetClipper failed", hResult);
-			goto cleanup_and_return_with_error;
-		}
-DoClipperOnly:
-		// Update the window for the original clipper
-		if ((glb.bDirectDrawPersistant && glb.bDirectDrawPrimary) || bSaveDesktop) {
-			IDirectDrawSurface4_GetClipper(dgl->lpFront4, &lpddClipper);
-			IDirectDrawClipper_SetHWnd(lpddClipper, 0, dgl->hWnd);
-			RELEASE(lpddClipper);
-		}
-
-		if (dgl->bDoubleBuffer) {
-			// Render target surface
-			ZeroMemory(&ddsd2, sizeof(ddsd2));
-			ddsd2.dwSize = sizeof(ddsd2);
-			ddsd2.dwFlags        = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
-			ddsd2.dwWidth        = dgl->dwWidth;
-			ddsd2.dwHeight       = dgl->dwHeight;
-			ddsd2.ddsCaps.dwCaps = DDSCAPS_3DDEVICE |
-								   DDSCAPS_OFFSCREENPLAIN |
-								   dwMemoryType;
-			hResult = IDirectDraw4_CreateSurface(dgl->lpDD4, &ddsd2, &dgl->lpBack4, NULL);
-			if (FAILED(hResult)) {
-				ddlogError(DDLOG_CRITICAL_OR_WARN, "dglResize: Create Backbuffer failed", hResult);
-				goto cleanup_and_return_with_error;
-			}
-
-		} else {
-			dgl->lpBack4 = NULL;
-		}
-	}
-
-	//
-	// Now create the Zbuffer
-	//
-	if (dgl->bDepthBuffer) {
-		// Get z-buffer dimensions from the render target
-		// Setup the surface desc for the z-buffer.
-		ZeroMemory(&ddsd2, sizeof(ddsd2));
-		ddsd2.dwSize = sizeof(ddsd2);
-		ddsd2.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT;
-		ddsd2.ddsCaps.dwCaps = DDSCAPS_ZBUFFER | dwMemoryType;
-		ddsd2.dwWidth = dgl->dwWidth;
-		ddsd2.dwHeight = dgl->dwHeight;
-		memcpy(&ddsd2.ddpfPixelFormat,
-			   &glb.lpZBufferPF[dgl->iZBufferPF],
-			   sizeof(DDPIXELFORMAT) );
-
-		// Create a z-buffer
-		hResult = IDirectDraw4_CreateSurface(dgl->lpDD4, &ddsd2, &dgl->lpDepth4, NULL);
-		if (FAILED(hResult)) {
-			ddlogError(DDLOG_CRITICAL_OR_WARN, "dglResize: CreateSurface (ZBuffer) failed", hResult);
-			goto cleanup_and_return_with_error;
-		}
-
-		// Attach Zbuffer to render target
-		TRY(IDirectDrawSurface4_AddAttachedSurface(
-			dgl->bDoubleBuffer ? dgl->lpBack4 : dgl->lpFront4,
-			dgl->lpDepth4),
-			"dglResize: Attach Zbuffer");
-
-	}
-
-	// Clear the newly resized back buffers for the window client area.
-	ZeroMemory(&ddbltfx, sizeof(ddbltfx));
-	ddbltfx.dwSize = sizeof(ddbltfx);
-	ddbltfx.dwFillColor = dgl->dwClearColorPF;
-	IDirectDrawSurface4_Blt(dgl->lpBack4, &rcScreenRect, NULL, NULL,
-		DDBLT_WAIT | DDBLT_COLORFILL, &ddbltfx);
-
-	//
-	// Now that we have a zbuffer we can create the 3D device
-	//
-	hResult = IDirect3D3_CreateDevice(dgl->lpD3D3,
-									  bDefaultDriver ? &glb.d3dGuid : &IID_IDirect3DRGBDevice,
-									  dgl->bDoubleBuffer ? dgl->lpBack4 : dgl->lpFront4,
-									  &dgl->lpDev3,
-									  NULL);
-	if (FAILED(hResult)) {
-		ddlogError(DDLOG_CRITICAL_OR_WARN, "dglResize: Could not create Direct3D device", hResult);
-		goto cleanup_and_return_with_error;
-	}
-
-	// We must do this as soon as the device is created
-	dglInitStateCaches(dgl);
-
-	//
-	// Viewport
-	//
-	hResult = IDirect3DDevice3_AddViewport(dgl->lpDev3, dgl->lpViewport3);
-	if (FAILED(hResult)) {
-		ddlogError(DDLOG_CRITICAL_OR_WARN, "dglResize: AddViewport failed", hResult);
-		goto cleanup_and_return_with_error;
-	}
-
-	// Initialise the viewport
-	dgl->d3dViewport.dwSize = sizeof(dgl->d3dViewport);
-	dgl->d3dViewport.dwX = 0;
-	dgl->d3dViewport.dwY = 0;
-	dgl->d3dViewport.dwWidth = dgl->dwWidth;
-	dgl->d3dViewport.dwHeight = dgl->dwHeight;
-	dgl->d3dViewport.dvClipX = 0;
-	dgl->d3dViewport.dvClipY = 0;
-	dgl->d3dViewport.dvClipWidth = dgl->dwWidth;
-	dgl->d3dViewport.dvClipHeight = dgl->dwHeight;
-//	dgl->d3dViewport.dvMinZ = 0.0f;
-//	dgl->d3dViewport.dvMaxZ = 1.0f;
-	TRY(IDirect3DViewport3_SetViewport2(dgl->lpViewport3, &dgl->d3dViewport),
-		"dglResize: SetViewport2");
-
-	hResult = IDirect3DDevice3_SetCurrentViewport(dgl->lpDev3, dgl->lpViewport3);
-	if (FAILED(hResult)) {
-		ddlogError(DDLOG_CRITICAL_OR_WARN, "dglResize: SetCurrentViewport failed", hResult);
-		goto cleanup_and_return_with_error;
-	}
-
-	// (Re)Initialise all the Direct3D renderstates
-	dglInitStateD3D(ctx);
-
-	// Now we have to recreate all of our textures (+ mipmaps).
-	// Walk over all textures in hash table
-	// XXX what about the default texture objects (id=0)?
-	{
-		struct _mesa_HashTable *textures = ctx->Shared->TexObjects;
-		GLuint id;
-		for (id = _mesa_HashFirstEntry(textures);
-				 id;
-				 id = _mesa_HashNextEntry(textures, id)) {
-			tObj = (struct gl_texture_object *) _mesa_HashLookup(textures, id);
-			if (tObj->DriverData) {
-				// We could call our TexImage function directly, but it's
-				// safer to use the driver pointer.
-				for (i=0; i<MAX_TEXTURE_LEVELS; i++) {
-					image = tObj->Image[i];
-					if (image) {
-						switch (tObj->Dimensions){
-						case 1:
-							if (ctx->Driver.TexImage)
-								(*ctx->Driver.TexImage)(ctx, GL_TEXTURE_1D, tObj, i, image->Format, image);
-							break;
-						case 2:
-							if (ctx->Driver.TexImage)
-								(*ctx->Driver.TexImage)(ctx, GL_TEXTURE_2D, tObj, i, image->Format, image);
-							break;
-						default:
-							break;
-						}
-					}
-				}
-			}
-		}
-	}
-
-	// Re-Bind each texture Unit
-	for (i=0; i<glb.wMaxSimultaneousTextures; i++) {
-		tObj = ctx->Texture.Unit[i].Current;
-		if (tObj) {
-			DGL_texture *lpTex = (DGL_texture *)tObj->DriverData;
-			hResult = dglSetTexture(dgl, i, lpTex ? lpTex->lpTexture : NULL);
-			if (FAILED(hResult)) {
-				ddlogError(DDLOG_ERROR, "dglResize: SetTexture failed", hResult);
-			}
-		}
-	}
-#endif // _USE_GLD3_WGL
-
-	dgl->bCanRender = TRUE;
-
-#ifdef GLD_THREADS
-	// Release serialized access
-	if (glb.bMultiThreaded)
-		LeaveCriticalSection(&CriticalSection);
-#endif
-
-	// SUCCESS.
-	return TRUE;
-
-cleanup_and_return_with_error:
-	// Relase all interfaces before returning.
-#ifdef _USE_GLD3_WGL
-	_gldDriver.DestroyDrawable(dgl);
-#else // _USE_GLD3_WGL
-	RELEASE(dgl->lpDev3);
-	RELEASE(dgl->lpDepth4);
-	RELEASE(dgl->lpBack4);
-	if (glb.bDirectDrawPersistant && glb.bDirectDrawPrimary)
-		;
-	else
-	RELEASE(dgl->lpFront4);
-
-#undef DDLOG_CRITICAL_OR_WARN
-#endif // _USE_GLD3_WGL
-
-	// Mark context as not being able to render
-	dgl->bCanRender = FALSE;
-
-#ifdef GLD_THREADS
-	// Release serialized access
-	if (glb.bMultiThreaded)
-		LeaveCriticalSection(&CriticalSection);
-#endif
-
-	return FALSE;
-}
-
-// ***********************************************************************
-// ***********************************************************************
-// Support for bitmap fonts.
-// ***********************************************************************
-// ***********************************************************************
-
-/*****************************************************************************
-**
-** InvertGlyphBitmap.
-**
-** Invert the bitmap so that it suits OpenGL's representation.
-** Each row starts on a double word boundary.
-**
-*****************************************************************************/
-
-static void InvertGlyphBitmap(
-	int w,
-	int h,
-	DWORD *fptr,
-	DWORD *tptr)
-{
-	int dWordsInRow = (w+31)/32;
-	int i, j;
-	DWORD *tmp = tptr;
-
-	if (w <= 0 || h <= 0) {
-	return;
-	}
-
-	tptr += ((h-1)*dWordsInRow);
-	for (i = 0; i < h; i++) {
-	for (j = 0; j < dWordsInRow; j++) {
-		*(tptr + j) = *(fptr + j);
-	}
-	tptr -= dWordsInRow;
-	fptr += dWordsInRow;
-	}
-}
-
-// ***********************************************************************
-
-/*****************************************************************************
- * wglUseFontBitmaps
- *
- * Converts a subrange of the glyphs in a GDI font to OpenGL display
- * lists.
- *
- * Extended to support any GDI font, not just TrueType fonts. (DaveM)
- *
- *****************************************************************************/
-
-BOOL APIENTRY _GLD_WGL_EXPORT(UseFontBitmapsA)(
-	HDC hDC,
-	DWORD first,
-	DWORD count,
-	DWORD listBase)
-{
-	int					i, ox, oy, ix, iy;
-	int					w, h;
-	int					iBufSize, iCurBufSize = 0;
-	DWORD				*bitmapBuffer = NULL;
-	DWORD				*invertedBitmapBuffer = NULL;
-	BOOL				bSuccessOrFail = TRUE;
-	BOOL				bTrueType = FALSE;
-	TEXTMETRIC			tm;
-	GLYPHMETRICS		gm;
-	RASTERIZER_STATUS	rs;
-	MAT2				mat;
-	SIZE				size;
-	RECT				rect;
-	HDC					hDCMem;
-	HBITMAP				hBitmap;
-	BITMAPINFO			bmi;
-	HFONT				hFont;
-
-	// Validate SciTech DirectGL license
-	if (!dglValidate())
-		return FALSE;
-
-	// Set up a unity matrix.
-	ZeroMemory(&mat, sizeof(mat));
-	mat.eM11.value = 1;
-	mat.eM22.value = 1;
-
-	// Test to see if selected font is TrueType or not
-	ZeroMemory(&tm, sizeof(tm));
-	if (!GetTextMetrics(hDC, &tm)) {
-		ddlogMessage(DDLOG_ERROR, "DGL_UseFontBitmaps: Font metrics error\n");
-		return (FALSE);
-	}
-	bTrueType = (tm.tmPitchAndFamily & TMPF_TRUETYPE) ? TRUE : FALSE;
-
-	// Test to see if TRUE-TYPE capabilities are installed
-	// (only necessary if TrueType font selected)
-	ZeroMemory(&rs, sizeof(rs));
-	if (bTrueType) {
-		if (!GetRasterizerCaps (&rs, sizeof (RASTERIZER_STATUS))) {
-			ddlogMessage(DDLOG_ERROR, "DGL_UseFontBitmaps: Raster caps error\n");
-			return (FALSE);
-		}
-		if (!(rs.wFlags & TT_ENABLED)) {
-			ddlogMessage(DDLOG_ERROR, "DGL_UseFontBitmaps: No TrueType caps\n");
-			return (FALSE);
-		}
-	}
-
-	// Trick to get the current font handle
-	hFont = SelectObject(hDC, GetStockObject(SYSTEM_FONT));
-	SelectObject(hDC, hFont);
-
-	// Have memory device context available for holding bitmaps of font glyphs
-	hDCMem = CreateCompatibleDC(hDC);
-	SelectObject(hDCMem, hFont);
-	SetTextColor(hDCMem, RGB(0xFF, 0xFF, 0xFF));
-	SetBkColor(hDCMem, 0);
-
-	for (i = first; (DWORD) i < (first + count); i++) {
-		// Find out how much space is needed for the bitmap so we can
-		// Set the buffer size correctly.
-		if (bTrueType) {
-			// Use TrueType support to get bitmap size of glyph
-			iBufSize = GetGlyphOutline(hDC, i, GGO_BITMAP, &gm,
-				0, NULL, &mat);
-			if (iBufSize == GDI_ERROR) {
-				bSuccessOrFail = FALSE;
-				break;
-			}
-		}
-		else {
-			// Use generic GDI support to compute bitmap size of glyph
-			w = tm.tmMaxCharWidth;
-			h = tm.tmHeight;
-			if (GetTextExtentPoint32(hDC, (LPCTSTR)&i, 1, &size)) {
-				w = size.cx;
-				h = size.cy;
-			}
-			iBufSize = w * h;
-			// Use DWORD multiple for compatibility
-			iBufSize += 3;
-			iBufSize /= 4;
-			iBufSize *= 4;
-		}
-
-		// If we need to allocate Larger Buffers, then do so - but allocate
-		// An extra 50 % so that we don't do too many mallocs !
-		if (iBufSize > iCurBufSize) {
-			if (bitmapBuffer) {
-				__wglFree(bitmapBuffer);
-			}
-			if (invertedBitmapBuffer) {
-				__wglFree(invertedBitmapBuffer);
-			}
-
-			iCurBufSize = iBufSize * 2;
-			bitmapBuffer = (DWORD *) __wglMalloc(iCurBufSize);
-			invertedBitmapBuffer = (DWORD *) __wglMalloc(iCurBufSize);
-
-			if (bitmapBuffer == NULL || invertedBitmapBuffer == NULL) {
-				bSuccessOrFail = FALSE;
-				break;
-			}
-		}
-
-		// If we fail to get the Glyph data, delete the display lists
-		// Created so far and return FALSE.
-		if (bTrueType) {
-			// Use TrueType support to get bitmap of glyph
-			if (GetGlyphOutline(hDC, i, GGO_BITMAP, &gm,
-					iBufSize, bitmapBuffer, &mat) == GDI_ERROR) {
-				bSuccessOrFail = FALSE;
-				break;
-			}
-
-			// Setup glBitmap parameters for current font glyph
-			w  = gm.gmBlackBoxX;
-			h  = gm.gmBlackBoxY;
-			ox = gm.gmptGlyphOrigin.x;
-			oy = gm.gmptGlyphOrigin.y;
-			ix = gm.gmCellIncX;
-			iy = gm.gmCellIncY;
-		}
-		else {
-			// Use generic GDI support to create bitmap of glyph
-			ZeroMemory(bitmapBuffer, iBufSize);
-
-			if (i >= tm.tmFirstChar && i <= tm.tmLastChar) {
-				// Only create bitmaps for actual font glyphs
-				hBitmap = CreateBitmap(w, h, 1, 1, NULL);
-				SelectObject(hDCMem, hBitmap);
-				// Make bitmap of current font glyph
-				SetRect(&rect, 0, 0, w, h);
-				DrawText(hDCMem, (LPCTSTR)&i, 1, &rect,
-					DT_LEFT | DT_BOTTOM | DT_SINGLELINE | DT_NOCLIP);
-				// Make copy of bitmap in our local buffer
-				ZeroMemory(&bmi, sizeof(bmi));
-				bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
-				bmi.bmiHeader.biWidth = w;
-				bmi.bmiHeader.biHeight = -h;
-				bmi.bmiHeader.biPlanes = 1;
-				bmi.bmiHeader.biBitCount = 1;
-				bmi.bmiHeader.biCompression = BI_RGB;
-				GetDIBits(hDCMem, hBitmap, 0, h, bitmapBuffer, &bmi, 0);
-				DeleteObject(hBitmap);
-			}
-			else {
-				// Otherwise use empty display list for non-existing glyph
-				iBufSize = 0;
-			}
-
-			// Setup glBitmap parameters for current font glyph
-			ox = 0;
-			oy = tm.tmDescent;
-			ix = w;
-			iy = 0;
-		}
-
-		// Create an OpenGL display list.
-		_GLD_glNewList((listBase + i), GL_COMPILE);
-
-		// Some fonts have no data for the space character, yet advertise
-		// a non-zero size.
-		if (0 == iBufSize) {
-			_GLD_glBitmap(0, 0, 0.0f, 0.0f, (GLfloat) ix, (GLfloat) iy, NULL);
-		} else {
-			// Invert the Glyph data.
-			InvertGlyphBitmap(w, h, bitmapBuffer, invertedBitmapBuffer);
-
-			// Render an OpenGL bitmap and invert the origin.
-			_GLD_glBitmap(w, h,
-				(GLfloat) ox, (GLfloat) (h-oy),
-				(GLfloat) ix, (GLfloat) iy,
-				(GLubyte *) invertedBitmapBuffer);
-		}
-
-		// Close this display list.
-		_GLD_glEndList();
-	}
-
-	if (bSuccessOrFail == FALSE) {
-		ddlogMessage(DDLOG_ERROR, "DGL_UseFontBitmaps: Get glyph failed\n");
-		_GLD_glDeleteLists((i+listBase), (i-first));
-	}
-
-	// Release resources used
-	DeleteObject(hFont);
-	DeleteDC(hDCMem);
-
-	if (bitmapBuffer)
-		__wglFree(bitmapBuffer);
-	if (invertedBitmapBuffer)
-		__wglFree(invertedBitmapBuffer);
-
-	return(bSuccessOrFail);
-}
-
-// ***********************************************************************
-
-BOOL APIENTRY _GLD_WGL_EXPORT(UseFontBitmapsW)(
-	HDC a,
-	DWORD b,
-	DWORD c,
-	DWORD d)
-{
-	// Validate license
-	if (!dglValidate())
-		return FALSE;
-
-	return _GLD_WGL_EXPORT(UseFontBitmapsA)(a, b, c, d);
-}
-
-// ***********************************************************************
-// ***********************************************************************
-// Support for outline TrueType fonts.
-// ***********************************************************************
-// ***********************************************************************
-
-void * __wglRealloc(
-	void *oldPtr,
-	size_t newSize)
-{
-    void *newPtr = NULL;
-	
-    if (newSize != 0) {
-		newPtr = (void *) GlobalAlloc(GPTR, newSize);
-		if (oldPtr && newPtr) {
-			DWORD oldSize = GlobalSize(oldPtr);
-			
-			memcpy(newPtr, oldPtr, (oldSize <= newSize ? oldSize : newSize));
-			GlobalFree(oldPtr);
-		}
-    } else if (oldPtr) {
-		GlobalFree(oldPtr);
-    }
-    if (newPtr == NULL) {
-		return NULL;	/* XXX out of memory error */
-    }
-    return newPtr;
-}
-
-// ***********************************************************************
-
-
-/*****************************************************************************
- * wglUseFontOutlinesW
- *
- * Converts a subrange of the glyphs in a TrueType font to OpenGL display
- * lists.
- *****************************************************************************/
-
-BOOL APIENTRY _GLD_WGL_EXPORT(UseFontOutlinesW)(
-	IN	HDC			hDC,
-	IN	DWORD			first,
-	IN	DWORD			count,
-	IN	DWORD			listBase,
-	IN	FLOAT			chordalDeviation,
-	IN	FLOAT			extrusion,
-	IN	INT			format,
-	OUT	LPGLYPHMETRICSFLOAT	lpgmf)
-{
-	return _GLD_WGL_EXPORT(UseFontOutlinesA)(hDC, first, count, listBase,
-		chordalDeviation, extrusion, format, lpgmf);
-}
-
-/*****************************************************************************
- * wglUseFontOutlinesA
- *
- * Converts a subrange of the glyphs in a TrueType font to OpenGL display
- * lists.
- *****************************************************************************/
-
-BOOL APIENTRY _GLD_WGL_EXPORT(UseFontOutlinesA)(
-	IN	HDC			hDC,
-			IN	DWORD			first,
-			IN	DWORD			count,
-			IN	DWORD			listBase,
-			IN	FLOAT			chordalDeviation,
-			IN	FLOAT			extrusion,
-			IN	INT			format,
-			OUT	LPGLYPHMETRICSFLOAT	glyphMetricsFloatArray)
-	{
-	DWORD	glyphIndex;
-	UCHAR*	glyphBuf;
-	DWORD	glyphBufSize;
-
-
-	/*
-	 * Flush any previous OpenGL errors.  This allows us to check for
-	 * new errors so they can be reported via the function return value.
-	 */
-	while (_GLD_glGetError() != GL_NO_ERROR)
-		;
-
-	/*
-	 * Make sure that the current font can be sampled accurately.
-	 */
-	hNewFont = CreateHighResolutionFont(hDC);
-	if (!hNewFont)
-		return FALSE;
-
-	hOldFont = SelectObject(hDC, hNewFont);
-	if (!hOldFont)
-		return FALSE;
-
-	/*
-	 * Preallocate a buffer for the outline data, and track its size:
-	 */
-	glyphBuf = (UCHAR*) __wglMalloc(glyphBufSize = 10240);
-	if (!glyphBuf)
-		return FALSE; /*WGL_STATUS_NOT_ENOUGH_MEMORY*/
-
-	/*
-	 * Process each glyph in the given range:
-	 */
-	for (glyphIndex = first; glyphIndex - first < count; ++glyphIndex)
-		{
-		GLYPHMETRICS	glyphMetrics;
-		DWORD		glyphSize;
-		static MAT2	matrix =
-			{
-			{0, 1},		{0, 0},
-			{0, 0},		{0, 1}
-			};
-		LPGLYPHMETRICSFLOAT glyphMetricsFloat =
-			&glyphMetricsFloatArray[glyphIndex - first];
-
-
-		/*
-		 * Determine how much space is needed to store the glyph's
-		 * outlines.  If our glyph buffer isn't large enough,
-		 * resize it.
-		 */
-		glyphSize = GetGlyphOutline(	hDC,
-						glyphIndex,
-						GGO_NATIVE,
-						&glyphMetrics,
-						0,
-						NULL,
-						&matrix
-						);
-		if (glyphSize < 0)
-			return FALSE; /*WGL_STATUS_FAILURE*/
-		if (glyphSize > glyphBufSize)
-			{
-			__wglFree(glyphBuf);
-			glyphBuf = (UCHAR*) __wglMalloc(glyphBufSize = glyphSize);
-			if (!glyphBuf)
-				return FALSE; /*WGL_STATUS_NOT_ENOUGH_MEMORY*/
-			}
-
-
-		/*
-		 * Get the glyph's outlines.
-		 */
-		if (GetGlyphOutline(	hDC,
-					glyphIndex,
-					GGO_NATIVE,
-					&glyphMetrics,
-					glyphBufSize,
-					glyphBuf,
-					&matrix
-					) < 0)
-			{
-			__wglFree(glyphBuf);
-			return FALSE; /*WGL_STATUS_FAILURE*/
-			}
-		
-		glyphMetricsFloat->gmfBlackBoxX =
-			(FLOAT) glyphMetrics.gmBlackBoxX * ScaleFactor;
-		glyphMetricsFloat->gmfBlackBoxY =
-			(FLOAT) glyphMetrics.gmBlackBoxY * ScaleFactor;
-		glyphMetricsFloat->gmfptGlyphOrigin.x =
-			(FLOAT) glyphMetrics.gmptGlyphOrigin.x * ScaleFactor;
-		glyphMetricsFloat->gmfptGlyphOrigin.y =
-			(FLOAT) glyphMetrics.gmptGlyphOrigin.y * ScaleFactor;
-		glyphMetricsFloat->gmfCellIncX =
-			(FLOAT) glyphMetrics.gmCellIncX * ScaleFactor;
-		glyphMetricsFloat->gmfCellIncY =
-			(FLOAT) glyphMetrics.gmCellIncY * ScaleFactor;
-		
-		/*
-		 * Turn the glyph into a display list:
-		 */
-		if (!MakeDisplayListFromGlyph(	(glyphIndex - first) + listBase,
-						glyphBuf,
-						glyphSize,
-						glyphMetricsFloat,
-						chordalDeviation + ScaleFactor,
-						extrusion,
-						format))
-			{
-			__wglFree(glyphBuf);
-			return FALSE; /*WGL_STATUS_FAILURE*/
-			}
-		}
-
-
-	/*
-	 * Clean up temporary storage and return.  If an error occurred,
-	 * clear all OpenGL error flags and return FAILURE status;
-	 * otherwise just return SUCCESS.
-	 */
-	__wglFree(glyphBuf);
-
-	SelectObject(hDC, hOldFont);
-
-	if (_GLD_glGetError() == GL_NO_ERROR)
-		return TRUE; /*WGL_STATUS_SUCCESS*/
-	else
-		{
-		while (_GLD_glGetError() != GL_NO_ERROR)
-			;
-		return FALSE; /*WGL_STATUS_FAILURE*/
-		}
-	}
-
-
-
-/*****************************************************************************
- * CreateHighResolutionFont
- *
- * Gets metrics for the current font and creates an equivalent font
- * scaled to the design units of the font.
- * 
- *****************************************************************************/
-
-static HFONT
-CreateHighResolutionFont(HDC hDC)
-	{
-	UINT otmSize;
-	OUTLINETEXTMETRIC *otm;
-	LONG fontHeight, fontWidth, fontUnits;
-	LOGFONT logFont;
-
-	otmSize = GetOutlineTextMetrics(hDC, 0, NULL);
-	if (otmSize == 0) 
-		return NULL;
-
-	otm = (OUTLINETEXTMETRIC *) __wglMalloc(otmSize);
-	if (otm == NULL)
-		return NULL;
-
-	otm->otmSize = otmSize;
-	if (GetOutlineTextMetrics(hDC, otmSize, otm) == 0) 
-		return NULL;
-	
-	fontHeight = otm->otmTextMetrics.tmHeight -
-			otm->otmTextMetrics.tmInternalLeading;
-	fontWidth = otm->otmTextMetrics.tmAveCharWidth;
-	fontUnits = (LONG) otm->otmEMSquare;
-	
-	ScaleFactor = 1.0F / (FLOAT) fontUnits;
-
-	logFont.lfHeight = - ((LONG) fontUnits);
-	logFont.lfWidth = (LONG)
-		((FLOAT) (fontWidth * fontUnits) / (FLOAT) fontHeight);
-	logFont.lfEscapement = 0;
-	logFont.lfOrientation = 0;
-	logFont.lfWeight = otm->otmTextMetrics.tmWeight;
-	logFont.lfItalic = otm->otmTextMetrics.tmItalic;
-	logFont.lfUnderline = otm->otmTextMetrics.tmUnderlined;
-	logFont.lfStrikeOut = otm->otmTextMetrics.tmStruckOut;
-	logFont.lfCharSet = otm->otmTextMetrics.tmCharSet;
-	logFont.lfOutPrecision = OUT_OUTLINE_PRECIS;
-	logFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
-	logFont.lfQuality = DEFAULT_QUALITY;
-	logFont.lfPitchAndFamily =
-		otm->otmTextMetrics.tmPitchAndFamily & 0xf0;
-	strcpy(logFont.lfFaceName,
-	       (char *)otm + (int)otm->otmpFaceName);
-
-	hNewFont = CreateFontIndirect(&logFont);
-	if (hNewFont == NULL)
-		return NULL;
-
-	__wglFree(otm);
-
-	return hNewFont;
-	}
-
-
-
-/*****************************************************************************
- * MakeDisplayListFromGlyph
- * 
- * Converts the outline of a glyph to an OpenGL display list.
- *
- * Return value is nonzero for success, zero for failure.
- *
- * Does not check for OpenGL errors, so if the caller needs to know about them,
- * it should call glGetError().
- *****************************************************************************/
-
-static int
-MakeDisplayListFromGlyph(	IN  DWORD		listName,
-				IN  UCHAR*		glyphBuf,
-				IN  DWORD		glyphSize,
-				IN  LPGLYPHMETRICSFLOAT	glyphMetricsFloat,
-				IN  FLOAT		chordalDeviation,
-				IN  FLOAT		extrusion,
-				IN  INT			format)
-	{
-	int status;
-
-	_GLD_glNewList(listName, GL_COMPILE);
-		status = DrawGlyph(	glyphBuf,
-					glyphSize,
-					chordalDeviation,
-					extrusion,
-					format);
-		
-	_GLD_glTranslatef(glyphMetricsFloat->gmfCellIncX,
-		     glyphMetricsFloat->gmfCellIncY,
-		     0.0F);
-	_GLD_glEndList();
-
-	return status;
-	}
-
-
-
-/*****************************************************************************
- * DrawGlyph
- * 
- * Converts the outline of a glyph to OpenGL drawing primitives, tessellating
- * as needed, and then draws the glyph.  Tessellation of the quadratic splines
- * in the outline is controlled by "chordalDeviation", and the drawing
- * primitives (lines or polygons) are selected by "format".
- *
- * Return value is nonzero for success, zero for failure.
- *
- * Does not check for OpenGL errors, so if the caller needs to know about them,
- * it should call glGetError().
- *****************************************************************************/
-
-static int
-DrawGlyph(	IN  UCHAR*	glyphBuf,
-		IN  DWORD	glyphSize,
-		IN  FLOAT	chordalDeviation,
-		IN  FLOAT	extrusion,
-		IN  INT		format)
-	{
-	INT			status = 0;
-	FLOAT*			p;
-	DWORD			loop;
-	DWORD			point;
-	GLUtesselator*		tess = NULL;
-
-
-	/*
-	 * Initialize the global buffer into which we place the outlines:
-	 */
-	if (!InitLineBuf())
-		goto exit;
-
-
-	/*
-	 * Convert the glyph outlines to a set of polyline loops.
-	 * (See MakeLinesFromGlyph() for the format of the loop data
-	 * structure.)
-	 */
-	if (!MakeLinesFromGlyph(glyphBuf, glyphSize, chordalDeviation))
-		goto exit;
-	p = LineBuf;
-
-
-	/*
-	 * Now draw the loops in the appropriate format:
-	 */
-	if (format == WGL_FONT_LINES)
-		{
-		/*
-		 * This is the easy case.  Just draw the outlines.
-		 */
-		for (loop = (DWORD) *p++; loop; --loop)
-			{
-			_GLD_glBegin(GL_LINE_LOOP);
-				for (point = (DWORD) *p++; point; --point)
-					{
-					_GLD_glVertex2fv(p);
-					p += 2;
-					}
-			_GLD_glEnd();
-			}
-		status = 1;
-		}
-
-	else if (format == WGL_FONT_POLYGONS)
-		{
-		double v[3];
-		FLOAT *save_p = p;
-		GLfloat z_value;
-		
-		/*
-		 * This is the hard case.  We have to set up a tessellator
-		 * to convert the outlines into a set of polygonal
-		 * primitives, which the tessellator passes to some
-		 * auxiliary routines for drawing.
-		 */
-		if (!LoadGLUTesselator())
-			goto exit;
-		if (!InitVertBuf())
-			goto exit;
-		if (!(tess = gluNewTessProc()))
-			goto exit;
-		gluTessCallbackProc(tess,	GLU_BEGIN,	(void(CALLBACK *)()) _GLD_glBegin);
-		gluTessCallbackProc(tess,	GLU_TESS_VERTEX_DATA,
-				    (void(CALLBACK *)()) TessVertexOutData);
-		gluTessCallbackProc(tess,	GLU_END,	(void(CALLBACK *)()) _GLD_glEnd);
-		gluTessCallbackProc(tess,	GLU_ERROR,	(void(CALLBACK *)()) TessError);
-		gluTessCallbackProc(tess,	GLU_TESS_COMBINE, (void(CALLBACK *)()) TessCombine);
-		gluTessNormalProc(tess,	0.0F, 0.0F, 1.0F);
-
-		TessErrorOccurred = 0;
-		_GLD_glNormal3f(0.0f, 0.0f, 1.0f);
-		v[2] = 0.0;
-		z_value = 0.0f;
-
-		gluTessBeginPolygonProc(tess, (void *)*(int *)&z_value);
-			for (loop = (DWORD) *p++; loop; --loop)
-				{
-				gluTessBeginContourProc(tess);
-				
-				for (point = (DWORD) *p++; point; --point)
-					{
-					v[0] = p[0];
-					v[1] = p[1];
-					gluTessVertexProc(tess, v, p);
-					p += 2;
-					}
-
-				gluTessEndContourProc(tess);
-				}
-		gluTessEndPolygonProc(tess);
-
-		status = !TessErrorOccurred;
-
-		/* Extrusion code */
-		if (extrusion) {
-			DWORD loops;
-			GLfloat thickness = (GLfloat) -extrusion;
-			FLOAT *vert, *vert2;
-			DWORD count;
-
-			p = save_p;
-			loops = (DWORD) *p++;
-
-			for (loop = 0; loop < loops; loop++) {
-				GLfloat dx, dy, len;
-				DWORD last;
-
-				count = (DWORD) *p++;
-				_GLD_glBegin(GL_QUAD_STRIP);
-
-				/* Check if the first and last vertex are identical
-				 * so we don't draw the same quad twice.
-				 */
-				vert = p + (count-1)*2;
-				last = (p[0] == vert[0] && p[1] == vert[1]) ? count-1 : count;
-
-				for (point = 0; point <= last; point++) {
-					vert  = p + 2 * (point % last);
-					vert2 = p + 2 * ((point+1) % last);
-
-					dx = vert[0] - vert2[0];
-					dy = vert[1] - vert2[1];
-					len = (GLfloat)sqrt(dx * dx + dy * dy);
-
-					_GLD_glNormal3f(dy / len, -dx / len, 0.0f);
-					_GLD_glVertex3f((GLfloat) vert[0],
-							   (GLfloat) vert[1], thickness);
-					_GLD_glVertex3f((GLfloat) vert[0],
-							   (GLfloat) vert[1], 0.0f);
-				}
-
-				_GLD_glEnd();
-				p += count*2;
-			}
-
-			/* Draw the back face */
-			p = save_p;
-			v[2] = thickness;
-			_GLD_glNormal3f(0.0f, 0.0f, -1.0f);
-			gluTessNormalProc(tess,	0.0F, 0.0F, -1.0F);
-
-			gluTessBeginPolygonProc(tess, (void *)*(int *)&thickness);
-
-			for (loop = (DWORD) *p++; loop; --loop)
-			{
-				count = (DWORD) *p++;
-
-				gluTessBeginContourProc(tess);
-				
-				for (point = 0; point < count; point++)
-				{
-					vert = p + ((count-point-1)<<1);
-					v[0] = vert[0];
-					v[1] = vert[1];
-					gluTessVertexProc(tess, v, vert);
-				}
-				p += count*2;
-
-				gluTessEndContourProc(tess);
-			}
-			gluTessEndPolygonProc(tess);
-		}
-
-#if DEBUG
-	if (TessErrorOccurred)
-		printf("Tessellation error %s\n",
-			gluErrorString(TessErrorOccurred));
-#endif
-		}
-
-
-exit:
-	FreeLineBuf();
-	if (tess)
-		gluDeleteTessProc(tess);
-	// UnloadGLUTesselator();
-	FreeVertBuf();
-	return status;
-	}
-
-
-
-/*****************************************************************************
- * LoadGLUTesselator
- *
- * Maps the glu32.dll module and gets function pointers for the 
- * tesselator functions.
- *****************************************************************************/
-
-static BOOL
-LoadGLUTesselator(void)
-	{
-	if (gluModuleHandle != NULL)
-		return TRUE;
-
-	{
-		extern HINSTANCE hInstanceOpenGL;
-		char *gluName = "GLU32.DLL";
-//		char name[256];
-//		char *ptr;
-//		int len;
-
-/*
-		len = GetModuleFileName(hInstanceOpenGL, name, 255);
-		if (len != 0)
-			{
-			ptr = name+len-1;
-			while (ptr > name && *ptr != '\\')
-				ptr--;
-			if (*ptr == '\\')
-				ptr++;
-			if (!stricmp(ptr, "cosmogl.dll"))
-				{
-				gluName = "COSMOGLU.DLL";
-				}
-			else if (!stricmp(ptr, "opengl32.dll"))
-				{
-				gluName = "GLU32.DLL";
-				}
-			}
-*/
-		if ((gluModuleHandle = LoadLibrary(gluName)) == NULL)
-			return FALSE;
-	}
-
-	if ((gluNewTessProc = (gluNewTessProto)
-		GetProcAddress(gluModuleHandle, "gluNewTess")) == NULL)
-		return FALSE;
-	
-	if ((gluDeleteTessProc = (gluDeleteTessProto)
-		GetProcAddress(gluModuleHandle, "gluDeleteTess")) == NULL)
-		return FALSE;
-	
-	if ((gluTessBeginPolygonProc = (gluTessBeginPolygonProto)
-		GetProcAddress(gluModuleHandle, "gluTessBeginPolygon")) == NULL)
-		return FALSE;
-	
-	if ((gluTessBeginContourProc = (gluTessBeginContourProto)
-		GetProcAddress(gluModuleHandle, "gluTessBeginContour")) == NULL)
-		return FALSE;
-	
-	if ((gluTessVertexProc = (gluTessVertexProto)
-		GetProcAddress(gluModuleHandle, "gluTessVertex")) == NULL)
-		return FALSE;
-	
-	if ((gluTessEndContourProc = (gluTessEndContourProto)
-		GetProcAddress(gluModuleHandle, "gluTessEndContour")) == NULL)
-		return FALSE;
-	
-	if ((gluTessEndPolygonProc = (gluTessEndPolygonProto)
-		GetProcAddress(gluModuleHandle, "gluTessEndPolygon")) == NULL)
-		return FALSE;
-	
-	if ((gluTessPropertyProc = (gluTessPropertyProto)
-		GetProcAddress(gluModuleHandle, "gluTessProperty")) == NULL)
-		return FALSE;
-
-	if ((gluTessNormalProc = (gluTessNormalProto)
-		GetProcAddress(gluModuleHandle, "gluTessNormal")) == NULL)
-		return FALSE;
-	
-	if ((gluTessCallbackProc = (gluTessCallbackProto)
-		GetProcAddress(gluModuleHandle, "gluTessCallback")) == NULL)
-		return FALSE;
-
-	return TRUE;
-	}
-
-
-
-/*****************************************************************************
- * UnloadGLUTesselator
- *
- * Unmaps the glu32.dll module.
- *****************************************************************************/
-
-static BOOL
-UnloadGLUTesselator(void)
-	{
-	if (gluModuleHandle != NULL)
-	    if (FreeLibrary(gluModuleHandle) == FALSE)
-		return FALSE;
-	gluModuleHandle = NULL;
-	}
-
-
-
-/*****************************************************************************
- * TessVertexOut
- *
- * Used by tessellator to handle output vertexes.
- *****************************************************************************/
- 
-static void CALLBACK
-TessVertexOut(FLOAT	p[3])
-	{
-	    GLfloat v[2];
-
-	    v[0] = p[0] * ScaleFactor;
-	    v[1] = p[1] * ScaleFactor;
-	    _GLD_glVertex2fv(v);
-	}
-
-static void CALLBACK
-TessVertexOutData(FLOAT	p[3], GLfloat z)
-{
-    GLfloat v[3];
-
-    v[0] = (GLfloat) p[0];
-    v[1] = (GLfloat) p[1];
-    v[2] = z;
-    _GLD_glVertex3fv(v);
-}
-
-
-/*****************************************************************************
- * TessCombine
- *
- * Used by tessellator to handle self-intersecting contours and degenerate
- * geometry.
- *****************************************************************************/
- 
-static void CALLBACK
-TessCombine(double	coords[3],
-	    void*	vertex_data[4],
-	    FLOAT	weight[4],
-	    void**	outData)
-	{
-	if (!AppendToVertBuf((FLOAT) coords[0])
-	 || !AppendToVertBuf((FLOAT) coords[1])
-	 || !AppendToVertBuf((FLOAT) coords[2]))
-		TessErrorOccurred = GL_OUT_OF_MEMORY;
-	*outData = VertBuf + (VertBufIndex - 3);
-	}
-
-
-
-/*****************************************************************************
- * TessError
- *
- * Saves the last tessellator error code in the global TessErrorOccurred.
- *****************************************************************************/
- 
-static void CALLBACK
-TessError(GLenum error)
-	{
-	TessErrorOccurred = error;
-	}
-
-
-
-/*****************************************************************************
- * MakeLinesFromGlyph
- * 
- * Converts the outline of a glyph from the TTPOLYGON format to a simple
- * array of floating-point values containing one or more loops.
- *
- * The first element of the output array is a count of the number of loops.
- * The loop data follows this count.  Each loop consists of a count of the
- * number of vertices it contains, followed by the vertices.  Each vertex
- * is an X and Y coordinate.  For example, a single triangle might be
- * described by this array:
- *
- *	1.,	3.,	0., 0.,		1., 0.,		0., 1.
- *       ^	 ^	 ^    ^		 ^    ^		 ^    ^
- *     #loops	#verts	 x1   y1	 x2   y2	 x3   y3
- *
- * A two-loop glyph would look like this:
- *
- *	2.,	3.,  0.,0.,  1.,0.,  0.,1.,	3.,  .2,.2,  .4,.2,  .2,.4
- *
- * Line segments from the TTPOLYGON are transferred to the output array in
- * the obvious way.  Quadratic splines in the TTPOLYGON are converted to
- * collections of line segments
- *****************************************************************************/
-
-static int
-MakeLinesFromGlyph(IN  UCHAR*	glyphBuf,
-		   IN  DWORD	glyphSize,
-		   IN  FLOAT	chordalDeviation)
-	{
-	UCHAR*	p;
-	int	status = 0;
-
-
-	/*
-	 * Pick up all the polygons (aka loops) that make up the glyph:
-	 */
-	if (!AppendToLineBuf(0.0F))	/* loop count at LineBuf[0] */
-		goto exit;
-
-	p = glyphBuf;
-	while (p < glyphBuf + glyphSize)
-		{
-		if (!MakeLinesFromTTPolygon(&p, chordalDeviation))
-			goto exit;
-		LineBuf[0] += 1.0F;	/* increment loop count */
-		}
-
-	status = 1;
-
-exit:
-	return status;
-	}
-
-
-
-/*****************************************************************************
- * MakeLinesFromTTPolygon
- *
- * Converts a TTPOLYGONHEADER and its associated curve structures into a
- * single polyline loop in the global LineBuf.
- *****************************************************************************/
-
-static int
-MakeLinesFromTTPolygon(	IN OUT	UCHAR**	pp,
-			IN	FLOAT	chordalDeviation)
-	{
-	DWORD	polySize;
-	UCHAR*	polyStart;
-	DWORD	vertexCountIndex;
-
-	/*
-	 * Record where the polygon data begins, and where the loop's
-	 * vertex count resides:
-	 */
-	polyStart = *pp;
-	vertexCountIndex = LineBufIndex;
-	if (!AppendToLineBuf(0.0F))
-		return 0;
-
-	/*
-	 * Extract relevant data from the TTPOLYGONHEADER:
-	 */
-	polySize = GetDWord(pp);
-	if (GetDWord(pp) != TT_POLYGON_TYPE)	/* polygon type */
-		return 0;
-	if (!AppendToLineBuf((FLOAT) GetFixed(pp)))	/* first X coord */
-		return 0;
-	if (!AppendToLineBuf((FLOAT) GetFixed(pp)))	/* first Y coord */
-		return 0;
-	LineBuf[vertexCountIndex] += 1.0F;
-
-	/*
-	 * Process each of the TTPOLYCURVE structures in the polygon:
-	 */
-	while (*pp < polyStart + polySize)
-		if (!MakeLinesFromTTPolycurve(	pp,
-						vertexCountIndex,
-						chordalDeviation))
-		return 0;
-
-	return 1;
-	}
-
-
-
-/*****************************************************************************
- * MakeLinesFromTTPolyCurve
- *
- * Converts the lines and splines in a single TTPOLYCURVE structure to points
- * in the global LineBuf.
- *****************************************************************************/
-
-static int
-MakeLinesFromTTPolycurve(	IN OUT	UCHAR**	pp,
-				IN	DWORD	vertexCountIndex,
-				IN	FLOAT	chordalDeviation)
-	{
-	WORD type;
-	WORD pointCount;
-
-
-	/*
-	 * Pick up the relevant fields of the TTPOLYCURVE structure:
-	 */
-	type = (WORD) GetWord(pp);
-	pointCount = (WORD) GetWord(pp);
-
-	/*
-	 * Convert the "curve" to line segments:
-	 */
-	if (type == TT_PRIM_LINE)
-		return MakeLinesFromTTLine(	pp,
-						vertexCountIndex,
-						pointCount);
-	else if (type == TT_PRIM_QSPLINE)
-		return MakeLinesFromTTQSpline(	pp,
-						vertexCountIndex,
-						pointCount,
-						chordalDeviation);
-	else
-		return 0;
-	}
-
-
-
-/*****************************************************************************
- * MakeLinesFromTTLine
- *
- * Converts points from the polyline in a TT_PRIM_LINE structure to
- * equivalent points in the global LineBuf.
- *****************************************************************************/
-static int
-MakeLinesFromTTLine(	IN OUT	UCHAR**	pp,
-			IN	DWORD	vertexCountIndex,
-			IN	WORD	pointCount)
-	{
-	/*
-	 * Just copy the line segments into the line buffer (converting
-	 * type as we go):
-	 */
-	LineBuf[vertexCountIndex] += pointCount;
-	while (pointCount--)
-		{
-		if (!AppendToLineBuf((FLOAT) GetFixed(pp))	/* X coord */
-		 || !AppendToLineBuf((FLOAT) GetFixed(pp)))	/* Y coord */
-			return 0;
-		}
-
-	return 1;
-	}
-
-
-
-/*****************************************************************************
- * MakeLinesFromTTQSpline
- *
- * Converts points from the poly quadratic spline in a TT_PRIM_QSPLINE
- * structure to polyline points in the global LineBuf.
- *****************************************************************************/
-
-static int
-MakeLinesFromTTQSpline(	IN OUT	UCHAR**	pp,
-			IN	DWORD	vertexCountIndex,
-			IN	WORD	pointCount,
-			IN	FLOAT	chordalDeviation)
-	{
-	FLOAT x0, y0, x1, y1, x2, y2;
-	WORD point;
-
-	/*
-	 * Process each of the non-interpolated points in the outline.
-	 * To do this, we need to generate two interpolated points (the
-	 * start and end of the arc) for each non-interpolated point.
-	 * The first interpolated point is always the one most recently
-	 * stored in LineBuf, so we just extract it from there.  The
-	 * second interpolated point is either the average of the next
-	 * two points in the QSpline, or the last point in the QSpline
-	 * if only one remains.
-	 */
-	for (point = 0; point < pointCount - 1; ++point)
-		{
-		x0 = LineBuf[LineBufIndex - 2];
-		y0 = LineBuf[LineBufIndex - 1];
-
-		x1 = (FLOAT) GetFixed(pp);
-		y1 = (FLOAT) GetFixed(pp);
-
-		if (point == pointCount - 2)
-			{
-			/*
-			 * This is the last arc in the QSpline.  The final
-			 * point is the end of the arc.
-			 */
-			x2 = (FLOAT) GetFixed(pp);
-			y2 = (FLOAT) GetFixed(pp);
-			}
-		else
-			{
-			/*
-			 * Peek at the next point in the input to compute
-			 * the end of the arc:
-			 */
-			x2 = 0.5F * (x1 + (FLOAT) GetFixed(pp));
-			y2 = 0.5F * (y1 + (FLOAT) GetFixed(pp));
-			/*
-			 * Push the point back onto the input so it will
-			 * be reused as the next off-curve point:
-			 */
-			*pp -= 8;
-			}
-
-		if (!MakeLinesFromArc(	x0, y0,
-					x1, y1,
-					x2, y2,
-					vertexCountIndex,
-					chordalDeviation * chordalDeviation))
-			return 0;
-		}
-
-	return 1;
-	}
-
-
-
-/*****************************************************************************
- * MakeLinesFromArc
- *
- * Subdivides one arc of a quadratic spline until the chordal deviation
- * tolerance requirement is met, then places the resulting set of line
- * segments in the global LineBuf.
- *****************************************************************************/
-
-static int
-MakeLinesFromArc(	IN	FLOAT	x0,
-			IN	FLOAT	y0,
-			IN	FLOAT	x1,
-			IN	FLOAT	y1,
-			IN	FLOAT	x2,
-			IN	FLOAT	y2,
-			IN	DWORD	vertexCountIndex,
-			IN	FLOAT	chordalDeviationSquared)
-	{
-	FLOAT	x01;
-	FLOAT	y01;
-	FLOAT	x12;
-	FLOAT	y12;
-	FLOAT	midPointX;
-	FLOAT	midPointY;
-	FLOAT	deltaX;
-	FLOAT	deltaY;
-
-	/*
-	 * Calculate midpoint of the curve by de Casteljau:
-	 */
-	x01 = 0.5F * (x0 + x1);
-	y01 = 0.5F * (y0 + y1);
-	x12 = 0.5F * (x1 + x2);
-	y12 = 0.5F * (y1 + y2);
-	midPointX = 0.5F * (x01 + x12);
-	midPointY = 0.5F * (y01 + y12);
-
-
-	/*
-	 * Estimate chordal deviation by the distance from the midpoint
-	 * of the curve to its non-interpolated control point.  If this
-	 * distance is greater than the specified chordal deviation
-	 * constraint, then subdivide.  Otherwise, generate polylines
-	 * from the three control points.
-	 */
-	deltaX = midPointX - x1;
-	deltaY = midPointY - y1;
-	if (deltaX * deltaX + deltaY * deltaY > chordalDeviationSquared)
-		{
-		MakeLinesFromArc(	x0, y0,
-					x01, y01,
-					midPointX, midPointY,
-					vertexCountIndex,
-					chordalDeviationSquared);
-		
-		MakeLinesFromArc(	midPointX, midPointY,
-					x12, y12,
-					x2, y2,
-					vertexCountIndex,
-					chordalDeviationSquared);
-		}
-	else
-		{
-		/*
-		 * The "pen" is already at (x0, y0), so we don't need to
-		 * add that point to the LineBuf.
-		 */
-		if (!AppendToLineBuf(x1)
-		 || !AppendToLineBuf(y1)
-		 || !AppendToLineBuf(x2)
-		 || !AppendToLineBuf(y2))
-			return 0;
-		LineBuf[vertexCountIndex] += 2.0F;
-		}
-
-	return 1;
-	}
-
-
-
-/*****************************************************************************
- * InitLineBuf
- *
- * Initializes the global LineBuf and its associated size and current-element
- * counters.
- *****************************************************************************/
-
-static int
-InitLineBuf(void)
-	{
-	if (!(LineBuf = (FLOAT*)
-		__wglMalloc((LineBufSize = LINE_BUF_QUANT) * sizeof(FLOAT))))
-			return 0;
-	LineBufIndex = 0;
-	return 1;
-	}
-
-
-
-/*****************************************************************************
- * InitVertBuf
- *
- * Initializes the global VertBuf and its associated size and current-element
- * counters.
- *****************************************************************************/
-
-static int
-InitVertBuf(void)
-	{
-	if (!(VertBuf = (FLOAT*)
-		__wglMalloc((VertBufSize = VERT_BUF_QUANT) * sizeof(FLOAT))))
-			return 0;
-	VertBufIndex = 0;
-	return 1;
-	}
-
-
-
-/*****************************************************************************
- * AppendToLineBuf
- *
- * Appends one floating-point value to the global LineBuf array.  Return value
- * is non-zero for success, zero for failure.
- *****************************************************************************/
-
-static int
-AppendToLineBuf(FLOAT value)
-	{
-	if (LineBufIndex >= LineBufSize)
-		{
-		FLOAT* f;
-		
-		f = (FLOAT*) __wglRealloc(LineBuf,
-			(LineBufSize += LINE_BUF_QUANT) * sizeof(FLOAT));
-		if (!f)
-			return 0;
-		LineBuf = f;
-		}
-	LineBuf[LineBufIndex++] = value;
-	return 1;
-	}
-
-
-
-/*****************************************************************************
- * AppendToVertBuf
- *
- * Appends one floating-point value to the global VertBuf array.  Return value
- * is non-zero for success, zero for failure.
- *
- * Note that we can't realloc this one, because the tessellator is using
- * pointers into it.
- *****************************************************************************/
-
-static int
-AppendToVertBuf(FLOAT value)
-	{
-	if (VertBufIndex >= VertBufSize)
-		return 0;
-	VertBuf[VertBufIndex++] = value;
-	return 1;
-	}
-
-
-
-/*****************************************************************************
- * FreeLineBuf
- *
- * Cleans up vertex buffer structure.
- *****************************************************************************/
-
-static void
-FreeLineBuf(void)
-	{
-	if (LineBuf)
-		{
-		__wglFree(LineBuf);
-		LineBuf = NULL;
-		}
-	}
-
-
-
-/*****************************************************************************
- * FreeVertBuf
- *
- * Cleans up vertex buffer structure.
- *****************************************************************************/
-
-static void
-FreeVertBuf(void)
-	{
-	if (VertBuf)
-		{
-		__wglFree(VertBuf);
-		VertBuf = NULL;
-		}
-	}
-
-
-
-/*****************************************************************************
- * GetWord
- *
- * Fetch the next 16-bit word from a little-endian byte stream, and increment
- * the stream pointer to the next unscanned byte.
- *****************************************************************************/
-
-static long GetWord(UCHAR** p)
-	{
-	long value;
-
-	value = ((*p)[1] << 8) + (*p)[0];
-	*p += 2;
-	return value;
-	}
-
-
-
-/*****************************************************************************
- * GetDWord
- *
- * Fetch the next 32-bit word from a little-endian byte stream, and increment
- * the stream pointer to the next unscanned byte.
- *****************************************************************************/
-
-static long GetDWord(UCHAR** p)
-	{
-	long value;
-
-	value = ((*p)[3] << 24) + ((*p)[2] << 16) + ((*p)[1] << 8) + (*p)[0];
-	*p += 4;
-	return value;
-	}
-
-
-
-
-/*****************************************************************************
- * GetFixed
- *
- * Fetch the next 32-bit fixed-point value from a little-endian byte stream,
- * convert it to floating-point, and increment the stream pointer to the next
- * unscanned byte.
- *****************************************************************************/
-
-static double GetFixed(
-	UCHAR** p)
-{
-	long hiBits, loBits;
-	double value;
-
-	loBits = GetWord(p);
-	hiBits = GetWord(p);
-	value = (double) ((hiBits << 16) | loBits) / 65536.0;
-
-	return value * ScaleFactor;
-}
-
-// ***********************************************************************
-