fxwgl.c

Go to the documentation of this file.

/*
 * Mesa 3-D graphics library
 * Version:  4.0
 *
 * Copyright (C) 1999-2001  Brian Paul   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
 * BRIAN PAUL 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.
 */

/* Authors:
 *    David Bucciarelli
 *    Brian Paul
 *    Keith Whitwell
 *    Hiroshi Morii
 *    Daniel Borca
 */

/* fxwgl.c - Microsoft wgl functions emulation for
 *           3Dfx VooDoo/Mesa interface
 */


#ifdef _WIN32

#ifdef __cplusplus
extern "C" {
#endif

#include <windows.h>
#define GL_GLEXT_PROTOTYPES
#include "GL/gl.h"
#include "GL/glext.h"

#ifdef __cplusplus
}
#endif

#include "GL/fxmesa.h"
#include "glheader.h"
#include "glapi.h"
#include "imports.h"
#include "../../glide/fxdrv.h"

#define MAX_MESA_ATTRS  20

#if (_MSC_VER >= 1200)
#pragma warning( push )
#pragma warning( disable : 4273 )
#endif

struct __extensions__ {
   PROC proc;
   char *name;
};

struct __pixelformat__ {
   PIXELFORMATDESCRIPTOR pfd;
   GLint mesaAttr[MAX_MESA_ATTRS];
};

WINGDIAPI void GLAPIENTRY gl3DfxSetPaletteEXT(GLuint *);
static GLushort gammaTable[3 * 256];

struct __pixelformat__ pix[] = {
   /* 16bit RGB565 single buffer with depth */
   {
    {sizeof(PIXELFORMATDESCRIPTOR), 1,
     PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL,
     PFD_TYPE_RGBA,
     16,
     5, 0, 6, 5, 5, 11, 0, 0,
     0, 0, 0, 0, 0,
     16,
     0,
     0,
     PFD_MAIN_PLANE,
     0, 0, 0, 0}
    ,
    {FXMESA_COLORDEPTH, 16,
     FXMESA_ALPHA_SIZE, 0,
     FXMESA_DEPTH_SIZE, 16,
     FXMESA_STENCIL_SIZE, 0,
     FXMESA_ACCUM_SIZE, 0,
     FXMESA_NONE}
   }
   ,
   /* 16bit RGB565 double buffer with depth */
   {
    {sizeof(PIXELFORMATDESCRIPTOR), 1,
     PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL |
     PFD_DOUBLEBUFFER | PFD_SWAP_COPY,
     PFD_TYPE_RGBA,
     16,
     5, 0, 6, 5, 5, 11, 0, 0,
     0, 0, 0, 0, 0,
     16,
     0,
     0,
     PFD_MAIN_PLANE,
     0, 0, 0, 0}
    ,
    {FXMESA_COLORDEPTH, 16,
     FXMESA_DOUBLEBUFFER,
     FXMESA_ALPHA_SIZE, 0,
     FXMESA_DEPTH_SIZE, 16,
     FXMESA_STENCIL_SIZE, 0,
     FXMESA_ACCUM_SIZE, 0,
     FXMESA_NONE}
   }
   ,
   /* 16bit ARGB1555 single buffer with depth */
   {
    {sizeof(PIXELFORMATDESCRIPTOR), 1,
     PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL,
     PFD_TYPE_RGBA,
     16,
     5, 0, 5, 5, 5, 10, 1, 15,
     0, 0, 0, 0, 0,
     16,
     0,
     0,
     PFD_MAIN_PLANE,
     0, 0, 0, 0}
    ,
    {FXMESA_COLORDEPTH, 15,
     FXMESA_ALPHA_SIZE, 1,
     FXMESA_DEPTH_SIZE, 16,
     FXMESA_STENCIL_SIZE, 0,
     FXMESA_ACCUM_SIZE, 0,
     FXMESA_NONE}
   }
   ,
   /* 16bit ARGB1555 double buffer with depth */
   {
    {sizeof(PIXELFORMATDESCRIPTOR), 1,
     PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL |
     PFD_DOUBLEBUFFER | PFD_SWAP_COPY,
     PFD_TYPE_RGBA,
     16,
     5, 0, 5, 5, 5, 10, 1, 15,
     0, 0, 0, 0, 0,
     16,
     0,
     0,
     PFD_MAIN_PLANE,
     0, 0, 0, 0}
    ,
    {FXMESA_COLORDEPTH, 15,
     FXMESA_DOUBLEBUFFER,
     FXMESA_ALPHA_SIZE, 1,
     FXMESA_DEPTH_SIZE, 16,
     FXMESA_STENCIL_SIZE, 0,
     FXMESA_ACCUM_SIZE, 0,
     FXMESA_NONE}
   }
   ,
   /* 32bit ARGB8888 single buffer with depth */
   {
    {sizeof(PIXELFORMATDESCRIPTOR), 1,
     PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL,
     PFD_TYPE_RGBA,
     32,
     8, 0, 8, 8, 8, 16, 8, 24,
     0, 0, 0, 0, 0,
     24,
     8,
     0,
     PFD_MAIN_PLANE,
     0, 0, 0, 0}
    ,
    {FXMESA_COLORDEPTH, 32,
     FXMESA_ALPHA_SIZE, 8,
     FXMESA_DEPTH_SIZE, 24,
     FXMESA_STENCIL_SIZE, 8,
     FXMESA_ACCUM_SIZE, 0,
     FXMESA_NONE}
   }
   ,
   /* 32bit ARGB8888 double buffer with depth */
   {
    {sizeof(PIXELFORMATDESCRIPTOR), 1,
     PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL |
     PFD_DOUBLEBUFFER | PFD_SWAP_COPY,
     PFD_TYPE_RGBA,
     32,
     8, 0, 8, 8, 8, 16, 8, 24,
     0, 0, 0, 0, 0,
     24,
     8,
     0,
     PFD_MAIN_PLANE,
     0, 0, 0, 0}
    ,
    {FXMESA_COLORDEPTH, 32,
     FXMESA_DOUBLEBUFFER,
     FXMESA_ALPHA_SIZE, 8,
     FXMESA_DEPTH_SIZE, 24,
     FXMESA_STENCIL_SIZE, 8,
     FXMESA_ACCUM_SIZE, 0,
     FXMESA_NONE}
   }
};

static fxMesaContext ctx = NULL;
static WNDPROC hWNDOldProc;
static int curPFD = 0;
static HDC hDC;
static HWND hWND;

static GLboolean haveDualHead;

/* For the in-window-rendering hack */

#ifndef GR_CONTROL_RESIZE
/* Apparently GR_CONTROL_RESIZE can be ignored. OK? */
#define GR_CONTROL_RESIZE -1
#endif

static GLboolean gdiWindowHack;
static void *dibSurfacePtr;
static BITMAPINFO *dibBMI;
static HBITMAP dibHBM;
static HWND dibWnd;

static int
env_check (const char *var, int val)
{
   const char *env = getenv(var);
   return (env && (env[0] == val));
}

static LRESULT APIENTRY
__wglMonitor (HWND hwnd, UINT message, UINT wParam, LONG lParam)
{
   long ret;                    /* Now gives the resized window at the end to hWNDOldProc */

   if (ctx && hwnd == hWND) {
      switch (message) {
         case WM_PAINT:
         case WM_MOVE:
            break;
         case WM_DISPLAYCHANGE:
         case WM_SIZE:
#if 0
            if (wParam != SIZE_MINIMIZED) {
               static int moving = 0;
               if (!moving) {
                  if (!FX_grSstControl(GR_CONTROL_RESIZE)) {
                     moving = 1;
                     SetWindowPos(hwnd, 0, 0, 0, 300, 300, SWP_NOMOVE | SWP_NOZORDER);
                     moving = 0;
                     if (!FX_grSstControl(GR_CONTROL_RESIZE)) {
                        /*MessageBox(0,_T("Error changing windowsize"),_T("fxMESA"),MB_OK);*/
                        PostMessage(hWND, WM_CLOSE, 0, 0);
                     }
                  }
                  /* Do the clipping in the glide library */
                  grClipWindow(0, 0, FX_grSstScreenWidth(), FX_grSstScreenHeight());
                  /* And let the new size set in the context */
                  fxMesaUpdateScreenSize(ctx);
               }
            }
#endif
            break;
         case WM_ACTIVATE:
            break;
         case WM_SHOWWINDOW:
            break;
         case WM_SYSKEYDOWN:
         case WM_SYSCHAR:
            break;
      }
   }

   /* Finally call the hWNDOldProc, which handles the resize with the
    * now changed window sizes */
   ret = CallWindowProc(hWNDOldProc, hwnd, message, wParam, lParam);

   return ret;
}

static void
wgl_error (long error)
{
#define WGL_INVALID_PIXELFORMAT ERROR_INVALID_PIXEL_FORMAT
   SetLastError(0xC0000000      /* error severity */
               |0x00070000      /* error facility (who we are) */
               |error);
}

GLAPI BOOL GLAPIENTRY
wglCopyContext (HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask)
{
   return FALSE;
}

GLAPI HGLRC GLAPIENTRY
wglCreateContext (HDC hdc)
{
   HWND hWnd;
   WNDPROC oldProc;
   int error;

   if (ctx) {
      SetLastError(0);
      return NULL;
   }

   if (!(hWnd = WindowFromDC(hdc))) {
      SetLastError(0);
      return NULL;
   }

   if (curPFD == 0) {
      wgl_error(WGL_INVALID_PIXELFORMAT);
      return NULL;
   }

   if ((oldProc = (WNDPROC)GetWindowLong(hWnd, GWL_WNDPROC)) != __wglMonitor) {
      hWNDOldProc = oldProc;
      SetWindowLong(hWnd, GWL_WNDPROC, (LONG)__wglMonitor);
   }

   /* always log when debugging, or if user demands */
   if (TDFX_DEBUG || env_check("MESA_FX_INFO", 'r')) {
      freopen("MESA.LOG", "w", stderr);
   }

   {
      RECT cliRect;
      ShowWindow(hWnd, SW_SHOWNORMAL);
      SetForegroundWindow(hWnd);
      Sleep(100);               /* a hack for win95 */
      if (env_check("MESA_GLX_FX", 'w') && !(GetWindowLong(hWnd, GWL_STYLE) & WS_POPUP)) {
         /* XXX todo - windowed modes */
         error = !(ctx = fxMesaCreateContext((GLuint) hWnd, GR_RESOLUTION_NONE, GR_REFRESH_NONE, pix[curPFD - 1].mesaAttr));
      } else {
         GetClientRect(hWnd, &cliRect);
         error = !(ctx = fxMesaCreateBestContext((GLuint) hWnd, cliRect.right, cliRect.bottom, pix[curPFD - 1].mesaAttr));
      }
   }

   /*if (getenv("SST_DUALHEAD"))
      haveDualHead =
         ((atoi(getenv("SST_DUALHEAD")) == 1) ? GL_TRUE : GL_FALSE);
   else
      haveDualHead = GL_FALSE;*/

   if (error) {
      SetLastError(0);
      return NULL;
   }

   hDC = hdc;
   hWND = hWnd;

   /* Required by the OpenGL Optimizer 1.1 (is it a Optimizer bug ?) */
   wglMakeCurrent(hdc, (HGLRC)1);

   return (HGLRC)1;
}

GLAPI HGLRC GLAPIENTRY
wglCreateLayerContext (HDC hdc, int iLayerPlane)
{
   SetLastError(0);
   return NULL;
}

GLAPI BOOL GLAPIENTRY
wglDeleteContext (HGLRC hglrc)
{
   if (ctx && hglrc == (HGLRC)1) {

      fxMesaDestroyContext(ctx);

      SetWindowLong(WindowFromDC(hDC), GWL_WNDPROC, (LONG) hWNDOldProc);

      ctx = NULL;
      hDC = 0;
      return TRUE;
   }

   SetLastError(0);

   return FALSE;
}

GLAPI HGLRC GLAPIENTRY
wglGetCurrentContext (VOID)
{
   if (ctx)
      return (HGLRC)1;

   SetLastError(0);
   return NULL;
}

GLAPI HDC GLAPIENTRY
wglGetCurrentDC (VOID)
{
   if (ctx)
      return hDC;

   SetLastError(0);
   return NULL;
}

GLAPI BOOL GLAPIENTRY
wglSwapIntervalEXT (int interval)
{
   if (ctx == NULL) {
      return FALSE;
   }
   if (interval < 0) {
      interval = 0;
   } else if (interval > 3) {
      interval = 3;
   }
   ctx->swapInterval = interval;
   return TRUE;
}

GLAPI int GLAPIENTRY
wglGetSwapIntervalEXT (void)
{
   return (ctx == NULL) ? -1 : ctx->swapInterval;
}

GLAPI BOOL GLAPIENTRY
wglGetDeviceGammaRamp3DFX (HDC hdc, LPVOID arrays)
{
   /* gammaTable should be per-context */
   memcpy(arrays, gammaTable, 3 * 256 * sizeof(GLushort));
   return TRUE;
}

GLAPI BOOL GLAPIENTRY
wglSetDeviceGammaRamp3DFX (HDC hdc, LPVOID arrays)
{
   GLint i, tableSize, inc, index;
   GLushort *red, *green, *blue;
   FxU32 gammaTableR[256], gammaTableG[256], gammaTableB[256];

   /* gammaTable should be per-context */
   memcpy(gammaTable, arrays, 3 * 256 * sizeof(GLushort));

   tableSize = FX_grGetInteger(GR_GAMMA_TABLE_ENTRIES);
   inc = 256 / tableSize;
   red = (GLushort *)arrays;
   green = (GLushort *)arrays + 256;
   blue = (GLushort *)arrays + 512;
   for (i = 0, index = 0; i < tableSize; i++, index += inc) {
      gammaTableR[i] = red[index] >> 8;
      gammaTableG[i] = green[index] >> 8;
      gammaTableB[i] = blue[index] >> 8;
   }

   grLoadGammaTable(tableSize, gammaTableR, gammaTableG, gammaTableB);

   return TRUE;
}

typedef void *HPBUFFERARB;

/* WGL_ARB_pixel_format */
GLAPI BOOL GLAPIENTRY
wglGetPixelFormatAttribivARB (HDC hdc,
                              int iPixelFormat,
                              int iLayerPlane,
                              UINT nAttributes,
                              const int *piAttributes,
                              int *piValues)
{
   SetLastError(0);
   return FALSE;
}

GLAPI BOOL GLAPIENTRY
wglGetPixelFormatAttribfvARB (HDC hdc,
                              int iPixelFormat,
                              int iLayerPlane,
                              UINT nAttributes,
                              const int *piAttributes,
                              FLOAT *pfValues)
{
   SetLastError(0);
   return FALSE;
}

GLAPI BOOL GLAPIENTRY
wglChoosePixelFormatARB (HDC hdc,
                         const int *piAttribIList,
                         const FLOAT *pfAttribFList,
                         UINT nMaxFormats,
                         int *piFormats,
                         UINT *nNumFormats)
{
   SetLastError(0);
   return FALSE;
}

/* WGL_ARB_render_texture */
GLAPI BOOL GLAPIENTRY
wglBindTexImageARB (HPBUFFERARB hPbuffer, int iBuffer)
{
   SetLastError(0);
   return FALSE;
}

GLAPI BOOL GLAPIENTRY
wglReleaseTexImageARB (HPBUFFERARB hPbuffer, int iBuffer)
{
   SetLastError(0);
   return FALSE;
}

GLAPI BOOL GLAPIENTRY
wglSetPbufferAttribARB (HPBUFFERARB hPbuffer,
                        const int *piAttribList)
{
   SetLastError(0);
   return FALSE;
}

/* WGL_ARB_pbuffer */
GLAPI HPBUFFERARB GLAPIENTRY
wglCreatePbufferARB (HDC hDC,
                     int iPixelFormat,
                     int iWidth,
                     int iHeight,
                     const int *piAttribList)
{
   SetLastError(0);
   return NULL;
}

GLAPI HDC GLAPIENTRY
wglGetPbufferDCARB (HPBUFFERARB hPbuffer)
{
   SetLastError(0);
   return NULL;
}

GLAPI int GLAPIENTRY
wglReleasePbufferDCARB (HPBUFFERARB hPbuffer, HDC hDC)
{
   SetLastError(0);
   return -1;
}

GLAPI BOOL GLAPIENTRY
wglDestroyPbufferARB (HPBUFFERARB hPbuffer)
{
   SetLastError(0);
   return FALSE;
}

GLAPI BOOL GLAPIENTRY
wglQueryPbufferARB (HPBUFFERARB hPbuffer,
                    int iAttribute,
                    int *piValue)
{
   SetLastError(0);
   return FALSE;
}

GLAPI const char * GLAPIENTRY
wglGetExtensionsStringEXT (void)
{
   return "WGL_3DFX_gamma_control "
          "WGL_EXT_swap_control "
          "WGL_EXT_extensions_string WGL_ARB_extensions_string"
         /*WGL_ARB_pixel_format WGL_ARB_render_texture WGL_ARB_pbuffer*/;
}

GLAPI const char * GLAPIENTRY
wglGetExtensionsStringARB (HDC hdc)
{
   return wglGetExtensionsStringEXT();
}

static struct {
   const char *name;
   PROC func;
} wgl_ext[] = {
       {"wglGetExtensionsStringARB",    (PROC)wglGetExtensionsStringARB},
       {"wglGetExtensionsStringEXT",    (PROC)wglGetExtensionsStringEXT},
       {"wglSwapIntervalEXT",           (PROC)wglSwapIntervalEXT},
       {"wglGetSwapIntervalEXT",        (PROC)wglGetSwapIntervalEXT},
       {"wglGetDeviceGammaRamp3DFX",    (PROC)wglGetDeviceGammaRamp3DFX},
       {"wglSetDeviceGammaRamp3DFX",    (PROC)wglSetDeviceGammaRamp3DFX},
       /* WGL_ARB_pixel_format */
       {"wglGetPixelFormatAttribivARB", (PROC)wglGetPixelFormatAttribivARB},
       {"wglGetPixelFormatAttribfvARB", (PROC)wglGetPixelFormatAttribfvARB},
       {"wglChoosePixelFormatARB",      (PROC)wglChoosePixelFormatARB},
       /* WGL_ARB_render_texture */
       {"wglBindTexImageARB",           (PROC)wglBindTexImageARB},
       {"wglReleaseTexImageARB",        (PROC)wglReleaseTexImageARB},
       {"wglSetPbufferAttribARB",       (PROC)wglSetPbufferAttribARB},
       /* WGL_ARB_pbuffer */
       {"wglCreatePbufferARB",          (PROC)wglCreatePbufferARB},
       {"wglGetPbufferDCARB",           (PROC)wglGetPbufferDCARB},
       {"wglReleasePbufferDCARB",       (PROC)wglReleasePbufferDCARB},
       {"wglDestroyPbufferARB",         (PROC)wglDestroyPbufferARB},
       {"wglQueryPbufferARB",           (PROC)wglQueryPbufferARB},
       {NULL, NULL}
};

GLAPI PROC GLAPIENTRY
wglGetProcAddress (LPCSTR lpszProc)
{
   int i;
   PROC p = (PROC)_glapi_get_proc_address((const char *)lpszProc);

   /* we can't BlendColor. work around buggy applications */
   if (p && strcmp(lpszProc, "glBlendColor")
         && strcmp(lpszProc, "glBlendColorEXT"))
      return p;

   for (i = 0; wgl_ext[i].name; i++) {
      if (!strcmp(lpszProc, wgl_ext[i].name)) {
         return wgl_ext[i].func;
      }
   }

   SetLastError(0);
   return NULL;
}

GLAPI PROC GLAPIENTRY
wglGetDefaultProcAddress (LPCSTR lpszProc)
{
   SetLastError(0);
   return NULL;
}

GLAPI BOOL GLAPIENTRY
wglMakeCurrent (HDC hdc, HGLRC hglrc)
{
   if ((hdc == NULL) && (hglrc == NULL))
      return TRUE;

   if (!ctx || hglrc != (HGLRC)1 || WindowFromDC(hdc) != hWND) {
      SetLastError(0);
      return FALSE;
   }

   hDC = hdc;

   fxMesaMakeCurrent(ctx);

   return TRUE;
}

GLAPI BOOL GLAPIENTRY
wglShareLists (HGLRC hglrc1, HGLRC hglrc2)
{
   if (!ctx || hglrc1 != (HGLRC)1 || hglrc1 != hglrc2) {
      SetLastError(0);
      return FALSE;
   }

   return TRUE;
}

static BOOL
wglUseFontBitmaps_FX (HDC fontDevice, DWORD firstChar, DWORD numChars,
                      DWORD listBase)
{
   TEXTMETRIC metric;
   BITMAPINFO *dibInfo;
   HDC bitDevice;
   COLORREF tempColor;
   int i;

   GetTextMetrics(fontDevice, &metric);

   dibInfo = (BITMAPINFO *)calloc(sizeof(BITMAPINFO) + sizeof(RGBQUAD), 1);
   dibInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
   dibInfo->bmiHeader.biPlanes = 1;
   dibInfo->bmiHeader.biBitCount = 1;
   dibInfo->bmiHeader.biCompression = BI_RGB;

   bitDevice = CreateCompatibleDC(fontDevice);

   /* Swap fore and back colors so the bitmap has the right polarity */
   tempColor = GetBkColor(bitDevice);
   SetBkColor(bitDevice, GetTextColor(bitDevice));
   SetTextColor(bitDevice, tempColor);

   /* Place chars based on base line */
   SetTextAlign(bitDevice, TA_BASELINE);

   for (i = 0; i < (int)numChars; i++) {
      SIZE size;
      char curChar;
      int charWidth, charHeight, bmapWidth, bmapHeight, numBytes, res;
      HBITMAP bitObject;
      HGDIOBJ origBmap;
      unsigned char *bmap;

      curChar = (char)(i + firstChar); /* [koolsmoky] explicit cast */

      /* Find how high/wide this character is */
      GetTextExtentPoint32(bitDevice, &curChar, 1, &size);

      /* Create the output bitmap */
      charWidth = size.cx;
      charHeight = size.cy;
      bmapWidth = ((charWidth + 31) / 32) * 32; /* Round up to the next multiple of 32 bits */
      bmapHeight = charHeight;
      bitObject = CreateCompatibleBitmap(bitDevice, bmapWidth, bmapHeight);
      /*VERIFY(bitObject);*/

      /* Assign the output bitmap to the device */
      origBmap = SelectObject(bitDevice, bitObject);

      PatBlt(bitDevice, 0, 0, bmapWidth, bmapHeight, BLACKNESS);

      /* Use our source font on the device */
      SelectObject(bitDevice, GetCurrentObject(fontDevice, OBJ_FONT));

      /* Draw the character */
      TextOut(bitDevice, 0, metric.tmAscent, &curChar, 1);

      /* Unselect our bmap object */
      SelectObject(bitDevice, origBmap);

      /* Convert the display dependant representation to a 1 bit deep DIB */
      numBytes = (bmapWidth * bmapHeight) / 8;
      bmap = MALLOC(numBytes);
      dibInfo->bmiHeader.biWidth = bmapWidth;
      dibInfo->bmiHeader.biHeight = bmapHeight;
      res = GetDIBits(bitDevice, bitObject, 0, bmapHeight, bmap,
                      dibInfo, DIB_RGB_COLORS);

      /* Create the GL object */
      glNewList(i + listBase, GL_COMPILE);
      glBitmap(bmapWidth, bmapHeight, 0.0, metric.tmDescent,
               charWidth, 0.0, bmap);
      glEndList();
      /* CheckGL(); */

      /* Destroy the bmap object */
      DeleteObject(bitObject);

      /* Deallocate the bitmap data */
      FREE(bmap);
   }

   /* Destroy the DC */
   DeleteDC(bitDevice);

   FREE(dibInfo);

   return TRUE;
}

GLAPI BOOL GLAPIENTRY
wglUseFontBitmapsW (HDC hdc, DWORD first, DWORD count, DWORD listBase)
{
   return FALSE;
}

GLAPI BOOL GLAPIENTRY
wglUseFontOutlinesA (HDC hdc, DWORD first, DWORD count,
                     DWORD listBase, FLOAT deviation,
                     FLOAT extrusion, int format, LPGLYPHMETRICSFLOAT lpgmf)
{
   SetLastError(0);
   return FALSE;
}

GLAPI BOOL GLAPIENTRY
wglUseFontOutlinesW (HDC hdc, DWORD first, DWORD count,
                     DWORD listBase, FLOAT deviation,
                     FLOAT extrusion, int format, LPGLYPHMETRICSFLOAT lpgmf)
{
   SetLastError(0);
   return FALSE;
}


GLAPI BOOL GLAPIENTRY
wglSwapLayerBuffers (HDC hdc, UINT fuPlanes)
{
   if (ctx && WindowFromDC(hdc) == hWND) {
      fxMesaSwapBuffers();

      return TRUE;
   }

   SetLastError(0);
   return FALSE;
}

static int
pfd_tablen (void)
{
   /* we should take an envvar for `fxMesaSelectCurrentBoard' */
   return (fxMesaSelectCurrentBoard(0) < GR_SSTTYPE_Voodoo4)
         ? 2                      /* only 16bit entries */
         : sizeof(pix) / sizeof(pix[0]);  /* full table */
}

GLAPI int GLAPIENTRY
wglChoosePixelFormat (HDC hdc, const PIXELFORMATDESCRIPTOR *ppfd)
{
   int i, best = -1, qt_valid_pix;
   PIXELFORMATDESCRIPTOR pfd = *ppfd;

   qt_valid_pix = pfd_tablen();

#if 1 || QUAKE2 || GORE
   /* QUAKE2: 24+32 */
   /* GORE  : 24+16 */
   if ((pfd.cColorBits == 24) || (pfd.cColorBits == 32)) {
      /* the first 2 entries are 16bit */
      pfd.cColorBits = (qt_valid_pix > 2) ? 32 : 16;
   }
   if (pfd.cColorBits == 32) {
      pfd.cDepthBits = 24;
   } else if (pfd.cColorBits == 16) {
      pfd.cDepthBits = 16;
   }
#endif

   if (pfd.nSize != sizeof(PIXELFORMATDESCRIPTOR) || pfd.nVersion != 1) {
      SetLastError(0);
      return 0;
   }

   for (i = 0; i < qt_valid_pix; i++) {
      if (pfd.cColorBits > 0 && pix[i].pfd.cColorBits != pfd.cColorBits)
         continue;

      if ((pfd.dwFlags & PFD_DRAW_TO_WINDOW)
          && !(pix[i].pfd.dwFlags & PFD_DRAW_TO_WINDOW)) continue;
      if ((pfd.dwFlags & PFD_DRAW_TO_BITMAP)
          && !(pix[i].pfd.dwFlags & PFD_DRAW_TO_BITMAP)) continue;
      if ((pfd.dwFlags & PFD_SUPPORT_GDI)
          && !(pix[i].pfd.dwFlags & PFD_SUPPORT_GDI)) continue;
      if ((pfd.dwFlags & PFD_SUPPORT_OPENGL)
          && !(pix[i].pfd.dwFlags & PFD_SUPPORT_OPENGL)) continue;
      if (!(pfd.dwFlags & PFD_DOUBLEBUFFER_DONTCARE)
          && ((pfd.dwFlags & PFD_DOUBLEBUFFER) !=
              (pix[i].pfd.dwFlags & PFD_DOUBLEBUFFER))) continue;
#if 1 /* Doom3 fails here! */
      if (!(pfd.dwFlags & PFD_STEREO_DONTCARE)
          && ((pfd.dwFlags & PFD_STEREO) !=
              (pix[i].pfd.dwFlags & PFD_STEREO))) continue;
#endif

      if (pfd.cDepthBits > 0 && pix[i].pfd.cDepthBits == 0)
         continue;              /* need depth buffer */

      if (pfd.cAlphaBits > 0 && pix[i].pfd.cAlphaBits == 0)
         continue;              /* need alpha buffer */

#if 0                           /* regression bug? */
      if (pfd.cStencilBits > 0 && pix[i].pfd.cStencilBits == 0)
         continue;              /* need stencil buffer */
#endif

      if (pfd.iPixelType == pix[i].pfd.iPixelType) {
         best = i + 1;
         break;
      }
   }

   if (best == -1) {
      FILE *err = fopen("MESA.LOG", "w");
      if (err != NULL) {
         fprintf(err, "wglChoosePixelFormat failed\n");
         fprintf(err, "\tnSize           = %d\n", ppfd->nSize);
         fprintf(err, "\tnVersion        = %d\n", ppfd->nVersion);
         fprintf(err, "\tdwFlags         = %lu\n", ppfd->dwFlags);
         fprintf(err, "\tiPixelType      = %d\n", ppfd->iPixelType);
         fprintf(err, "\tcColorBits      = %d\n", ppfd->cColorBits);
         fprintf(err, "\tcRedBits        = %d\n", ppfd->cRedBits);
         fprintf(err, "\tcRedShift       = %d\n", ppfd->cRedShift);
         fprintf(err, "\tcGreenBits      = %d\n", ppfd->cGreenBits);
         fprintf(err, "\tcGreenShift     = %d\n", ppfd->cGreenShift);
         fprintf(err, "\tcBlueBits       = %d\n", ppfd->cBlueBits);
         fprintf(err, "\tcBlueShift      = %d\n", ppfd->cBlueShift);
         fprintf(err, "\tcAlphaBits      = %d\n", ppfd->cAlphaBits);
         fprintf(err, "\tcAlphaShift     = %d\n", ppfd->cAlphaShift);
         fprintf(err, "\tcAccumBits      = %d\n", ppfd->cAccumBits);
         fprintf(err, "\tcAccumRedBits   = %d\n", ppfd->cAccumRedBits);
         fprintf(err, "\tcAccumGreenBits = %d\n", ppfd->cAccumGreenBits);
         fprintf(err, "\tcAccumBlueBits  = %d\n", ppfd->cAccumBlueBits);
         fprintf(err, "\tcAccumAlphaBits = %d\n", ppfd->cAccumAlphaBits);
         fprintf(err, "\tcDepthBits      = %d\n", ppfd->cDepthBits);
         fprintf(err, "\tcStencilBits    = %d\n", ppfd->cStencilBits);
         fprintf(err, "\tcAuxBuffers     = %d\n", ppfd->cAuxBuffers);
         fprintf(err, "\tiLayerType      = %d\n", ppfd->iLayerType);
         fprintf(err, "\tbReserved       = %d\n", ppfd->bReserved);
         fprintf(err, "\tdwLayerMask     = %lu\n", ppfd->dwLayerMask);
         fprintf(err, "\tdwVisibleMask   = %lu\n", ppfd->dwVisibleMask);
         fprintf(err, "\tdwDamageMask    = %lu\n", ppfd->dwDamageMask);
         fclose(err);
      }

      SetLastError(0);
      return 0;
   }

   return best;
}

GLAPI int GLAPIENTRY
ChoosePixelFormat (HDC hdc, const PIXELFORMATDESCRIPTOR *ppfd)
{

   return wglChoosePixelFormat(hdc, ppfd);
}

GLAPI int GLAPIENTRY
wglDescribePixelFormat (HDC hdc, int iPixelFormat, UINT nBytes,
                        LPPIXELFORMATDESCRIPTOR ppfd)
{
   int qt_valid_pix;

   qt_valid_pix = pfd_tablen();

   if (iPixelFormat < 1 || iPixelFormat > qt_valid_pix ||
       ((nBytes != sizeof(PIXELFORMATDESCRIPTOR)) && (nBytes != 0))) {
      SetLastError(0);
      return qt_valid_pix;
   }

   if (nBytes != 0)
      *ppfd = pix[iPixelFormat - 1].pfd;

   return qt_valid_pix;
}

GLAPI int GLAPIENTRY
DescribePixelFormat (HDC hdc, int iPixelFormat, UINT nBytes,
                     LPPIXELFORMATDESCRIPTOR ppfd)
{
   return wglDescribePixelFormat(hdc, iPixelFormat, nBytes, ppfd);
}

GLAPI int GLAPIENTRY
wglGetPixelFormat (HDC hdc)
{
   if (curPFD == 0) {
      SetLastError(0);
      return 0;
   }

   return curPFD;
}

GLAPI int GLAPIENTRY
GetPixelFormat (HDC hdc)
{
   return wglGetPixelFormat(hdc);
}

GLAPI BOOL GLAPIENTRY
wglSetPixelFormat (HDC hdc, int iPixelFormat, const PIXELFORMATDESCRIPTOR *ppfd)
{
   int qt_valid_pix;

   qt_valid_pix = pfd_tablen();

   if (iPixelFormat < 1 || iPixelFormat > qt_valid_pix) {
      if (ppfd == NULL) {
         PIXELFORMATDESCRIPTOR my_pfd;
         if (!wglDescribePixelFormat(hdc, iPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &my_pfd)) {
            SetLastError(0);
            return FALSE;
         }
      } else if (ppfd->nSize != sizeof(PIXELFORMATDESCRIPTOR)) {
         SetLastError(0);
         return FALSE;
      }
   }
   curPFD = iPixelFormat;

   return TRUE;
}

GLAPI BOOL GLAPIENTRY
wglSwapBuffers (HDC hdc)
{
   if (!ctx) {
      SetLastError(0);
      return FALSE;
   }

   fxMesaSwapBuffers();

   return TRUE;
}

GLAPI BOOL GLAPIENTRY
SetPixelFormat (HDC hdc, int iPixelFormat, const PIXELFORMATDESCRIPTOR *ppfd)
{
   return wglSetPixelFormat(hdc, iPixelFormat, ppfd);
}

GLAPI BOOL GLAPIENTRY
SwapBuffers(HDC hdc)
{
   return wglSwapBuffers(hdc);
}

static FIXED
FixedFromDouble (double d)
{
   struct {
      FIXED f;
      long l;
   } pun;
   pun.l = (long)(d * 65536L);
   return pun.f;
}

/*
** This was yanked from windows/gdi/wgl.c
*/
GLAPI BOOL GLAPIENTRY
wglUseFontBitmapsA (HDC hdc, DWORD first, DWORD count, DWORD listBase)
{
   int i;
   GLuint font_list;
   DWORD size;
   GLYPHMETRICS gm;
   HANDLE hBits;
   LPSTR lpBits;
   MAT2 mat;
   int success = TRUE;

   font_list = listBase;

   mat.eM11 = FixedFromDouble(1);
   mat.eM12 = FixedFromDouble(0);
   mat.eM21 = FixedFromDouble(0);
   mat.eM22 = FixedFromDouble(-1);

   memset(&gm, 0, sizeof(gm));

   /*
    ** If we can't get the glyph outline, it may be because this is a fixed
    ** font.  Try processing it that way.
    */
   if (GetGlyphOutline(hdc, first, GGO_BITMAP, &gm, 0, NULL, &mat) == GDI_ERROR) {
      return wglUseFontBitmaps_FX(hdc, first, count, listBase);
   }

   /*
    ** Otherwise process all desired characters.
    */
   for (i = 0; i < count; i++) {
      DWORD err;

      glNewList(font_list + i, GL_COMPILE);

      /* allocate space for the bitmap/outline */
      size = GetGlyphOutline(hdc, first + i, GGO_BITMAP, &gm, 0, NULL, &mat);
      if (size == GDI_ERROR) {
         glEndList();
         err = GetLastError();
         success = FALSE;
         continue;
      }

      hBits = GlobalAlloc(GHND, size + 1);
      lpBits = GlobalLock(hBits);

      err = GetGlyphOutline(hdc,        /* handle to device context */
                            first + i,  /* character to query */
                            GGO_BITMAP, /* format of data to return */
                            &gm,        /* pointer to structure for metrics */
                            size,       /* size of buffer for data */
                            lpBits,     /* pointer to buffer for data */
                            &mat        /* pointer to transformation */
                                        /* matrix structure */
          );

      if (err == GDI_ERROR) {
         GlobalUnlock(hBits);
         GlobalFree(hBits);

         glEndList();
         err = GetLastError();
         success = FALSE;
         continue;
      }

      glBitmap(gm.gmBlackBoxX, gm.gmBlackBoxY,
               -gm.gmptGlyphOrigin.x,
               gm.gmptGlyphOrigin.y,
               gm.gmCellIncX, gm.gmCellIncY,
               (const GLubyte *)lpBits);

      GlobalUnlock(hBits);
      GlobalFree(hBits);

      glEndList();
   }

   return success;
}

GLAPI BOOL GLAPIENTRY
wglDescribeLayerPlane (HDC hdc, int iPixelFormat, int iLayerPlane,
                       UINT nBytes, LPLAYERPLANEDESCRIPTOR ppfd)
{
   SetLastError(0);
   return FALSE;
}

GLAPI int GLAPIENTRY
wglGetLayerPaletteEntries (HDC hdc, int iLayerPlane, int iStart,
                           int cEntries, COLORREF *pcr)
{
   SetLastError(0);
   return FALSE;
}

GLAPI BOOL GLAPIENTRY
wglRealizeLayerPalette (HDC hdc, int iLayerPlane, BOOL bRealize)
{
   SetLastError(0);
   return FALSE;
}

GLAPI int GLAPIENTRY
wglSetLayerPaletteEntries (HDC hdc, int iLayerPlane, int iStart,
                           int cEntries, CONST COLORREF *pcr)
{
   SetLastError(0);
   return FALSE;
}


/***************************************************************************
 * [dBorca] simplistic ICD implementation, based on ICD code by Gregor Anich
 */

typedef struct _icdTable {
   DWORD size;
   PROC table[336];
} ICDTABLE, *PICDTABLE;

#ifdef USE_MGL_NAMESPACE
#define GL_FUNC(func) mgl##func
#else
#define GL_FUNC(func) gl##func
#endif

static ICDTABLE icdTable = { 336, {
#define ICD_ENTRY(func) (PROC)GL_FUNC(func),
#include "../icd/icdlist.h"
#undef ICD_ENTRY
} };


GLAPI BOOL GLAPIENTRY
DrvCopyContext (HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask)
{
   return wglCopyContext(hglrcSrc, hglrcDst, mask);
}


GLAPI HGLRC GLAPIENTRY
DrvCreateContext (HDC hdc)
{
   return wglCreateContext(hdc);
}


GLAPI BOOL GLAPIENTRY
DrvDeleteContext (HGLRC hglrc)
{
   return wglDeleteContext(hglrc);
}


GLAPI HGLRC GLAPIENTRY
DrvCreateLayerContext (HDC hdc, int iLayerPlane)
{
   return wglCreateContext(hdc);
}


GLAPI PICDTABLE GLAPIENTRY
DrvSetContext (HDC hdc, HGLRC hglrc, void *callback)
{
   return wglMakeCurrent(hdc, hglrc) ? &icdTable : NULL;
}


GLAPI BOOL GLAPIENTRY
DrvReleaseContext (HGLRC hglrc)
{
   return TRUE;
}


GLAPI BOOL GLAPIENTRY
DrvShareLists (HGLRC hglrc1, HGLRC hglrc2)
{
   return wglShareLists(hglrc1, hglrc2);
}


GLAPI BOOL GLAPIENTRY
DrvDescribeLayerPlane (HDC hdc, int iPixelFormat,
                       int iLayerPlane, UINT nBytes,
                       LPLAYERPLANEDESCRIPTOR plpd)
{
   return wglDescribeLayerPlane(hdc, iPixelFormat, iLayerPlane, nBytes, plpd);
}


GLAPI int GLAPIENTRY
DrvSetLayerPaletteEntries (HDC hdc, int iLayerPlane,
                           int iStart, int cEntries, CONST COLORREF *pcr)
{
   return wglSetLayerPaletteEntries(hdc, iLayerPlane, iStart, cEntries, pcr);
}


GLAPI int GLAPIENTRY
DrvGetLayerPaletteEntries (HDC hdc, int iLayerPlane,
                           int iStart, int cEntries, COLORREF *pcr)
{
   return wglGetLayerPaletteEntries(hdc, iLayerPlane, iStart, cEntries, pcr);
}


GLAPI BOOL GLAPIENTRY
DrvRealizeLayerPalette (HDC hdc, int iLayerPlane, BOOL bRealize)
{
   return wglRealizeLayerPalette(hdc, iLayerPlane, bRealize);
}


GLAPI BOOL GLAPIENTRY
DrvSwapLayerBuffers (HDC hdc, UINT fuPlanes)
{
   return wglSwapLayerBuffers(hdc, fuPlanes);
}

GLAPI int GLAPIENTRY
DrvDescribePixelFormat (HDC hdc, int iPixelFormat, UINT nBytes,
                        LPPIXELFORMATDESCRIPTOR ppfd)
{
   return wglDescribePixelFormat(hdc, iPixelFormat, nBytes, ppfd);
}


GLAPI PROC GLAPIENTRY
DrvGetProcAddress (LPCSTR lpszProc)
{
   return wglGetProcAddress(lpszProc);
}


GLAPI BOOL GLAPIENTRY
DrvSetPixelFormat (HDC hdc, int iPixelFormat)
{
   return wglSetPixelFormat(hdc, iPixelFormat, NULL);
}


GLAPI BOOL GLAPIENTRY
DrvSwapBuffers (HDC hdc)
{
   return wglSwapBuffers(hdc);
}


GLAPI BOOL GLAPIENTRY
DrvValidateVersion (DWORD version)
{
   (void)version;
   return TRUE;
}


#if (_MSC_VER >= 1200)
#pragma warning( pop )
#endif

#endif /* FX */