path: root/src/mesa/drivers/glide/fxwgl.c

/* $Id: fxwgl.c,v 1.16 2002/10/24 23:57:23 brianp Exp $ */

/*
 * 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
 */

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


#ifdef __WIN32__

#ifdef __cplusplus
extern "C"
{
#endif

#include <windows.h>
#include "glheader.h"
#include "fxdrv.h"
#include "glapi.h"

#ifdef __cplusplus
}
#endif

#include <stdio.h>
#include "GL/fxmesa.h"

#define MAX_MESA_ATTRS  20

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

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

WINGDIAPI void GLAPIENTRY gl3DfxSetPaletteEXT(GLuint *);

struct __pixelformat__ pix[] = {
   /* None */
   {
    {
     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, 0, 24,
     0, 0, 0, 0, 0,
     0,
     0,
     0,
     PFD_MAIN_PLANE,
     0, 0, 0, 0}
    ,
    {
     FXMESA_DOUBLEBUFFER,
     FXMESA_ALPHA_SIZE, 0,
     FXMESA_DEPTH_SIZE, 0,
     FXMESA_STENCIL_SIZE, 0,
     FXMESA_ACCUM_SIZE, 0,
     FXMESA_NONE}
    }
   ,

   /* Alpha */
   {
    {
     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,
     0,
     0,
     0,
     PFD_MAIN_PLANE,
     0, 0, 0, 0}
    ,
    {
     FXMESA_DOUBLEBUFFER,
     FXMESA_ALPHA_SIZE, 8,
     FXMESA_DEPTH_SIZE, 0,
     FXMESA_STENCIL_SIZE, 0,
     FXMESA_ACCUM_SIZE, 0,
     FXMESA_NONE}
    }
   ,

   /* 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, 0, 24,
     0, 0, 0, 0, 0,
     16,
     0,
     0,
     PFD_MAIN_PLANE,
     0, 0, 0, 0}
    ,
    {
     FXMESA_DOUBLEBUFFER,
     FXMESA_ALPHA_SIZE, 0,
     FXMESA_DEPTH_SIZE, 16,
     FXMESA_STENCIL_SIZE, 0,
     FXMESA_ACCUM_SIZE, 0,
     FXMESA_NONE}
    }
};
static int qt_pix = sizeof(pix) / sizeof(pix[0]);

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 */

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

LONG GLAPIENTRY
__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 (wParam != SIZE_MINIMIZED) {
	    static int moving = 0;
	    if (!moving) {
	       if (fxQueryHardware() != GR_SSTTYPE_VOODOO) {
		  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 */
	       FX_grClipWindow(0, 0, FX_grSstScreenWidth(),
			       FX_grSstScreenHeight());
	       /* And let the new size set in the context */
	       fxMesaUpdateScreenSize(ctx);
	    }
	 }
	 break;
      case WM_ACTIVATE:
	 if ((fxQueryHardware() == GR_SSTTYPE_VOODOO) &&
	     (!gdiWindowHack) && (!haveDualHead)) {
	    WORD fActive = LOWORD(wParam);
	    BOOL fMinimized = (BOOL) HIWORD(wParam);

	    if ((fActive == WA_INACTIVE) || fMinimized)
	       FX_grSstControl(GR_CONTROL_DEACTIVATE);
	    else
	       FX_grSstControl(GR_CONTROL_ACTIVATE);
	 }
	 break;
      case WM_SHOWWINDOW:
	 break;
      case WM_SYSKEYDOWN:
      case WM_SYSCHAR:
	 if (gdiWindowHackEna && (VK_RETURN == wParam)) {
	    if (gdiWindowHack) {
	       gdiWindowHack = GL_FALSE;
	       FX_grSstControl(GR_CONTROL_ACTIVATE);
	    }
	    else {
	       gdiWindowHack = GL_TRUE;
	       FX_grSstControl(GR_CONTROL_DEACTIVATE);
	    }
	 }
	 break;
      }
   }

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

   return (ret);
}

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

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) {
      SetLastError(0);
      return (NULL);
   }

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

#ifndef FX_SILENT
   freopen("MESA.LOG", "w", stderr);
#endif

   ShowWindow(hWnd, SW_SHOWNORMAL);
   SetForegroundWindow(hWnd);
   Sleep(100);			/* an hack for win95 */

   if (fxQueryHardware() == GR_SSTTYPE_VOODOO) {
      RECT cliRect;

      GetClientRect(hWnd, &cliRect);
      error = !(ctx =
		fxMesaCreateBestContext((GLuint) hWnd, cliRect.right,
					cliRect.bottom,
					pix[curPFD - 1].mesaAttr));

      if (!error) {
	 /* create the DIB section for windowed rendering */
	 DWORD *p;

	 dibWnd = hWnd;

	 hDC = GetDC(dibWnd);

	 dibBMI =
	    (BITMAPINFO *) MALLOC(sizeof(BITMAPINFO) +
				  (256 * sizeof(RGBQUAD)));

	 memset(dibBMI, 0, sizeof(BITMAPINFO) + (256 * sizeof(RGBQUAD)));

	 dibBMI->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	 dibBMI->bmiHeader.biWidth = ctx->width;
	 dibBMI->bmiHeader.biHeight = -ctx->height;
	 dibBMI->bmiHeader.biPlanes = (short) 1;
	 dibBMI->bmiHeader.biBitCount = (short) 16;
	 dibBMI->bmiHeader.biCompression = BI_BITFIELDS;
	 dibBMI->bmiHeader.biSizeImage = 0;
	 dibBMI->bmiHeader.biXPelsPerMeter = 0;
	 dibBMI->bmiHeader.biYPelsPerMeter = 0;
	 dibBMI->bmiHeader.biClrUsed = 3;
	 dibBMI->bmiHeader.biClrImportant = 3;

	 p = (DWORD *) dibBMI->bmiColors;
	 p[0] = 0xF800;
	 p[1] = 0x07E0;
	 p[2] = 0x001F;

	 dibHBM =
	    CreateDIBSection(hDC, dibBMI, DIB_RGB_COLORS, &dibSurfacePtr,
			     NULL, 0);

	 ReleaseDC(dibWnd, hDC);

	 gdiWindowHackEna = (dibHBM != NULL ? GL_TRUE : GL_FALSE);

	 if (!getenv("MESA_WGL_FX")
	     || !strcmp(getenv("MESA_WGL_FX"), "fullscreen"))
	    gdiWindowHack = GL_FALSE;
	 else {
	    gdiWindowHack = GL_TRUE;
	    FX_grSstControl(GR_CONTROL_DEACTIVATE);
	 }
      }
   }
   else {
      /* For the Voodoo Rush */

      if (getenv("MESA_WGL_FX")
	  && !strcmp(getenv("MESA_WGL_FX"), "fullscreen")) {
	 RECT cliRect;

	 GetClientRect(hWnd, &cliRect);
	 error = !(ctx =
		   fxMesaCreateBestContext((GLuint) hWnd, cliRect.right,
					   cliRect.bottom,
					   pix[curPFD - 1].mesaAttr));
      }
      else
	 error = !(ctx =
		   fxMesaCreateContext((GLuint) hWnd, GR_RESOLUTION_NONE,
				       GR_REFRESH_75Hz,
				       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);
}

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

BOOL GLAPIENTRY
wglDeleteContext(HGLRC hglrc)
{
   if (ctx && hglrc == (HGLRC) 1) {
      if (gdiWindowHackEna) {
	 DeleteObject(dibHBM);
	 FREE(dibBMI);

	 dibSurfacePtr = NULL;
	 dibBMI = NULL;
	 dibHBM = NULL;
	 dibWnd = NULL;
      }

      fxMesaDestroyContext(ctx);

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

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

   SetLastError(0);

   return (FALSE);
}

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

   SetLastError(0);
   return (NULL);
}

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

   SetLastError(0);
   return (NULL);
}

PROC GLAPIENTRY
wglGetProcAddress(LPCSTR lpszProc)
{
   PROC p = (PROC) _glapi_get_proc_address((const char *) lpszProc);
   if (p)
      return p;

   SetLastError(0);
   return (NULL);
}

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);
}

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

   return (TRUE);
}

BOOL GLAPIENTRY
wglUseFontBitmaps(HDC fontDevice, DWORD firstChar, DWORD numChars,
		  DWORD listBase)
{
#define VERIFY(a) a

   TEXTMETRIC metric;
   BITMAPINFO *dibInfo;
   HDC bitDevice;
   COLORREF tempColor;
   int i;

   VERIFY(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);
   // HDC bitDevice = CreateDC("DISPLAY", NULL, NULL, NULL);
   // VERIFY(bitDevice);

   // 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
   VERIFY(SetTextAlign(bitDevice, TA_BASELINE) >= 0 ? 1 : 0);

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

      curChar = i + firstChar;

      // Find how high/wide this character is
      VERIFY(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);
      VERIFY(origBmap);

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

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

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

      // Unselect our bmap object
      VERIFY(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);
      //VERIFY(res);

      // 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
   VERIFY(DeleteDC(bitDevice));

   FREE(dibInfo);

   return TRUE;
#undef VERIFY
}

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

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

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


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

      return (TRUE);
   }

   SetLastError(0);
   return (FALSE);
}

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

   qt_valid_pix = qt_pix;

   if (ppfd->nSize != sizeof(PIXELFORMATDESCRIPTOR) || ppfd->nVersion != 1) {
      SetLastError(0);
      return (0);
   }

   for (i = 0; i < qt_valid_pix; i++) {
      if ((ppfd->dwFlags & PFD_DRAW_TO_WINDOW)
	  && !(pix[i].pfd.dwFlags & PFD_DRAW_TO_WINDOW)) continue;
      if ((ppfd->dwFlags & PFD_DRAW_TO_BITMAP)
	  && !(pix[i].pfd.dwFlags & PFD_DRAW_TO_BITMAP)) continue;
      if ((ppfd->dwFlags & PFD_SUPPORT_GDI)
	  && !(pix[i].pfd.dwFlags & PFD_SUPPORT_GDI)) continue;
      if ((ppfd->dwFlags & PFD_SUPPORT_OPENGL)
	  && !(pix[i].pfd.dwFlags & PFD_SUPPORT_OPENGL)) continue;
      if (!(ppfd->dwFlags & PFD_DOUBLEBUFFER_DONTCARE)
	  && ((ppfd->dwFlags & PFD_DOUBLEBUFFER) !=
	      (pix[i].pfd.dwFlags & PFD_DOUBLEBUFFER))) continue;
      if (!(ppfd->dwFlags & PFD_STEREO_DONTCARE)
	  && ((ppfd->dwFlags & PFD_STEREO) !=
	      (pix[i].pfd.dwFlags & PFD_STEREO))) continue;

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

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

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

   if (best == -1) {
      SetLastError(0);
      return (0);
   }

   return (best);
}

int GLAPIENTRY
ChoosePixelFormat(HDC hdc, CONST PIXELFORMATDESCRIPTOR * ppfd)
{
   return wglChoosePixelFormat(hdc, ppfd);
}

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

   qt_valid_pix = qt_pix;

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

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

   return (qt_valid_pix);
}

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

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

   return (curPFD);
}

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

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

   qt_valid_pix = qt_pix;

   if (iPixelFormat < 1 || iPixelFormat > qt_valid_pix
       || ppfd->nSize != sizeof(PIXELFORMATDESCRIPTOR)) {
      SetLastError(0);
      return (FALSE);
   }
   curPFD = iPixelFormat;

   return (TRUE);
}

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

   fxMesaSwapBuffers();

   if (gdiWindowHack) {
      GLuint width = ctx->width;
      GLuint height = ctx->height;

      HDC hdcScreen = GetDC(dibWnd);
      HDC hdcDIBSection = CreateCompatibleDC(hdcScreen);
      HBITMAP holdBitmap = (HBITMAP) SelectObject(hdcDIBSection, dibHBM);

      FX_grLfbReadRegion(GR_BUFFER_FRONTBUFFER, 0, 0,
			 width, height, width * 2, dibSurfacePtr);

      /* Since the hardware is configured for GR_COLORFORMAT_ABGR the pixel data is
       * going to come out as BGR 565, which is reverse of what we need for blitting
       * to screen, so we need to convert it here pixel-by-pixel (ick). This loop would NOT
       * be required if the color format was changed to GR_COLORFORMAT_ARGB, but I do
       * not know the ramifications of that, so this will work until that is resolved.
       *
       * This routine CRIES out for MMX implementation, however since that's not
       * guaranteed to be running on MMX enabled hardware so I'm not going to do
       * that. I'm just going to try to make a reasonably efficient C
       * version. -TAJ
       *
       * This routine drops frame rate by <1 fps on a 200Mhz MMX processor with a 640x480
       * display. Obviously, it's performance hit will be higher on larger displays and
       * less on smaller displays. To support the window-hack display this is probably fine.
       */
#if  FXMESA_USE_ARGB
      {
	 unsigned long *pixel = dibSurfacePtr;
	 unsigned long count = (width * height) / 2;

	 while (count--) {
	    *pixel++ = (*pixel & 0x07e007e0)	/* greens */
	       |((*pixel & 0xf800f800) >> 11)	/* swap blues */
	       |((*pixel & 0x001f001f) << 11)	/* swap reds */
	       ;
	 }
      }
#endif

      BitBlt(hdcScreen, 0, 0, width, height, hdcDIBSection, 0, 0, SRCCOPY);

      ReleaseDC(dibWnd, hdcScreen);
      SelectObject(hdcDIBSection, holdBitmap);
      DeleteDC(hdcDIBSection);
   }

   return (TRUE);
}

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

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

#endif /* FX */