-/* $Id: wgl.c,v 1.8 2001/09/14 22:19:19 brianp Exp $ */\r
-\r
-/*\r
-* This library is free software; you can redistribute it and/or\r
-* modify it under the terms of the GNU Library General Public\r
-* License as published by the Free Software Foundation; either\r
-* version 2 of the License, or (at your option) any later version.\r
-*\r
-* This library is distributed in the hope that it will be useful,\r
-* but WITHOUT ANY WARRANTY; without even the implied warranty of\r
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\r
-* Library General Public License for more details.\r
-*\r
-* You should have received a copy of the GNU Library General Public\r
-* License along with this library; if not, write to the Free\r
-* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\r
-*\r
-*/\r
-\r
-/*\r
-* File name : wgl.c\r
-* WGL stuff. Added by Oleg Letsinsky, ajl@ultersys.ru\r
-* Some things originated from the 3Dfx WGL functions\r
-*/\r
-\r
-#ifdef WIN32\r
-\r
-#ifdef __cplusplus\r
-extern "C" {\r
-#endif\r
-\r
-#include <windows.h>\r
-#define GL_GLEXT_PROTOTYPES\r
-#include <GL/gl.h>\r
-#include <GL/glext.h>\r
-//#include <GL/glu.h>\r
-\r
-#ifdef __cplusplus\r
-}\r
-#endif\r
-\r
-#include <stdio.h>\r
-#include <tchar.h>\r
-#include "wmesadef.h"\r
-#include "GL/wmesa.h"\r
-#include "mtypes.h"\r
-\r
-#define MAX_MESA_ATTRS 20\r
-\r
-struct __extensions__\r
-{\r
- PROC proc;\r
- char *name;\r
-};\r
-\r
-struct __pixelformat__\r
-{\r
- PIXELFORMATDESCRIPTOR pfd;\r
- GLboolean doubleBuffered;\r
-};\r
-\r
-struct __extensions__ ext[] = {\r
-\r
-#ifdef GL_EXT_polygon_offset\r
- { (PROC)glPolygonOffsetEXT, "glPolygonOffsetEXT" },\r
-#endif\r
- { (PROC)glBlendEquationEXT, "glBlendEquationEXT" },\r
- { (PROC)glBlendColorEXT, "glBlendColorExt" },\r
- { (PROC)glVertexPointerEXT, "glVertexPointerEXT" },\r
- { (PROC)glNormalPointerEXT, "glNormalPointerEXT" },\r
- { (PROC)glColorPointerEXT, "glColorPointerEXT" },\r
- { (PROC)glIndexPointerEXT, "glIndexPointerEXT" },\r
- { (PROC)glTexCoordPointerEXT, "glTexCoordPointer" },\r
- { (PROC)glEdgeFlagPointerEXT, "glEdgeFlagPointerEXT" },\r
- { (PROC)glGetPointervEXT, "glGetPointervEXT" },\r
- { (PROC)glArrayElementEXT, "glArrayElementEXT" },\r
- { (PROC)glDrawArraysEXT, "glDrawArrayEXT" },\r
- { (PROC)glAreTexturesResidentEXT, "glAreTexturesResidentEXT" },\r
- { (PROC)glBindTextureEXT, "glBindTextureEXT" },\r
- { (PROC)glDeleteTexturesEXT, "glDeleteTexturesEXT" },\r
- { (PROC)glGenTexturesEXT, "glGenTexturesEXT" },\r
- { (PROC)glIsTextureEXT, "glIsTextureEXT" },\r
- { (PROC)glPrioritizeTexturesEXT, "glPrioritizeTexturesEXT" },\r
- { (PROC)glCopyTexSubImage3DEXT, "glCopyTexSubImage3DEXT" },\r
- { (PROC)glTexImage3DEXT, "glTexImage3DEXT" },\r
- { (PROC)glTexSubImage3DEXT, "glTexSubImage3DEXT" },\r
- { (PROC)glColorTableEXT, "glColorTableEXT" },\r
- { (PROC)glColorSubTableEXT, "glColorSubTableEXT" },\r
- { (PROC)glGetColorTableEXT, "glGetColorTableEXT" },\r
- { (PROC)glGetColorTableParameterfvEXT, "glGetColorTableParameterfvEXT" },\r
- { (PROC)glGetColorTableParameterivEXT, "glGetColorTableParameterivEXT" },\r
- { (PROC)glPointParameterfEXT, "glPointParameterfEXT" },\r
- { (PROC)glPointParameterfvEXT, "glPointParameterfvEXT" },\r
- { (PROC)glBlendFuncSeparateEXT, "glBlendFuncSeparateEXT" },\r
- { (PROC)glLockArraysEXT, "glLockArraysEXT" },\r
- { (PROC)glUnlockArraysEXT, "glUnlockArraysEXT" }\r
-};\r
-\r
-int qt_ext = sizeof(ext) / sizeof(ext[0]);\r
-\r
-struct __pixelformat__ pix[] =\r
-{\r
- { { sizeof(PIXELFORMATDESCRIPTOR), 1,\r
- PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|PFD_GENERIC_FORMAT|PFD_DOUBLEBUFFER|PFD_SWAP_COPY,\r
- PFD_TYPE_RGBA,\r
- 24, 8, 0, 8, 8, 8, 16, 8, 24,\r
- 0, 0, 0, 0, 0, 16, 8, 0, 0, 0, 0, 0, 0 },\r
- GL_TRUE\r
- },\r
- { { sizeof(PIXELFORMATDESCRIPTOR), 1,\r
- PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|PFD_GENERIC_FORMAT,\r
- PFD_TYPE_RGBA,\r
- 24, 8, 0, 8, 8, 8, 16, 8, 24,\r
- 0, 0, 0, 0, 0, 16, 8, 0, 0, 0, 0, 0, 0 },\r
- GL_FALSE\r
- },\r
-};\r
-\r
-int qt_pix = sizeof(pix) / sizeof(pix[0]);\r
-\r
-typedef struct {\r
- WMesaContext ctx;\r
- HDC hdc;\r
-} MesaWglCtx;\r
-\r
-#define MESAWGL_CTX_MAX_COUNT 20\r
-\r
-static MesaWglCtx wgl_ctx[MESAWGL_CTX_MAX_COUNT];\r
-\r
-static unsigned ctx_count = 0;\r
-static unsigned ctx_current = -1;\r
-static unsigned curPFD = 0;\r
-\r
-WGLAPI BOOL GLAPIENTRY wglCopyContext(HGLRC hglrcSrc,HGLRC hglrcDst,UINT mask)\r
-{\r
- return(FALSE);\r
-}\r
-\r
-WGLAPI HGLRC GLAPIENTRY wglCreateContext(HDC hdc)\r
-{\r
- HWND hWnd;\r
- int i = 0;\r
- if(!(hWnd = WindowFromDC(hdc)))\r
- {\r
- SetLastError(0);\r
- return(NULL);\r
- }\r
- if (!ctx_count)\r
- {\r
- for(i=0;i<MESAWGL_CTX_MAX_COUNT;i++)\r
- {\r
- wgl_ctx[i].ctx = NULL;\r
- wgl_ctx[i].hdc = NULL;\r
- }\r
- }\r
- for( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ )\r
- {\r
- if ( wgl_ctx[i].ctx == NULL )\r
- {\r
- wgl_ctx[i].ctx = WMesaCreateContext( hWnd, NULL, GL_TRUE,\r
- pix[curPFD-1].doubleBuffered );\r
- if (wgl_ctx[i].ctx == NULL)\r
- break;\r
- wgl_ctx[i].hdc = hdc;\r
- ctx_count++;\r
- return ((HGLRC)wgl_ctx[i].ctx);\r
- }\r
- }\r
- SetLastError(0);\r
- return(NULL);\r
-}\r
-\r
-WGLAPI BOOL GLAPIENTRY wglDeleteContext(HGLRC hglrc)\r
-{\r
- int i;\r
- for ( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ )\r
- {\r
- if ( wgl_ctx[i].ctx == (PWMC) hglrc )\r
- {\r
- WMesaMakeCurrent((PWMC) hglrc);\r
- WMesaDestroyContext();\r
- wgl_ctx[i].ctx = NULL;\r
- wgl_ctx[i].hdc = NULL;\r
- ctx_count--;\r
- return(TRUE);\r
- }\r
- }\r
- SetLastError(0);\r
- return(FALSE);\r
-}\r
-\r
-WGLAPI HGLRC GLAPIENTRY wglCreateLayerContext(HDC hdc,int iLayerPlane)\r
-{\r
- SetLastError(0);\r
- return(NULL);\r
-}\r
-\r
-WGLAPI HGLRC GLAPIENTRY wglGetCurrentContext(VOID)\r
-{\r
- if (ctx_current < 0)\r
- return 0;\r
- else\r
- return (HGLRC) wgl_ctx[ctx_current].ctx;\r
-}\r
-\r
-WGLAPI HDC GLAPIENTRY wglGetCurrentDC(VOID)\r
-{\r
- if (ctx_current < 0)\r
- return 0;\r
- else\r
- return wgl_ctx[ctx_current].hdc;\r
-}\r
-\r
-WGLAPI BOOL GLAPIENTRY wglMakeCurrent(HDC hdc,HGLRC hglrc)\r
-{\r
- int i;\r
-\r
- /* new code suggested by Andy Sy */\r
- if (!hdc || !hglrc) {\r
- WMesaMakeCurrent(NULL);\r
- ctx_current = -1;\r
- return TRUE;\r
- }\r
-\r
- for ( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ )\r
- {\r
- if ( wgl_ctx[i].ctx == (PWMC) hglrc )\r
- {\r
- wgl_ctx[i].hdc = hdc;\r
- WMesaMakeCurrent( (WMesaContext) hglrc );\r
- ctx_current = i;\r
- return TRUE;\r
- }\r
- }\r
- return FALSE;\r
-}\r
-\r
-WGLAPI BOOL GLAPIENTRY wglShareLists(HGLRC hglrc1,HGLRC hglrc2)\r
-{\r
- return(TRUE);\r
-}\r
-\r
-\r
-static FIXED FixedFromDouble(double d)\r
-{\r
- long l = (long) (d * 65536L);\r
- return *(FIXED *)&l;\r
-}\r
-\r
-\r
-/*\r
-** This is cribbed from FX/fxwgl.c, and seems to implement support\r
-** for bitmap fonts where the wglUseFontBitmapsA() code implements\r
-** support for outline fonts. In combination they hopefully give\r
-** fairly generic support for fonts.\r
-*/\r
-static BOOL wglUseFontBitmaps_FX(HDC fontDevice, DWORD firstChar,\r
- DWORD numChars, DWORD listBase)\r
-{\r
-#define VERIFY(a) a\r
-\r
- TEXTMETRIC metric;\r
- BITMAPINFO *dibInfo;\r
- HDC bitDevice;\r
- COLORREF tempColor;\r
- int i;\r
-\r
- VERIFY(GetTextMetrics(fontDevice, &metric));\r
-\r
- dibInfo = (BITMAPINFO *) calloc(sizeof(BITMAPINFO) + sizeof(RGBQUAD), 1);\r
- dibInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);\r
- dibInfo->bmiHeader.biPlanes = 1;\r
- dibInfo->bmiHeader.biBitCount = 1;\r
- dibInfo->bmiHeader.biCompression = BI_RGB;\r
-\r
- bitDevice = CreateCompatibleDC(fontDevice);\r
- // HDC bitDevice = CreateDC("DISPLAY", NULL, NULL, NULL);\r
- // VERIFY(bitDevice);\r
-\r
- // Swap fore and back colors so the bitmap has the right polarity\r
- tempColor = GetBkColor(bitDevice);\r
- SetBkColor(bitDevice, GetTextColor(bitDevice));\r
- SetTextColor(bitDevice, tempColor);\r
-\r
- // Place chars based on base line\r
- VERIFY(SetTextAlign(bitDevice, TA_BASELINE) >= 0 ? 1 : 0);\r
-\r
- for(i = 0; i < numChars; i++) {\r
- SIZE size;\r
- char curChar;\r
- int charWidth,charHeight,bmapWidth,bmapHeight,numBytes,res;\r
- HBITMAP bitObject;\r
- HGDIOBJ origBmap;\r
- unsigned char *bmap;\r
-\r
- curChar = i + firstChar;\r
-\r
- // Find how high/wide this character is\r
- VERIFY(GetTextExtentPoint32(bitDevice, &curChar, 1, &size));\r
-\r
- // Create the output bitmap\r
- charWidth = size.cx;\r
- charHeight = size.cy;\r
- bmapWidth = ((charWidth + 31) / 32) * 32; // Round up to the next multiple of 32 bits\r
- bmapHeight = charHeight;\r
- bitObject = CreateCompatibleBitmap(bitDevice,\r
- bmapWidth,\r
- bmapHeight);\r
- //VERIFY(bitObject);\r
-\r
- // Assign the output bitmap to the device\r
- origBmap = SelectObject(bitDevice, bitObject);\r
- VERIFY(origBmap);\r
-\r
- VERIFY( PatBlt( bitDevice, 0, 0, bmapWidth, bmapHeight,BLACKNESS ) );\r
-\r
- // Use our source font on the device\r
- VERIFY(SelectObject(bitDevice, GetCurrentObject(fontDevice,OBJ_FONT)));\r
-\r
- // Draw the character\r
- VERIFY(TextOut(bitDevice, 0, metric.tmAscent, &curChar, 1));\r
-\r
- // Unselect our bmap object\r
- VERIFY(SelectObject(bitDevice, origBmap));\r
-\r
- // Convert the display dependant representation to a 1 bit deep DIB\r
- numBytes = (bmapWidth * bmapHeight) / 8;\r
- bmap = malloc(numBytes);\r
- dibInfo->bmiHeader.biWidth = bmapWidth;\r
- dibInfo->bmiHeader.biHeight = bmapHeight;\r
- res = GetDIBits(bitDevice, bitObject, 0, bmapHeight, bmap,\r
- dibInfo,\r
- DIB_RGB_COLORS);\r
- //VERIFY(res);\r
-\r
- // Create the GL object\r
- glNewList(i + listBase, GL_COMPILE);\r
- glBitmap(bmapWidth, bmapHeight, 0.0, metric.tmDescent,\r
- charWidth, 0.0,\r
- bmap);\r
- glEndList();\r
- // CheckGL();\r
-\r
- // Destroy the bmap object\r
- DeleteObject(bitObject);\r
-\r
- // Deallocate the bitmap data\r
- free(bmap);\r
- }\r
-\r
- // Destroy the DC\r
- VERIFY(DeleteDC(bitDevice));\r
-\r
- free(dibInfo);\r
-\r
- return TRUE;\r
-#undef VERIFY\r
-}\r
-\r
-WGLAPI BOOL GLAPIENTRY wglUseFontBitmapsA(HDC hdc, DWORD first,\r
- DWORD count, DWORD listBase)\r
-{\r
- int i;\r
- GLuint font_list;\r
- DWORD size;\r
- GLYPHMETRICS gm;\r
- HANDLE hBits;\r
- LPSTR lpBits;\r
- MAT2 mat;\r
- int success = TRUE;\r
-\r
- if (first<0)\r
- return FALSE;\r
- if (count<0)\r
- return FALSE;\r
- if (listBase<0)\r
- return FALSE;\r
-\r
- font_list = listBase;\r
-\r
- mat.eM11 = FixedFromDouble(1);\r
- mat.eM12 = FixedFromDouble(0);\r
- mat.eM21 = FixedFromDouble(0);\r
- mat.eM22 = FixedFromDouble(-1);\r
-\r
- memset(&gm,0,sizeof(gm));\r
-\r
- /*\r
- ** If we can't get the glyph outline, it may be because this is a fixed\r
- ** font. Try processing it that way.\r
- */\r
- if( GetGlyphOutline(hdc, first, GGO_BITMAP, &gm, 0, NULL, &mat)\r
- == GDI_ERROR )\r
- {\r
- return wglUseFontBitmaps_FX( hdc, first, count, listBase );\r
- }\r
-\r
- /*\r
- ** Otherwise process all desired characters.\r
- */\r
- for (i = 0; i < count; i++)\r
- {\r
- DWORD err;\r
- \r
- glNewList( font_list+i, GL_COMPILE );\r
-\r
- /* allocate space for the bitmap/outline */\r
- size = GetGlyphOutline(hdc, first + i, GGO_BITMAP, &gm, 0, NULL, &mat);\r
- if (size == GDI_ERROR)\r
- {\r
- glEndList( );\r
- err = GetLastError();\r
- success = FALSE;\r
- continue;\r
- }\r
-\r
- hBits = GlobalAlloc(GHND, size+1);\r
- lpBits = GlobalLock(hBits);\r
-\r
- err = \r
- GetGlyphOutline(hdc, /* handle to device context */\r
- first + i, /* character to query */\r
- GGO_BITMAP, /* format of data to return */\r
- &gm, /* pointer to structure for metrics*/\r
- size, /* size of buffer for data */\r
- lpBits, /* pointer to buffer for data */\r
- &mat /* pointer to transformation */\r
- /* matrix structure */\r
- );\r
-\r
- if (err == GDI_ERROR)\r
- {\r
- GlobalUnlock(hBits);\r
- GlobalFree(hBits);\r
- \r
- glEndList( );\r
- err = GetLastError();\r
- success = FALSE;\r
- continue;\r
- }\r
-\r
- glBitmap(gm.gmBlackBoxX,gm.gmBlackBoxY,\r
- -gm.gmptGlyphOrigin.x,\r
- gm.gmptGlyphOrigin.y,\r
- gm.gmCellIncX,gm.gmCellIncY,\r
- (const GLubyte * )lpBits);\r
-\r
- GlobalUnlock(hBits);\r
- GlobalFree(hBits);\r
-\r
- glEndList( );\r
- }\r
-\r
- return success;\r
-}\r
-\r
-\r
-WGLAPI BOOL GLAPIENTRY wglUseFontBitmapsW(HDC hdc,DWORD first,DWORD count,DWORD listBase)\r
-{\r
- return FALSE;\r
-}\r
-\r
-WGLAPI BOOL GLAPIENTRY wglUseFontOutlinesA(HDC hdc,DWORD first,DWORD count,\r
- DWORD listBase,FLOAT deviation,\r
- FLOAT extrusion,int format,\r
- LPGLYPHMETRICSFLOAT lpgmf)\r
-{\r
- SetLastError(0);\r
- return(FALSE);\r
-}\r
-\r
-WGLAPI BOOL GLAPIENTRY wglUseFontOutlinesW(HDC hdc,DWORD first,DWORD count,\r
- DWORD listBase,FLOAT deviation,\r
- FLOAT extrusion,int format,\r
- LPGLYPHMETRICSFLOAT lpgmf)\r
-{\r
- SetLastError(0);\r
- return(FALSE);\r
-}\r
-\r
-WGLAPI BOOL GLAPIENTRY wglDescribeLayerPlane(HDC hdc,int iPixelFormat,\r
- int iLayerPlane,UINT nBytes,\r
- LPLAYERPLANEDESCRIPTOR plpd)\r
-{\r
- SetLastError(0);\r
- return(FALSE);\r
-}\r
-\r
-WGLAPI int GLAPIENTRY wglSetLayerPaletteEntries(HDC hdc,int iLayerPlane,\r
- int iStart,int cEntries,\r
- CONST COLORREF *pcr)\r
-{\r
- SetLastError(0);\r
- return(0);\r
-}\r
-\r
-WGLAPI int GLAPIENTRY wglGetLayerPaletteEntries(HDC hdc,int iLayerPlane,\r
- int iStart,int cEntries,\r
- COLORREF *pcr)\r
-{\r
- SetLastError(0);\r
- return(0);\r
-}\r
-\r
-WGLAPI BOOL GLAPIENTRY wglRealizeLayerPalette(HDC hdc,int iLayerPlane,BOOL bRealize)\r
-{\r
- SetLastError(0);\r
- return(FALSE);\r
-}\r
-\r
-WGLAPI BOOL GLAPIENTRY wglSwapLayerBuffers(HDC hdc,UINT fuPlanes)\r
-{\r
- if( !hdc )\r
- {\r
- WMesaSwapBuffers();\r
- return(TRUE);\r
- }\r
- SetLastError(0);\r
- return(FALSE);\r
-}\r
-\r
-WGLAPI int GLAPIENTRY wglChoosePixelFormat(HDC hdc,\r
- CONST PIXELFORMATDESCRIPTOR *ppfd)\r
-{\r
- int i,best = -1,bestdelta = 0x7FFFFFFF,delta,qt_valid_pix;\r
-\r
- qt_valid_pix = qt_pix;\r
- if(ppfd->nSize != sizeof(PIXELFORMATDESCRIPTOR) || ppfd->nVersion != 1)\r
- {\r
- SetLastError(0);\r
- return(0);\r
- }\r
- for(i = 0;i < qt_valid_pix;i++)\r
- {\r
- delta = 0;\r
- if(\r
- (ppfd->dwFlags & PFD_DRAW_TO_WINDOW) &&\r
- !(pix[i].pfd.dwFlags & PFD_DRAW_TO_WINDOW))\r
- continue;\r
- if(\r
- (ppfd->dwFlags & PFD_DRAW_TO_BITMAP) &&\r
- !(pix[i].pfd.dwFlags & PFD_DRAW_TO_BITMAP))\r
- continue;\r
- if(\r
- (ppfd->dwFlags & PFD_SUPPORT_GDI) &&\r
- !(pix[i].pfd.dwFlags & PFD_SUPPORT_GDI))\r
- continue;\r
- if(\r
- (ppfd->dwFlags & PFD_SUPPORT_OPENGL) &&\r
- !(pix[i].pfd.dwFlags & PFD_SUPPORT_OPENGL))\r
- continue;\r
- if(\r
- !(ppfd->dwFlags & PFD_DOUBLEBUFFER_DONTCARE) &&\r
- ((ppfd->dwFlags & PFD_DOUBLEBUFFER) != (pix[i].pfd.dwFlags & PFD_DOUBLEBUFFER)))\r
- continue;\r
- if(\r
- !(ppfd->dwFlags & PFD_STEREO_DONTCARE) &&\r
- ((ppfd->dwFlags & PFD_STEREO) != (pix[i].pfd.dwFlags & PFD_STEREO)))\r
- continue;\r
- if(ppfd->iPixelType != pix[i].pfd.iPixelType)\r
- delta++;\r
- if(delta < bestdelta)\r
- {\r
- best = i + 1;\r
- bestdelta = delta;\r
- if(bestdelta == 0)\r
- break;\r
- }\r
- }\r
- if(best == -1)\r
- {\r
- SetLastError(0);\r
- return(0);\r
- }\r
- return(best);\r
-}\r
-\r
-WGLAPI int GLAPIENTRY wglDescribePixelFormat(HDC hdc,int iPixelFormat,UINT nBytes,\r
- LPPIXELFORMATDESCRIPTOR ppfd)\r
-{\r
- int qt_valid_pix;\r
-\r
- qt_valid_pix = qt_pix;\r
- if(iPixelFormat < 1 || iPixelFormat > qt_valid_pix || nBytes != sizeof(PIXELFORMATDESCRIPTOR))\r
- {\r
- SetLastError(0);\r
- return(0);\r
- }\r
- *ppfd = pix[iPixelFormat - 1].pfd;\r
- return(qt_valid_pix);\r
-}\r
-\r
-/*\r
-* GetProcAddress - return the address of an appropriate extension\r
-*/\r
-WGLAPI PROC GLAPIENTRY wglGetProcAddress(LPCSTR lpszProc)\r
-{\r
- int i;\r
- for(i = 0;i < qt_ext;i++)\r
- if(!strcmp(lpszProc,ext[i].name))\r
- return(ext[i].proc);\r
-\r
- SetLastError(0);\r
- return(NULL);\r
-}\r
-\r
-WGLAPI int GLAPIENTRY wglGetPixelFormat(HDC hdc)\r
-{\r
- if(curPFD == 0)\r
- {\r
- SetLastError(0);\r
- return(0);\r
- }\r
- return(curPFD);\r
-}\r
-\r
-WGLAPI BOOL GLAPIENTRY wglSetPixelFormat(HDC hdc,int iPixelFormat,\r
- PIXELFORMATDESCRIPTOR *ppfd)\r
-{\r
- int qt_valid_pix;\r
-\r
- qt_valid_pix = qt_pix;\r
- if(iPixelFormat < 1 || iPixelFormat > qt_valid_pix || ppfd->nSize != sizeof(PIXELFORMATDESCRIPTOR))\r
- {\r
- SetLastError(0);\r
- return(FALSE);\r
- }\r
- curPFD = iPixelFormat;\r
- return(TRUE);\r
-}\r
-\r
-WGLAPI BOOL GLAPIENTRY wglSwapBuffers(HDC hdc)\r
-{\r
- if (ctx_current < 0)\r
- return FALSE;\r
-\r
- if(wgl_ctx[ctx_current].ctx == NULL) {\r
- SetLastError(0);\r
- return(FALSE);\r
- }\r
- WMesaSwapBuffers();\r
- return(TRUE);\r
-}\r
-\r
-#endif /* WIN32 */\r
+/* $Id: wgl.c,v 1.9 2001/09/18 16:39:38 kschultz Exp $ */
+
+/*
+* This library is free software; you can redistribute it and/or
+* modify it under the terms of the GNU Library General Public
+* License as published by the Free Software Foundation; either
+* version 2 of the License, or (at your option) any later version.
+*
+* This library is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+* Library General Public License for more details.
+*
+* You should have received a copy of the GNU Library General Public
+* License along with this library; if not, write to the Free
+* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*
+*/
+
+/*
+* File name : wgl.c
+* WGL stuff. Added by Oleg Letsinsky, ajl@ultersys.ru
+* Some things originated from the 3Dfx WGL functions
+*/
+
+#ifdef WIN32
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <windows.h>
+#define GL_GLEXT_PROTOTYPES
+#include <GL/gl.h>
+#include <GL/glext.h>
+//#include <GL/glu.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#include <stdio.h>
+#include <tchar.h>
+#include "wmesadef.h"
+#include "GL/wmesa.h"
+#include "mtypes.h"
+
+#define MAX_MESA_ATTRS 20
+
+struct __extensions__
+{
+ PROC proc;
+ char *name;
+};
+
+struct __pixelformat__
+{
+ PIXELFORMATDESCRIPTOR pfd;
+ GLboolean doubleBuffered;
+};
+
+struct __extensions__ ext[] = {
+
+#ifdef GL_EXT_polygon_offset
+ { (PROC)glPolygonOffsetEXT, "glPolygonOffsetEXT" },
+#endif
+ { (PROC)glBlendEquationEXT, "glBlendEquationEXT" },
+ { (PROC)glBlendColorEXT, "glBlendColorExt" },
+ { (PROC)glVertexPointerEXT, "glVertexPointerEXT" },
+ { (PROC)glNormalPointerEXT, "glNormalPointerEXT" },
+ { (PROC)glColorPointerEXT, "glColorPointerEXT" },
+ { (PROC)glIndexPointerEXT, "glIndexPointerEXT" },
+ { (PROC)glTexCoordPointerEXT, "glTexCoordPointer" },
+ { (PROC)glEdgeFlagPointerEXT, "glEdgeFlagPointerEXT" },
+ { (PROC)glGetPointervEXT, "glGetPointervEXT" },
+ { (PROC)glArrayElementEXT, "glArrayElementEXT" },
+ { (PROC)glDrawArraysEXT, "glDrawArrayEXT" },
+ { (PROC)glAreTexturesResidentEXT, "glAreTexturesResidentEXT" },
+ { (PROC)glBindTextureEXT, "glBindTextureEXT" },
+ { (PROC)glDeleteTexturesEXT, "glDeleteTexturesEXT" },
+ { (PROC)glGenTexturesEXT, "glGenTexturesEXT" },
+ { (PROC)glIsTextureEXT, "glIsTextureEXT" },
+ { (PROC)glPrioritizeTexturesEXT, "glPrioritizeTexturesEXT" },
+ { (PROC)glCopyTexSubImage3DEXT, "glCopyTexSubImage3DEXT" },
+ { (PROC)glTexImage3DEXT, "glTexImage3DEXT" },
+ { (PROC)glTexSubImage3DEXT, "glTexSubImage3DEXT" },
+ { (PROC)glColorTableEXT, "glColorTableEXT" },
+ { (PROC)glColorSubTableEXT, "glColorSubTableEXT" },
+ { (PROC)glGetColorTableEXT, "glGetColorTableEXT" },
+ { (PROC)glGetColorTableParameterfvEXT, "glGetColorTableParameterfvEXT" },
+ { (PROC)glGetColorTableParameterivEXT, "glGetColorTableParameterivEXT" },
+ { (PROC)glPointParameterfEXT, "glPointParameterfEXT" },
+ { (PROC)glPointParameterfvEXT, "glPointParameterfvEXT" },
+ { (PROC)glBlendFuncSeparateEXT, "glBlendFuncSeparateEXT" },
+ { (PROC)glLockArraysEXT, "glLockArraysEXT" },
+ { (PROC)glUnlockArraysEXT, "glUnlockArraysEXT" }
+};
+
+int qt_ext = sizeof(ext) / sizeof(ext[0]);
+
+struct __pixelformat__ pix[] =
+{
+ { { sizeof(PIXELFORMATDESCRIPTOR), 1,
+ PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|PFD_GENERIC_FORMAT|PFD_DOUBLEBUFFER|PFD_SWAP_COPY,
+ PFD_TYPE_RGBA,
+ 24, 8, 0, 8, 8, 8, 16, 8, 24,
+ 0, 0, 0, 0, 0, 16, 8, 0, 0, 0, 0, 0, 0 },
+ GL_TRUE
+ },
+ { { sizeof(PIXELFORMATDESCRIPTOR), 1,
+ PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|PFD_GENERIC_FORMAT,
+ PFD_TYPE_RGBA,
+ 24, 8, 0, 8, 8, 8, 16, 8, 24,
+ 0, 0, 0, 0, 0, 16, 8, 0, 0, 0, 0, 0, 0 },
+ GL_FALSE
+ },
+};
+
+int qt_pix = sizeof(pix) / sizeof(pix[0]);
+
+typedef struct {
+ WMesaContext ctx;
+ HDC hdc;
+} MesaWglCtx;
+
+#define MESAWGL_CTX_MAX_COUNT 20
+
+static MesaWglCtx wgl_ctx[MESAWGL_CTX_MAX_COUNT];
+
+static unsigned ctx_count = 0;
+static unsigned ctx_current = -1;
+static unsigned curPFD = 0;
+
+WGLAPI BOOL GLAPIENTRY wglCopyContext(HGLRC hglrcSrc,HGLRC hglrcDst,UINT mask)
+{
+ return(FALSE);
+}
+
+WGLAPI HGLRC GLAPIENTRY wglCreateContext(HDC hdc)
+{
+ HWND hWnd;
+ int i = 0;
+ if(!(hWnd = WindowFromDC(hdc)))
+ {
+ SetLastError(0);
+ return(NULL);
+ }
+ if (!ctx_count)
+ {
+ for(i=0;i<MESAWGL_CTX_MAX_COUNT;i++)
+ {
+ wgl_ctx[i].ctx = NULL;
+ wgl_ctx[i].hdc = NULL;
+ }
+ }
+ for( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ )
+ {
+ if ( wgl_ctx[i].ctx == NULL )
+ {
+ wgl_ctx[i].ctx = WMesaCreateContext( hWnd, NULL, GL_TRUE,
+ pix[curPFD-1].doubleBuffered );
+ if (wgl_ctx[i].ctx == NULL)
+ break;
+ wgl_ctx[i].hdc = hdc;
+ ctx_count++;
+ return ((HGLRC)wgl_ctx[i].ctx);
+ }
+ }
+ SetLastError(0);
+ return(NULL);
+}
+
+WGLAPI BOOL GLAPIENTRY wglDeleteContext(HGLRC hglrc)
+{
+ int i;
+ for ( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ )
+ {
+ if ( wgl_ctx[i].ctx == (PWMC) hglrc )
+ {
+ WMesaMakeCurrent((PWMC) hglrc);
+ WMesaDestroyContext();
+ wgl_ctx[i].ctx = NULL;
+ wgl_ctx[i].hdc = NULL;
+ ctx_count--;
+ return(TRUE);
+ }
+ }
+ SetLastError(0);
+ return(FALSE);
+}
+
+WGLAPI HGLRC GLAPIENTRY wglCreateLayerContext(HDC hdc,int iLayerPlane)
+{
+ SetLastError(0);
+ return(NULL);
+}
+
+WGLAPI HGLRC GLAPIENTRY wglGetCurrentContext(VOID)
+{
+ if (ctx_current < 0)
+ return 0;
+ else
+ return (HGLRC) wgl_ctx[ctx_current].ctx;
+}
+
+WGLAPI HDC GLAPIENTRY wglGetCurrentDC(VOID)
+{
+ if (ctx_current < 0)
+ return 0;
+ else
+ return wgl_ctx[ctx_current].hdc;
+}
+
+WGLAPI BOOL GLAPIENTRY wglMakeCurrent(HDC hdc,HGLRC hglrc)
+{
+ int i;
+
+ /* new code suggested by Andy Sy */
+ if (!hdc || !hglrc) {
+ WMesaMakeCurrent(NULL);
+ ctx_current = -1;
+ return TRUE;
+ }
+
+ for ( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ )
+ {
+ if ( wgl_ctx[i].ctx == (PWMC) hglrc )
+ {
+ wgl_ctx[i].hdc = hdc;
+ WMesaMakeCurrent( (WMesaContext) hglrc );
+ ctx_current = i;
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+WGLAPI BOOL GLAPIENTRY wglShareLists(HGLRC hglrc1,HGLRC hglrc2)
+{
+ return(TRUE);
+}
+
+
+static FIXED FixedFromDouble(double d)
+{
+ long l = (long) (d * 65536L);
+ return *(FIXED *)&l;
+}
+
+
+/*
+** This is cribbed from FX/fxwgl.c, and seems to implement support
+** for bitmap fonts where the wglUseFontBitmapsA() code implements
+** support for outline fonts. In combination they hopefully give
+** fairly generic support for fonts.
+*/
+static BOOL wglUseFontBitmaps_FX(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
+}
+
+WGLAPI 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;
+
+ if (first<0)
+ return FALSE;
+ if (count<0)
+ return FALSE;
+ if (listBase<0)
+ return FALSE;
+
+ 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;
+}
+
+
+WGLAPI BOOL GLAPIENTRY wglUseFontBitmapsW(HDC hdc,DWORD first,DWORD count,DWORD listBase)
+{
+ return FALSE;
+}
+
+WGLAPI BOOL GLAPIENTRY wglUseFontOutlinesA(HDC hdc,DWORD first,DWORD count,
+ DWORD listBase,FLOAT deviation,
+ FLOAT extrusion,int format,
+ LPGLYPHMETRICSFLOAT lpgmf)
+{
+ SetLastError(0);
+ return(FALSE);
+}
+
+WGLAPI BOOL GLAPIENTRY wglUseFontOutlinesW(HDC hdc,DWORD first,DWORD count,
+ DWORD listBase,FLOAT deviation,
+ FLOAT extrusion,int format,
+ LPGLYPHMETRICSFLOAT lpgmf)
+{
+ SetLastError(0);
+ return(FALSE);
+}
+
+WGLAPI BOOL GLAPIENTRY wglDescribeLayerPlane(HDC hdc,int iPixelFormat,
+ int iLayerPlane,UINT nBytes,
+ LPLAYERPLANEDESCRIPTOR plpd)
+{
+ SetLastError(0);
+ return(FALSE);
+}
+
+WGLAPI int GLAPIENTRY wglSetLayerPaletteEntries(HDC hdc,int iLayerPlane,
+ int iStart,int cEntries,
+ CONST COLORREF *pcr)
+{
+ SetLastError(0);
+ return(0);
+}
+
+WGLAPI int GLAPIENTRY wglGetLayerPaletteEntries(HDC hdc,int iLayerPlane,
+ int iStart,int cEntries,
+ COLORREF *pcr)
+{
+ SetLastError(0);
+ return(0);
+}
+
+WGLAPI BOOL GLAPIENTRY wglRealizeLayerPalette(HDC hdc,int iLayerPlane,BOOL bRealize)
+{
+ SetLastError(0);
+ return(FALSE);
+}
+
+WGLAPI BOOL GLAPIENTRY wglSwapLayerBuffers(HDC hdc,UINT fuPlanes)
+{
+ if( !hdc )
+ {
+ WMesaSwapBuffers();
+ return(TRUE);
+ }
+ SetLastError(0);
+ return(FALSE);
+}
+
+WGLAPI int GLAPIENTRY wglChoosePixelFormat(HDC hdc,
+ CONST PIXELFORMATDESCRIPTOR *ppfd)
+{
+ int i,best = -1,bestdelta = 0x7FFFFFFF,delta,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++)
+ {
+ delta = 0;
+ 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->iPixelType != pix[i].pfd.iPixelType)
+ delta++;
+ if(delta < bestdelta)
+ {
+ best = i + 1;
+ bestdelta = delta;
+ if(bestdelta == 0)
+ break;
+ }
+ }
+ if(best == -1)
+ {
+ SetLastError(0);
+ return(0);
+ }
+ return(best);
+}
+
+WGLAPI 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))
+ {
+ SetLastError(0);
+ return(0);
+ }
+ *ppfd = pix[iPixelFormat - 1].pfd;
+ return(qt_valid_pix);
+}
+
+/*
+* GetProcAddress - return the address of an appropriate extension
+*/
+WGLAPI PROC GLAPIENTRY wglGetProcAddress(LPCSTR lpszProc)
+{
+ int i;
+ for(i = 0;i < qt_ext;i++)
+ if(!strcmp(lpszProc,ext[i].name))
+ return(ext[i].proc);
+
+ SetLastError(0);
+ return(NULL);
+}
+
+WGLAPI int GLAPIENTRY wglGetPixelFormat(HDC hdc)
+{
+ if(curPFD == 0)
+ {
+ SetLastError(0);
+ return(0);
+ }
+ return(curPFD);
+}
+
+WGLAPI BOOL GLAPIENTRY wglSetPixelFormat(HDC hdc,int iPixelFormat,
+ 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);
+}
+
+WGLAPI BOOL GLAPIENTRY wglSwapBuffers(HDC hdc)
+{
+ if (ctx_current < 0)
+ return FALSE;
+
+ if(wgl_ctx[ctx_current].ctx == NULL) {
+ SetLastError(0);
+ return(FALSE);
+ }
+ WMesaSwapBuffers();
+ return(TRUE);
+}
+
+#endif /* WIN32 */
-/* $Id: wmesa.c,v 1.18 2001/09/14 22:19:19 brianp Exp $ */\r
-\r
-/*\r
- * Windows (Win32) device driver for Mesa 3.4\r
- *\r
- * Original author:\r
- *\r
- * Copyright (C) 1996- Li Wei\r
- * Address : Institute of Artificial Intelligence\r
- * : & Robotics\r
- * : Xi'an Jiaotong University\r
- * Email : liwei@aiar.xjtu.edu.cn\r
- * Web page : http://sun.aiar.xjtu.edu.cn\r
- *\r
- * This file and its associations are partially borrowed from the\r
- * Windows NT driver for Mesa 1.8 , written by Mark Leaming\r
- * (mark@rsinc.com).\r
- */\r
-\r
-\r
-#define WMESA_STEREO_C\r
-\r
-#include <windows.h>\r
-#include <stdio.h>\r
-#include <stdlib.h>\r
-#include <GL/wmesa.h>\r
-#include "mesa_extend.h"\r
-#include "colors.h"\r
-#include "macros.h"\r
-#include "context.h"\r
-#include "dd.h"\r
-//#include "xform.h"\r
-//#include "vb.h"\r
-#include "matrix.h"\r
-#include "depth.h"\r
-#include "wmesadef.h"\r
-\r
-#pragma warning ( disable : 4100 4133 4761 )\r
-\r
-#ifdef PROFILE\r
-// #include "profile.h"\r
-#endif\r
-\r
-#ifdef DITHER\r
-#include <wing.h>\r
-#endif\r
-\r
-#ifdef __CYGWIN32__\r
-#include "macros.h"\r
-#include <string.h>\r
-#define CopyMemory memcpy\r
-#endif\r
-\r
-#if !defined(NO_STEREO)\r
-\r
-#include "gl\glu.h"\r
-#include "stereo.h"\r
-\r
-#endif\r
-#if !defined(NO_PARALLEL)\r
- #include "parallel.h"\r
-#endif\r
-\r
-struct DISPLAY_OPTIONS displayOptions;\r
-\r
-GLenum stereoCompile = GL_FALSE ;\r
-GLenum stereoShowing = GL_FALSE ;\r
-GLenum stereoBuffer = GL_FALSE;\r
-#if !defined(NO_STEREO)\r
-GLint displayList = MAXIMUM_DISPLAY_LIST ;\r
-#endif\r
-GLint stereo_flag = 0 ;\r
-\r
-/* end of added code*/\r
-\r
-static PWMC Current = NULL;\r
-WMesaContext WC = NULL;\r
-\r
-#ifdef NDEBUG\r
-#define assert(ignore) ((void) 0)\r
-#else\r
-void Mesa_Assert(void *Cond,void *File,unsigned Line)\r
-{\r
- char Msg[512];\r
- sprintf(Msg,"%s %s %d",Cond,File,Line);\r
- MessageBox(NULL,Msg,"Assertion failed.",MB_OK);\r
- exit(1);\r
-}\r
-#define assert(e) if (!e) Mesa_Assert(#e,__FILE__,__LINE__);\r
-#endif\r
-\r
-//#define DD_GETDC (Current->hDC )\r
-#define DD_GETDC ((Current->db_flag) ? Current->dib.hDC : Current->hDC )\r
-//#define DD_GETDC ((Current->db_flag) ? Current->hDCPrimary : Current->hDCBack )\r
-#define DD_RELEASEDC\r
-\r
-//#define BEGINGDICALL if(Current->rgb_flag)wmFlushBits(Current);\r
-#define BEGINGDICALL\r
-//#define ENDGDICALL if(Current->rgb_flag)wmGetBits(Current);\r
-#define ENDGDICALL\r
-\r
-//#define FLIP(Y) (Current->dither_flag? Y : Current->height-(Y)-1)\r
-//#define FLIP(Y) (Current->height-(Y)-1)\r
-//#define FLIP(Y) Y\r
-/*\r
- * XXX Why only flip Y coord if single buffered???\r
- */\r
-#define FLIP(Y) (Current->db_flag? Y: Current->height-(Y)-1)\r
-#define STARTPROFILE\r
-#define ENDPROFILE(PARA)\r
-\r
-#define DITHER_RGB_TO_8BIT_SETUP \\r
-GLubyte pixelDithered;\r
-\r
-#define DITHER_RGB_TO_8BIT(red, green, blue, pixel, scanline) \\r
-{ \\r
- char unsigned redtemp, greentemp, bluetemp, paletteindex; \\r
- redtemp = aDividedBy51[red] \\r
- + (aModulo51[red] > aHalftone8x8[(pixel%8)*8 \\r
- + scanline%8]); \\r
- greentemp = aDividedBy51[(char unsigned)green] \\r
- + (aModulo51[green] > aHalftone8x8[ \\r
- (pixel%8)*8 + scanline%8]); \\r
- bluetemp = aDividedBy51[(char unsigned)blue] \\r
- + (aModulo51[blue] > aHalftone8x8[ \\r
- (pixel%8)*8 +scanline%8]); \\r
- paletteindex = redtemp + aTimes6[greentemp] + aTimes36[bluetemp]; \\r
- pixelDithered = aWinGHalftoneTranslation[paletteindex]; \\r
-}\r
-\r
-\r
-#ifdef DDRAW\r
-static BOOL DDInit( WMesaContext wc, HWND hwnd);\r
-static void DDFree( WMesaContext wc);\r
-static HRESULT DDRestoreAll( WMesaContext wc );\r
-static void DDDeleteOffScreen(WMesaContext wc);\r
-static BOOL DDCreateOffScreen(WMesaContext wc);\r
-#endif\r
-\r
-static void FlushToFile(PWMC pwc, PSTR szFile);\r
-\r
-BOOL wmCreateBackingStore(PWMC pwc, long lxSize, long lySize);\r
-BOOL wmDeleteBackingStore(PWMC pwc);\r
-void wmCreatePalette( PWMC pwdc );\r
-BOOL wmSetDibColors(PWMC pwc);\r
-void wmSetPixel(PWMC pwc, int iScanLine, int iPixel, BYTE r, BYTE g, BYTE b);\r
-\r
-void wmCreateDIBSection(\r
- HDC hDC,\r
- PWMC pwc, // handle of device context\r
- CONST BITMAPINFO *pbmi, // address of structure containing bitmap size, format, and color data\r
- UINT iUsage // color data type indicator: RGB values or palette indices\r
- );\r
-\r
-\r
-void WMesaViewport( GLcontext *ctx,\r
- GLint x, GLint y, GLsizei width, GLsizei height );\r
-\r
-\r
-//static triangle_func choose_triangle_function( GLcontext *ctx );\r
-\r
-\r
-static void wmSetPixelFormat( PWMC wc, HDC hDC)\r
-{\r
- if(wc->rgb_flag)\r
- wc->cColorBits = GetDeviceCaps(hDC, BITSPIXEL);\r
- else\r
- wc->cColorBits = 8;\r
- switch(wc->cColorBits){\r
- case 8:\r
- if(wc->dither_flag != GL_TRUE)\r
- wc->pixelformat = PF_INDEX8;\r
- else\r
- wc->pixelformat = PF_DITHER8;\r
- break;\r
- case 16:\r
- wc->pixelformat = PF_5R6G5B;\r
- break;\r
- case 32:\r
- wc->pixelformat = PF_8R8G8B;\r
- break;\r
- default:\r
- wc->pixelformat = PF_BADFORMAT;\r
- }\r
-}\r
-\r
-//\r
-// This function sets the color table of a DIB section\r
-// to match that of the destination DC\r
-//\r
-BOOL /*WINAPI*/ wmSetDibColors(PWMC pwc)\r
-{\r
- RGBQUAD *pColTab, *pRGB;\r
- PALETTEENTRY *pPal, *pPE;\r
- int i, nColors;\r
- BOOL bRet=TRUE;\r
- DWORD dwErr=0;\r
-\r
- /* Build a color table in the DIB that maps to the\r
- selected palette in the DC.\r
- */\r
- nColors = 1 << pwc->cColorBits;\r
- pPal = (PALETTEENTRY *)malloc( nColors * sizeof(PALETTEENTRY));\r
- memset( pPal, 0, nColors * sizeof(PALETTEENTRY) );\r
- GetPaletteEntries( pwc->hGLPalette, 0, nColors, pPal );\r
- pColTab = (RGBQUAD *)malloc( nColors * sizeof(RGBQUAD));\r
- for (i = 0, pRGB = pColTab, pPE = pPal; i < nColors; i++, pRGB++, pPE++) {\r
- pRGB->rgbRed = pPE->peRed;\r
- pRGB->rgbGreen = pPE->peGreen;\r
- pRGB->rgbBlue = pPE->peBlue;\r
- }\r
- if(pwc->db_flag)\r
- bRet = SetDIBColorTable(pwc->dib.hDC, 0, nColors, pColTab );\r
-\r
- if(!bRet)\r
- dwErr = GetLastError();\r
-\r
- free( pColTab );\r
- free( pPal );\r
-\r
- return(bRet);\r
-}\r
-\r
-\r
-//\r
-// Free up the dib section that was created\r
-//\r
-BOOL wmDeleteBackingStore(PWMC pwc)\r
-{\r
- SelectObject(pwc->dib.hDC, pwc->hOldBitmap);\r
- DeleteDC(pwc->dib.hDC);\r
- DeleteObject(pwc->hbmDIB);\r
- UnmapViewOfFile(pwc->dib.base);\r
- CloseHandle(pwc->dib.hFileMap);\r
- return TRUE;\r
-}\r
-\r
-\r
-//\r
-// This function creates the DIB section that is used for combined\r
-// GL and GDI calls\r
-//\r
-BOOL /*WINAPI*/ wmCreateBackingStore(PWMC pwc, long lxSize, long lySize)\r
-{\r
- HDC hdc = pwc->hDC;\r
- LPBITMAPINFO pbmi = &(pwc->bmi);\r
- int iUsage;\r
-\r
- pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);\r
- pbmi->bmiHeader.biWidth = lxSize;\r
- pbmi->bmiHeader.biHeight= -lySize;\r
- pbmi->bmiHeader.biPlanes = 1;\r
- if(pwc->rgb_flag)\r
- pbmi->bmiHeader.biBitCount = GetDeviceCaps(pwc->hDC, BITSPIXEL);\r
- else\r
- pbmi->bmiHeader.biBitCount = 8;\r
- pbmi->bmiHeader.biCompression = BI_RGB;\r
- pbmi->bmiHeader.biSizeImage = 0;\r
- pbmi->bmiHeader.biXPelsPerMeter = 0;\r
- pbmi->bmiHeader.biYPelsPerMeter = 0;\r
- pbmi->bmiHeader.biClrUsed = 0;\r
- pbmi->bmiHeader.biClrImportant = 0;\r
-\r
- iUsage = (pbmi->bmiHeader.biBitCount <= 8) ? DIB_PAL_COLORS : DIB_RGB_COLORS;\r
-\r
- pwc->cColorBits = pbmi->bmiHeader.biBitCount;\r
- pwc->ScanWidth = pwc->pitch = lxSize;\r
-\r
- wmCreateDIBSection(hdc, pwc, pbmi, iUsage);\r
-\r
- if ((iUsage == DIB_PAL_COLORS) && !(pwc->hGLPalette)) {\r
- wmCreatePalette( pwc );\r
- wmSetDibColors( pwc );\r
- }\r
- wmSetPixelFormat(pwc, pwc->hDC);\r
- return(TRUE);\r
-\r
-}\r
-\r
-\r
-//\r
-// This function copies one scan line in a DIB section to another\r
-//\r
-BOOL WINAPI wmSetDIBits(PWMC pwc, UINT uiScanWidth, UINT uiNumScans, UINT nBypp, UINT uiNewWidth, LPBYTE pBits)\r
-{\r
- UINT uiScans = 0;\r
- LPBYTE pDest = pwc->pbPixels;\r
- DWORD dwNextScan = uiScanWidth;\r
- DWORD dwNewScan = uiNewWidth;\r
- DWORD dwScanWidth = (uiScanWidth * nBypp);\r
-\r
- //\r
- // We need to round up to the nearest DWORD\r
- // and multiply by the number of bytes per\r
- // pixel\r
- //\r
- dwNextScan = (((dwNextScan * nBypp)+ 3) & ~3);\r
- dwNewScan = (((dwNewScan * nBypp)+ 3) & ~3);\r
-\r
- for(uiScans = 0; uiScans < uiNumScans; uiScans++){\r
- CopyMemory(pDest, pBits, dwScanWidth);\r
- pBits += dwNextScan;\r
- pDest += dwNewScan;\r
- }\r
-\r
- return(TRUE);\r
-\r
-}\r
-\r
-\r
-BOOL wmFlush(PWMC pwc);\r
-\r
-/*\r
-* Useful macros:\r
-Modified from file osmesa.c\r
-*/\r
-\r
-\r
-#define PIXELADDR(X,Y) ((GLubyte *)Current->pbPixels + (Current->height-Y-1)* Current->ScanWidth + (X)*nBypp)\r
-#define PIXELADDR1( X, Y ) \\r
-((GLubyte *)wmesa->pbPixels + (wmesa->height-Y-1)* wmesa->ScanWidth + (X))\r
-#define PIXELADDR2( X, Y ) \\r
-((GLubyte *)wmesa->pbPixels + (wmesa->height-Y-1)* wmesa->ScanWidth + (X)*2)\r
-#define PIXELADDR4( X, Y ) \\r
-((GLubyte *)wmesa->pbPixels + (wmesa->height-Y-1)* wmesa->ScanWidth + (X)*4)\r
-\r
-\r
-BYTE DITHER_RGB_2_8BIT( int r, int g, int b, int x, int y);\r
-\r
-/* Finish all pending operations and synchronize. */\r
-static void finish(GLcontext* ctx)\r
-{\r
- /* No op */\r
-}\r
-\r
-\r
-//\r
-// We cache all gl draw routines until a flush is made\r
-//\r
-static void flush(GLcontext* ctx)\r
-{\r
- STARTPROFILE\r
- if((Current->rgb_flag /*&& !(Current->dib.fFlushed)*/&&!(Current->db_flag))\r
- ||(!Current->rgb_flag))\r
- {\r
- wmFlush(Current);\r
- }\r
- ENDPROFILE(flush)\r
-\r
-}\r
-\r
-\r
-\r
-/*\r
-* Set the color index used to clear the color buffer.\r
-*/\r
-static void clear_index(GLcontext* ctx, GLuint index)\r
-{\r
- STARTPROFILE\r
- Current->clearpixel = index;\r
- ENDPROFILE(clear_index)\r
-}\r
-\r
-\r
-\r
-/*\r
-* Set the color used to clear the color buffer.\r
-*/\r
-static void clear_color( GLcontext* ctx, const GLchan color[4] )\r
-{\r
- STARTPROFILE\r
- Current->clearpixel = RGB(color[0], color[1], color[2]);\r
- ENDPROFILE(clear_color)\r
-}\r
-\r
-\r
-\r
-/*\r
-* Clear the specified region of the color buffer using the clear color\r
-* or index as specified by one of the two functions above.\r
-*/\r
-//static void clear(GLcontext* ctx,\r
-// GLboolean all,GLint x, GLint y, GLint width, GLint height )\r
-// TODO: I modified this function to match the prototype in\r
-// dd.h. (swansma@geocities.com)\r
-\r
-static GLbitfield clear(GLcontext* ctx, GLbitfield mask,\r
- GLboolean all, GLint x, GLint y, GLint width, GLint height)\r
-{\r
- DWORD dwColor;\r
- WORD wColor;\r
- BYTE bColor;\r
- LPDWORD lpdw = (LPDWORD)Current->pbPixels;\r
- LPWORD lpw = (LPWORD)Current->pbPixels;\r
- LPBYTE lpb = Current->pbPixels;\r
- int lines;\r
-\r
- STARTPROFILE\r
-\r
- if (all){\r
- x=y=0;\r
- width=Current->width;\r
- height=Current->height;\r
- }\r
- if(Current->db_flag==GL_TRUE){\r
- UINT nBypp = Current->cColorBits / 8;\r
- int i = 0;\r
- int iSize = 0;\r
-\r
- if(nBypp ==1 ){\r
- /* Need rectification */\r
- iSize = Current->width/4;\r
- bColor = BGR8(GetRValue(Current->clearpixel),\r
- GetGValue(Current->clearpixel),\r
- GetBValue(Current->clearpixel));\r
- wColor = MAKEWORD(bColor,bColor);\r
- dwColor = MAKELONG(wColor, wColor);\r
- }\r
- if(nBypp == 2){\r
- iSize = Current->width / 2;\r
- wColor = BGR16(GetRValue(Current->clearpixel),\r
- GetGValue(Current->clearpixel),\r
- GetBValue(Current->clearpixel));\r
- dwColor = MAKELONG(wColor, wColor);\r
- }\r
- else if(nBypp == 4){\r
- iSize = Current->width;\r
- dwColor = BGR32(GetRValue(Current->clearpixel),\r
- GetGValue(Current->clearpixel),\r
- GetBValue(Current->clearpixel));\r
- }\r
-\r
- while(i < iSize){\r
- *lpdw = dwColor;\r
- lpdw++;\r
- i++;\r
- }\r
-\r
- //\r
- // This is the 24bit case\r
- //\r
- if (nBypp == 3) {\r
- iSize = Current->width *3/4;\r
- dwColor = BGR24(GetRValue(Current->clearpixel),\r
- GetGValue(Current->clearpixel),\r
- GetBValue(Current->clearpixel));\r
- while(i < iSize){\r
- *lpdw = dwColor;\r
- lpb += nBypp;\r
- lpdw = (LPDWORD)lpb;\r
- i++;\r
- }\r
- }\r
-\r
- i = 0;\r
- if (stereo_flag)\r
- lines = height /2;\r
- else\r
- lines = height;\r
- do {\r
- memcpy(lpb, Current->pbPixels, iSize*4);\r
- lpb += Current->ScanWidth;\r
- i++;\r
- }\r
- while (i<lines-1);\r
- }\r
- else { // For single buffer\r
- HDC DC=DD_GETDC;\r
- HPEN Pen=CreatePen(PS_SOLID,1,Current->clearpixel);\r
- HBRUSH Brush=CreateSolidBrush(Current->clearpixel);\r
- HPEN Old_Pen=SelectObject(DC,Pen);\r
- HBRUSH Old_Brush=SelectObject(DC,Brush);\r
- Rectangle(DC,x,y,x+width,y+height);\r
- SelectObject(DC,Old_Pen);\r
- SelectObject(DC,Old_Brush);\r
- DeleteObject(Pen);\r
- DeleteObject(Brush);\r
- DD_RELEASEDC;\r
- }\r
-\r
-\r
-\r
- ENDPROFILE(clear)\r
-\r
- return mask; // TODO: I doubt this is correct. dd.h doesn't explain what this should\r
- // be...\r
-}\r
-\r
-\r
-\r
-static void enable( GLcontext* ctx, GLenum pname, GLboolean enable )\r
-{\r
- if (!Current)\r
- return;\r
-\r
- if (pname == GL_DITHER) {\r
- if(enable == GL_FALSE){\r
- Current->dither_flag = GL_FALSE;\r
- if(Current->cColorBits == 8)\r
- Current->pixelformat = PF_INDEX8;\r
- }\r
- else{\r
- if (Current->rgb_flag && Current->cColorBits == 8){\r
- Current->pixelformat = PF_DITHER8;\r
- Current->dither_flag = GL_TRUE;\r
- }\r
- else\r
- Current->dither_flag = GL_FALSE;\r
- }\r
- }\r
-}\r
-\r
-\r
-\r
-static GLboolean set_draw_buffer( GLcontext* ctx, GLenum mode )\r
-{\r
- STARTPROFILE\r
- /* TODO: this could be better */\r
- if (mode==GL_FRONT_LEFT || mode==GL_BACK_LEFT) {\r
- return GL_TRUE;\r
- }\r
- else {\r
- return GL_FALSE;\r
- }\r
- ENDPROFILE(set_draw_buffer)\r
-}\r
-\r
-\r
-static void set_read_buffer(GLcontext *ctx, GLframebuffer *colorBuffer,\r
- GLenum buffer )\r
-{\r
- /* XXX todo */\r
- return;\r
-}\r
-\r
-\r
-\r
-/* Return characteristics of the output buffer. */\r
-static void buffer_size( GLcontext* ctx, GLuint *width, GLuint *height )\r
-{\r
- int New_Size;\r
- RECT CR;\r
-\r
- STARTPROFILE\r
- GetClientRect(Current->Window,&CR);\r
-\r
- *width=CR.right;\r
- *height=CR.bottom;\r
-\r
- New_Size=((*width)!=Current->width) || ((*height)!=Current->height);\r
-\r
- if (New_Size){\r
- Current->width=*width;\r
- Current->height=*height;\r
- Current->ScanWidth=Current->width;\r
- if ((Current->ScanWidth%sizeof(long))!=0)\r
- Current->ScanWidth+=(sizeof(long)-(Current->ScanWidth%sizeof(long)));\r
-\r
- if (Current->db_flag){\r
-#ifdef DDRAW\r
- DDDeleteOffScreen(Current);\r
- DDCreateOffScreen(Current);\r
-#else\r
- if (Current->rgb_flag==GL_TRUE && Current->dither_flag!=GL_TRUE){\r
- wmDeleteBackingStore(Current);\r
- wmCreateBackingStore(Current, Current->width, Current->height);\r
- }\r
-#endif\r
- }\r
-\r
- // Resize OsmesaBuffer if in Parallel mode\r
-#if !defined(NO_PARALLEL)\r
- if(parallelFlag)\r
- PRSizeRenderBuffer(Current->width, Current->height,Current->ScanWidth,\r
- Current->rgb_flag == GL_TRUE ? Current->pbPixels: Current->ScreenMem);\r
-#endif\r
- }\r
- ENDPROFILE(buffer_size)\r
-}\r
-\r
-\r
-\r
-/**********************************************************************/\r
-/***** Accelerated point, line, polygon rendering *****/\r
-/**********************************************************************/\r
-\r
-\r
-static void fast_rgb_points( GLcontext* ctx, GLuint first, GLuint last )\r
-{\r
-#if 0\r
- GLuint i;\r
- // HDC DC=DD_GETDC;\r
- PWMC pwc = Current;\r
-\r
- STARTPROFILE\r
-\r
- if (0 /*Current->gl_ctx->VB->MonoColor*/) {\r
- /* all drawn with current color */\r
- for (i=first;i<=last;i++) {\r
- if (!Current->gl_ctx->VB->ClipMask[i]) {\r
- int x, y;\r
- x = (GLint) Current->gl_ctx->VB->Win.data[i][0];\r
- y = FLIP( (GLint) Current->gl_ctx->VB->Win.data[i][1] );\r
- wmSetPixel(pwc, y,x,GetRValue(Current->pixel),\r
- GetGValue(Current->pixel), GetBValue(Current->pixel));\r
- }\r
- }\r
- }\r
- else {\r
- /* draw points of different colors */\r
- for (i=first;i<=last;i++) {\r
- if (!Current->gl_ctx->VB->ClipMask[i]) {\r
- int x, y;\r
- unsigned long pixel=RGB(Current->gl_ctx->VB->ColorPtr->data[i][0]*255.0,\r
- Current->gl_ctx->VB->ColorPtr->data[i][1]*255.0,\r
- Current->gl_ctx->VB->ColorPtr->data[i][2]*255.0);\r
- x = (GLint) Current->gl_ctx->VB->Win.data[i][0];\r
- y = FLIP( (GLint) Current->gl_ctx->VB->Win.data[i][1] );\r
- wmSetPixel(pwc, y,x,Current->gl_ctx->VB->ColorPtr->data[i][0]*255.0,\r
- Current->gl_ctx->VB->ColorPtr->data[i][1]*255.0,\r
- Current->gl_ctx->VB->ColorPtr->data[i][2]*255.0);\r
- }\r
- }\r
- }\r
- // DD_RELEASEDC;\r
- ENDPROFILE(fast_rgb_points)\r
-#endif\r
-}\r
-\r
-\r
-\r
-/* Return pointer to accerated points function */\r
-extern /*points_func*/ choose_points_function( GLcontext* ctx )\r
-{\r
-#if 0\r
- STARTPROFILE\r
- if (ctx->Point.Size==1.0 && !ctx->Point.SmoothFlag && ctx->_RasterMask==0\r
- && !ctx->Texture._ReallyEnabled && ctx->Visual->RGBAflag) {\r
- ENDPROFILE(choose_points_function)\r
- return fast_rgb_points;\r
- }\r
- else {\r
- ENDPROFILE(choose_points_function)\r
- return NULL;\r
- }\r
-#endif\r
-}\r
-\r
-\r
-\r
-/* Draw a line using the color specified by Current->gl_ctx->VB->ColorPtr->data[pv] */\r
-static void fast_flat_rgb_line( GLcontext* ctx, GLuint v0, GLuint v1, GLuint pv )\r
-{\r
-#if 0\r
- STARTPROFILE\r
- int x0, y0, x1, y1;\r
- unsigned long pixel;\r
- HDC DC=DD_GETDC;\r
- HPEN Pen;\r
- HPEN Old_Pen;\r
-\r
- if (0 /*Current->gl_ctx->VB->MonoColor*/) {\r
- pixel = Current->pixel; /* use current color */\r
- }\r
- else {\r
- pixel = RGB(Current->gl_ctx->VB->ColorPtr->data[pv][0]*255.0, Current->gl_ctx->VB->ColorPtr->data[pv][1]*255.0, Current->gl_ctx->VB->ColorPtr->data[pv][2]*255.0);\r
- }\r
-\r
- x0 = (int) Current->gl_ctx->VB->Win.data[v0][0];\r
- y0 = FLIP( (int) Current->gl_ctx->VB->Win.data[v0][1] );\r
- x1 = (int) Current->gl_ctx->VB->Win.data[v1][0];\r
- y1 = FLIP( (int) Current->gl_ctx->VB->Win.data[v1][1] );\r
-\r
-\r
- BEGINGDICALL\r
-\r
- Pen=CreatePen(PS_SOLID,1,pixel);\r
- Old_Pen=SelectObject(DC,Pen);\r
- MoveToEx(DC,x0,y0,NULL);\r
- LineTo(DC,x1,y1);\r
- SelectObject(DC,Old_Pen);\r
- DeleteObject(Pen);\r
- DD_RELEASEDC;\r
-\r
- ENDGDICALL\r
-\r
- ENDPROFILE(fast_flat_rgb_line)\r
-#endif\r
-}\r
-\r
-\r
-\r
-/* Return pointer to accerated line function */\r
-static /*line_func*/ choose_line_function( GLcontext* ctx )\r
-{\r
-#if 0\r
- STARTPROFILE\r
- if (ctx->Line.Width==1.0 && !ctx->Line.SmoothFlag && !ctx->Line.StippleFlag\r
- && ctx->Light.ShadeModel==GL_FLAT && ctx->_RasterMask==0\r
- && !ctx->Texture._ReallyEnabled && Current->rgb_flag) {\r
- ENDPROFILE(choose_line_function)\r
- return fast_flat_rgb_line;\r
- }\r
- else {\r
- ENDPROFILE(choose_line_function)\r
- return NULL;\r
- }\r
-#endif\r
-}\r
-\r
-\r
-/**********************************************************************/\r
-/***** Span-based pixel drawing *****/\r
-/**********************************************************************/\r
-\r
-\r
-/* Write a horizontal span of 32-bit color-index pixels with a boolean mask. */\r
-static void write_ci32_span( const GLcontext* ctx,\r
- GLuint n, GLint x, GLint y,\r
- const GLuint index[],\r
- const GLubyte mask[] )\r
-{\r
- STARTPROFILE\r
- GLuint i;\r
- PBYTE Mem=Current->ScreenMem+FLIP(y)*Current->ScanWidth+x;\r
- assert(Current->rgb_flag==GL_FALSE);\r
- for (i=0; i<n; i++)\r
- if (mask[i])\r
- Mem[i]=index[i];\r
- ENDPROFILE(write_ci32_span)\r
-}\r
-\r
-\r
-/* Write a horizontal span of 8-bit color-index pixels with a boolean mask. */\r
-static void write_ci8_span( const GLcontext* ctx,\r
- GLuint n, GLint x, GLint y,\r
- const GLubyte index[],\r
- const GLubyte mask[] )\r
-{\r
- STARTPROFILE\r
- GLuint i;\r
- PBYTE Mem=Current->ScreenMem+FLIP(y)*Current->ScanWidth+x;\r
- assert(Current->rgb_flag==GL_FALSE);\r
- for (i=0; i<n; i++)\r
- if (mask[i])\r
- Mem[i]=index[i];\r
- ENDPROFILE(write_ci8_span)\r
-}\r
-\r
-\r
-\r
-/*\r
-* Write a horizontal span of pixels with a boolean mask. The current\r
-* color index is used for all pixels.\r
-*/\r
-static void write_mono_ci_span(const GLcontext* ctx,\r
- GLuint n,GLint x,GLint y,\r
- GLuint colorIndex, const GLubyte mask[])\r
-{\r
- STARTPROFILE\r
- GLuint i;\r
- BYTE *Mem=Current->ScreenMem+FLIP(y)*Current->ScanWidth+x;\r
- assert(Current->rgb_flag==GL_FALSE);\r
- for (i=0; i<n; i++)\r
- if (mask[i])\r
- Mem[i]=colorIndex;\r
- ENDPROFILE(write_mono_ci_span)\r
-}\r
-\r
-/*\r
- * To improve the performance of this routine, frob the data into an actual\r
- * scanline and call bitblt on the complete scan line instead of SetPixel.\r
- */\r
-\r
-/* Write a horizontal span of RGBA color pixels with a boolean mask. */\r
-static void write_rgba_span( const GLcontext* ctx, GLuint n, GLint x, GLint y,\r
- const GLubyte rgba[][4], const GLubyte mask[] )\r
-{\r
- STARTPROFILE\r
- PWMC pwc = Current;\r
-\r
- if (pwc->rgb_flag==GL_TRUE)\r
- {\r
- GLuint i;\r
- HDC DC=DD_GETDC;\r
- y=FLIP(y);\r
- if (mask) {\r
- for (i=0; i<n; i++)\r
- if (mask[i])\r
- wmSetPixel(pwc, y, x + i, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);\r
- }\r
- else {\r
- for (i=0; i<n; i++)\r
- wmSetPixel(pwc, y, x + i, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );\r
- }\r
- DD_RELEASEDC;\r
- }\r
- else\r
- {\r
- GLuint i;\r
- BYTE *Mem=Current->ScreenMem+y*Current->ScanWidth+x;\r
- y = FLIP(y);\r
- if (mask) {\r
- for (i=0; i<n; i++)\r
- if (mask[i])\r
- Mem[i] = GetNearestPaletteIndex(Current->hPal,RGB(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]));\r
- }\r
- else {\r
- for (i=0; i<n; i++)\r
- Mem[i] = GetNearestPaletteIndex(Current->hPal,RGB(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]));\r
- }\r
- }\r
- ENDPROFILE(write_rgba_span)\r
-\r
-}\r
-\r
-/* Write a horizontal span of RGB color pixels with a boolean mask. */\r
-static void write_rgb_span( const GLcontext* ctx,\r
- GLuint n, GLint x, GLint y,\r
- const GLubyte rgb[][3], const GLubyte mask[] )\r
-{\r
- STARTPROFILE\r
- PWMC pwc = Current;\r
-\r
- if (pwc->rgb_flag==GL_TRUE)\r
- {\r
- GLuint i;\r
- HDC DC=DD_GETDC;\r
- y=FLIP(y);\r
- if (mask) {\r
- for (i=0; i<n; i++)\r
- if (mask[i])\r
- wmSetPixel(pwc, y, x + i, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);\r
- }\r
- else {\r
- for (i=0; i<n; i++)\r
- wmSetPixel(pwc, y, x + i, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );\r
- }\r
- DD_RELEASEDC;\r
- }\r
- else\r
- {\r
- GLuint i;\r
- BYTE *Mem=Current->ScreenMem+y*Current->ScanWidth+x;\r
- y = FLIP(y);\r
- if (mask) {\r
- for (i=0; i<n; i++)\r
- if (mask[i])\r
- Mem[i] = GetNearestPaletteIndex(Current->hPal,RGB(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]));\r
- }\r
- else {\r
- for (i=0; i<n; i++)\r
- Mem[i] = GetNearestPaletteIndex(Current->hPal,RGB(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]));\r
- }\r
- }\r
- ENDPROFILE(write_rgb_span)\r
-\r
-}\r
-\r
-/*\r
-* Write a horizontal span of pixels with a boolean mask. The current color\r
-* is used for all pixels.\r
-*/\r
-static void write_mono_rgba_span( const GLcontext* ctx,\r
- GLuint n, GLint x, GLint y,\r
- const GLchan color[4], const GLubyte mask[])\r
-{\r
- ULONG pixel = RGB( color[RCOMP], color[GCOMP], color[BCOMP] );\r
- STARTPROFILE\r
- GLuint i;\r
- HDC DC=DD_GETDC;\r
- PWMC pwc = Current;\r
- assert(Current->rgb_flag==GL_TRUE);\r
- y=FLIP(y);\r
- if(Current->rgb_flag==GL_TRUE){\r
- for (i=0; i<n; i++)\r
- if (mask[i])\r
- // Trying\r
- wmSetPixel(pwc,y,x+i,color[RCOMP], color[GCOMP], color[BCOMP]);\r
- }\r
- else {\r
- for (i=0; i<n; i++)\r
- if (mask[i])\r
- SetPixel(DC, y, x+i, pixel);\r
- }\r
- DD_RELEASEDC;\r
- ENDPROFILE(write_mono_rgba_span)\r
-}\r
-\r
-\r
-\r
-/**********************************************************************/\r
-/***** Array-based pixel drawing *****/\r
-/**********************************************************************/\r
-\r
-\r
-/* Write an array of 32-bit index pixels with a boolean mask. */\r
-static void write_ci32_pixels( const GLcontext* ctx,\r
- GLuint n, const GLint x[], const GLint y[],\r
- const GLuint index[], const GLubyte mask[] )\r
-{\r
- STARTPROFILE\r
- GLuint i;\r
- assert(Current->rgb_flag==GL_FALSE);\r
- for (i=0; i<n; i++) {\r
- if (mask[i]) {\r
- BYTE *Mem=Current->ScreenMem+FLIP(y[i])*Current->ScanWidth+x[i];\r
- *Mem = index[i];\r
- }\r
- }\r
- ENDPROFILE(write_ci32_pixels)\r
-}\r
-\r
-\r
-\r
-/*\r
-* Write an array of pixels with a boolean mask. The current color\r
-* index is used for all pixels.\r
-*/\r
-static void write_mono_ci_pixels( const GLcontext* ctx,\r
- GLuint n,\r
- const GLint x[], const GLint y[],\r
- GLuint colorIndex, const GLubyte mask[] )\r
-{\r
- STARTPROFILE\r
- GLuint i;\r
- assert(Current->rgb_flag==GL_FALSE);\r
- for (i=0; i<n; i++) {\r
- if (mask[i]) {\r
- BYTE *Mem=Current->ScreenMem+FLIP(y[i])*Current->ScanWidth+x[i];\r
- *Mem = colorIndex;\r
- }\r
- }\r
- ENDPROFILE(write_mono_ci_pixels)\r
-}\r
-\r
-\r
-\r
-/* Write an array of RGBA pixels with a boolean mask. */\r
-static void write_rgba_pixels( const GLcontext* ctx,\r
- GLuint n, const GLint x[], const GLint y[],\r
- const GLubyte rgba[][4], const GLubyte mask[] )\r
-{\r
- STARTPROFILE\r
- GLuint i;\r
- PWMC pwc = Current;\r
- HDC DC=DD_GETDC;\r
- assert(Current->rgb_flag==GL_TRUE);\r
- for (i=0; i<n; i++)\r
- if (mask[i])\r
- wmSetPixel(pwc, FLIP(y[i]), x[i],\r
- rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);\r
- DD_RELEASEDC;\r
- ENDPROFILE(write_rgba_pixels)\r
-}\r
-\r
-\r
-\r
-/*\r
-* Write an array of pixels with a boolean mask. The current color\r
-* is used for all pixels.\r
-*/\r
-static void write_mono_rgba_pixels( const GLcontext* ctx,\r
- GLuint n,\r
- const GLint x[], const GLint y[],\r
- const GLchan color[4],\r
- const GLubyte mask[] )\r
-{\r
- STARTPROFILE\r
- GLuint i;\r
- PWMC pwc = Current;\r
- HDC DC=DD_GETDC;\r
- assert(Current->rgb_flag==GL_TRUE);\r
- for (i=0; i<n; i++)\r
- if (mask[i])\r
- wmSetPixel(pwc, FLIP(y[i]),x[i],color[RCOMP],\r
- color[GCOMP], color[BCOMP]);\r
- DD_RELEASEDC;\r
- ENDPROFILE(write_mono_rgba_pixels)\r
-}\r
-\r
-\r
-\r
-/**********************************************************************/\r
-/***** Read spans/arrays of pixels *****/\r
-/**********************************************************************/\r
-\r
-\r
-/* Read a horizontal span of color-index pixels. */\r
-static void read_ci32_span( const GLcontext* ctx, GLuint n, GLint x, GLint y,\r
- GLuint index[])\r
-{\r
- STARTPROFILE\r
- GLuint i;\r
- BYTE *Mem=Current->ScreenMem+FLIP(y)*Current->ScanWidth+x;\r
- assert(Current->rgb_flag==GL_FALSE);\r
- for (i=0; i<n; i++)\r
- index[i]=Mem[i];\r
- ENDPROFILE(read_ci32_span)\r
-}\r
-\r
-\r
-\r
-\r
-/* Read an array of color index pixels. */\r
-static void read_ci32_pixels( const GLcontext* ctx,\r
- GLuint n, const GLint x[], const GLint y[],\r
- GLuint indx[], const GLubyte mask[] )\r
-{\r
- STARTPROFILE\r
- GLuint i;\r
- assert(Current->rgb_flag==GL_FALSE);\r
- for (i=0; i<n; i++) {\r
- if (mask[i]) {\r
- indx[i]=*(Current->ScreenMem+FLIP(y[i])*Current->ScanWidth+x[i]);\r
- }\r
- }\r
- ENDPROFILE(read_ci32_pixels)\r
-}\r
-\r
-\r
-\r
-/* Read a horizontal span of color pixels. */\r
-static void read_rgba_span( const GLcontext* ctx,\r
- GLuint n, GLint x, GLint y,\r
- GLubyte rgba[][4] )\r
-{\r
- STARTPROFILE\r
- UINT i;\r
- COLORREF Color;\r
- HDC DC=DD_GETDC;\r
- assert(Current->rgb_flag==GL_TRUE);\r
- /* y=FLIP(y);*/\r
- y = Current->height - y - 1;\r
- for (i=0; i<n; i++) {\r
- Color=GetPixel(DC,x+i,y);\r
- rgba[i][RCOMP] = GetRValue(Color);\r
- rgba[i][GCOMP] = GetGValue(Color);\r
- rgba[i][BCOMP] = GetBValue(Color);\r
- rgba[i][ACOMP] = 255;\r
- }\r
- DD_RELEASEDC;\r
-// Brian P. Has mentioned to comment this out.\r
-// memset(alpha,0,n*sizeof(GLubyte));\r
- ENDPROFILE(read_rgba_span)\r
-}\r
-\r
-\r
-/* Read an array of color pixels. */\r
-static void read_rgba_pixels( const GLcontext* ctx,\r
- GLuint n, const GLint x[], const GLint y[],\r
- GLubyte rgba[][4], const GLubyte mask[] )\r
-{\r
- STARTPROFILE\r
- GLuint i;\r
- COLORREF Color;\r
- HDC DC=DD_GETDC;\r
- assert(Current->rgb_flag==GL_TRUE);\r
- for (i=0; i<n; i++) {\r
- if (mask[i]) {\r
- GLint y2 = Current->height - y[i] - 1;\r
- Color=GetPixel(DC,x[i],y2);\r
- rgba[i][RCOMP] = GetRValue(Color);\r
- rgba[i][GCOMP] = GetGValue(Color);\r
- rgba[i][BCOMP] = GetBValue(Color);\r
- rgba[i][ACOMP] = 255;\r
- }\r
- }\r
- DD_RELEASEDC;\r
-// Brian P. has mentioned to comment this out.\r
-// memset(alpha,0,n*sizeof(GLint));\r
- ENDPROFILE(read_rgba_pixels)\r
-}\r
-\r
-\r
-\r
-/**********************************************************************/\r
-/**********************************************************************/\r
-\r
-\r
-static const GLubyte *get_string(GLcontext *ctx, GLenum name)\r
-{\r
- if (name == GL_RENDERER) {\r
- return (GLubyte *) "Mesa Windows";\r
- }\r
- else {\r
- return NULL;\r
- }\r
-}\r
-\r
-\r
-\r
-void setup_DD_pointers( GLcontext* ctx )\r
-{\r
-#if 0\r
- ctx->Driver.GetString = get_string;\r
- ctx->Driver.UpdateState = setup_DD_pointers;\r
- ctx->Driver.GetBufferSize = buffer_size;\r
- ctx->Driver.Finish = finish;\r
- ctx->Driver.Flush = flush;\r
-\r
- ctx->Driver.ClearIndex = clear_index;\r
- ctx->Driver.ClearColor = clear_color;\r
- ctx->Driver.Clear = clear;\r
-\r
- ctx->Driver.Enable = enable;\r
-\r
- ctx->Driver.SetDrawBuffer = set_draw_buffer;\r
- ctx->Driver.SetReadBuffer = set_read_buffer;\r
- ctx->Driver.GetBufferSize = buffer_size;\r
-\r
- ctx->Driver.PointsFunc = choose_points_function(ctx);\r
- ctx->Driver.LineFunc = choose_line_function(ctx);\r
- ctx->Driver.TriangleFunc = choose_triangle_function( ctx );\r
-\r
- /* Pixel/span writing functions: */\r
- ctx->Driver.WriteRGBASpan = write_rgba_span;\r
- ctx->Driver.WriteRGBSpan = write_rgb_span;\r
- ctx->Driver.WriteMonoRGBASpan = write_mono_rgba_span;\r
- ctx->Driver.WriteRGBAPixels = write_rgba_pixels;\r
- ctx->Driver.WriteMonoRGBAPixels = write_mono_rgba_pixels;\r
- ctx->Driver.WriteCI32Span = write_ci32_span;\r
- ctx->Driver.WriteCI8Span = write_ci8_span;\r
- ctx->Driver.WriteMonoCISpan = write_mono_ci_span;\r
- ctx->Driver.WriteCI32Pixels = write_ci32_pixels;\r
- ctx->Driver.WriteMonoCIPixels = write_mono_ci_pixels;\r
-\r
- ctx->Driver.ReadCI32Span = read_ci32_span;\r
- ctx->Driver.ReadRGBASpan = read_rgba_span;\r
- ctx->Driver.ReadCI32Pixels = read_ci32_pixels;\r
- ctx->Driver.ReadRGBAPixels = read_rgba_pixels;\r
-#endif\r
-}\r
-\r
-\r
-/**********************************************************************/\r
-/***** WMesa API Functions *****/\r
-/**********************************************************************/\r
-\r
-\r
-\r
-#define PAL_SIZE 256\r
-static void GetPalette(HPALETTE Pal,RGBQUAD *aRGB)\r
-{\r
- STARTPROFILE\r
- int i;\r
- HDC hdc;\r
- struct\r
- {\r
- WORD Version;\r
- WORD NumberOfEntries;\r
- PALETTEENTRY aEntries[PAL_SIZE];\r
- } Palette =\r
- {\r
- 0x300,\r
- PAL_SIZE\r
- };\r
- hdc=GetDC(NULL);\r
- if (Pal!=NULL)\r
- GetPaletteEntries(Pal,0,PAL_SIZE,Palette.aEntries);\r
- else\r
- GetSystemPaletteEntries(hdc,0,PAL_SIZE,Palette.aEntries);\r
- if (GetSystemPaletteUse(hdc) == SYSPAL_NOSTATIC)\r
- {\r
- for(i = 0; i <PAL_SIZE; i++)\r
- Palette.aEntries[i].peFlags = PC_RESERVED;\r
- Palette.aEntries[255].peRed = 255;\r
- Palette.aEntries[255].peGreen = 255;\r
- Palette.aEntries[255].peBlue = 255;\r
- Palette.aEntries[255].peFlags = 0;\r
- Palette.aEntries[0].peRed = 0;\r
- Palette.aEntries[0].peGreen = 0;\r
- Palette.aEntries[0].peBlue = 0;\r
- Palette.aEntries[0].peFlags = 0;\r
- }\r
- else\r
- {\r
- int nStaticColors;\r
- int nUsableColors;\r
- nStaticColors = GetDeviceCaps(hdc, NUMCOLORS)/2;\r
- for (i=0; i<nStaticColors; i++)\r
- Palette.aEntries[i].peFlags = 0;\r
- nUsableColors = PAL_SIZE-nStaticColors;\r
- for (; i<nUsableColors; i++)\r
- Palette.aEntries[i].peFlags = PC_RESERVED;\r
- for (; i<PAL_SIZE-nStaticColors; i++)\r
- Palette.aEntries[i].peFlags = PC_RESERVED;\r
- for (i=PAL_SIZE-nStaticColors; i<PAL_SIZE; i++)\r
- Palette.aEntries[i].peFlags = 0;\r
- }\r
- ReleaseDC(NULL,hdc);\r
- for (i=0; i<PAL_SIZE; i++)\r
- {\r
- aRGB[i].rgbRed=Palette.aEntries[i].peRed;\r
- aRGB[i].rgbGreen=Palette.aEntries[i].peGreen;\r
- aRGB[i].rgbBlue=Palette.aEntries[i].peBlue;\r
- aRGB[i].rgbReserved=Palette.aEntries[i].peFlags;\r
- }\r
- ENDPROFILE(GetPalette)\r
-}\r
-\r
-\r
-WMesaContext WMesaCreateContext( HWND hWnd, HPALETTE* Pal,\r
- GLboolean rgb_flag,\r
- GLboolean db_flag )\r
-{\r
- RECT CR;\r
- WMesaContext c;\r
- GLboolean true_color_flag;\r
- c = (struct wmesa_context * ) calloc(1,sizeof(struct wmesa_context));\r
- if (!c)\r
- return NULL;\r
-\r
- c->Window=hWnd;\r
- c->hDC = GetDC(hWnd);\r
- true_color_flag = GetDeviceCaps(c->hDC, BITSPIXEL) > 8;\r
-#ifdef DDRAW\r
- if(true_color_flag) c->rgb_flag = rgb_flag = GL_TRUE;\r
-#endif\r
-\r
-\r
-#ifdef DITHER\r
- if ((true_color_flag==GL_FALSE) && (rgb_flag == GL_TRUE)){\r
- c->dither_flag = GL_TRUE;\r
- c->hPalHalfTone = WinGCreateHalftonePalette();\r
- }\r
- else\r
- c->dither_flag = GL_FALSE;\r
-#else\r
- c->dither_flag = GL_FALSE;\r
-#endif\r
-\r
-\r
- if (rgb_flag==GL_FALSE)\r
- {\r
- c->rgb_flag = GL_FALSE;\r
- // c->pixel = 1;\r
- c->db_flag = db_flag =GL_TRUE; // WinG requires double buffering\r
- printf("Single buffer is not supported in color index mode, setting to double buffer.\n");\r
- }\r
- else\r
- {\r
- c->rgb_flag = GL_TRUE;\r
- // c->pixel = 0;\r
- }\r
- GetClientRect(c->Window,&CR);\r
- c->width=CR.right;\r
- c->height=CR.bottom;\r
- if (db_flag)\r
- {\r
- c->db_flag = 1;\r
- /* Double buffered */\r
-#ifndef DDRAW\r
- // if (c->rgb_flag==GL_TRUE && c->dither_flag != GL_TRUE )\r
- {\r
- wmCreateBackingStore(c, c->width, c->height);\r
-\r
- }\r
-#endif\r
- }\r
- else\r
- {\r
- /* Single Buffered */\r
- if (c->rgb_flag)\r
- c->db_flag = 0;\r
- }\r
-#ifdef DDRAW\r
- if (DDInit(c,hWnd) == GL_FALSE) {\r
- free( (void *) c );\r
- exit(1);\r
- }\r
-#endif\r
-\r
-\r
- c->gl_visual = _mesa_create_visual(rgb_flag,\r
- db_flag, /* db_flag */\r
- GL_FALSE, /* stereo */\r
- 8,8,8,8, /* r, g, b, a bits */\r
- 0, /* index bits */\r
- 16, /* depth_bits */\r
- 8, /* stencil_bits */\r
- 16,16,16,16,/* accum_bits */\r
- 1);\r
-\r
- if (!c->gl_visual) {\r
- return NULL;\r
- }\r
-\r
- /* allocate a new Mesa context */\r
- c->gl_ctx = _mesa_create_context( c->gl_visual, NULL, c, GL_TRUE);\r
-\r
- if (!c->gl_ctx) {\r
- _mesa_destroy_visual( c->gl_visual );\r
- free(c);\r
- return NULL;\r
- }\r
-\r
- _mesa_enable_sw_extensions(c->gl_ctx);\r
-#if 0\r
- c->gl_buffer = _mesa_create_framebuffer( c->gl_visual,\r
- c->gl_visual->DepthBits > 0,\r
- c->gl_visual->StencilBits > 0,\r
- c->gl_visual->AccumRedBits > 0,\r
- c->gl_visual->AlphaBits > 0 );\r
-#endif\r
- c->gl_buffer = NULL; /* TEMP */\r
- if (!c->gl_buffer) {\r
- _mesa_destroy_visual( c->gl_visual );\r
- _mesa_destroy_context( c->gl_ctx );\r
- free(c);\r
- return NULL;\r
- }\r
-\r
- c->gl_ctx->Driver.UpdateState = setup_DD_pointers;\r
-\r
- // setup_DD_pointers(c->gl_ctx);\r
-\r
- return c;\r
-}\r
-\r
-void WMesaDestroyContext( void )\r
-{\r
- WMesaContext c = Current;\r
- ReleaseDC(c->Window,c->hDC);\r
- WC = c;\r
- if(c->hPalHalfTone != NULL)\r
- DeleteObject(c->hPalHalfTone);\r
- _mesa_destroy_visual( c->gl_visual );\r
- _mesa_destroy_framebuffer( c->gl_buffer );\r
- _mesa_destroy_context( c->gl_ctx );\r
-\r
- if (c->db_flag)\r
-#ifdef DDRAW\r
- DDFree(c);\r
-#else\r
- wmDeleteBackingStore(c);\r
-#endif\r
- free( (void *) c );\r
- //Following code is added to enable parallel render\r
- // Parallel render only work in double buffer mode\r
-#if !defined(NO_PARALLEL)\r
- if(parallelMachine)\r
- PRDestroyRenderBuffer();\r
-#endif\r
- // End modification\r
-}\r
-\r
-\r
-\r
-void /*APIENTRY*/ WMesaMakeCurrent( WMesaContext c )\r
-{\r
- if(!c){\r
- Current = c;\r
- return;\r
- }\r
-\r
- //\r
- // A little optimization\r
- // If it already is current,\r
- // don't set it again\r
- //\r
- if(Current == c)\r
- return;\r
-\r
- //gl_set_context( c->gl_ctx );\r
- _mesa_make_current(c->gl_ctx, c->gl_buffer);\r
- setup_DD_pointers(c->gl_ctx);\r
- Current = c;\r
- if (Current->gl_ctx->Viewport.Width==0) {\r
- /* initialize viewport to window size */\r
- _mesa_set_viewport( Current->gl_ctx,\r
- 0, 0, Current->width, Current->height );\r
- }\r
- if ((c->cColorBits <= 8 ) && (c->rgb_flag == GL_TRUE)){\r
- WMesaPaletteChange(c->hPalHalfTone);\r
- }\r
-}\r
-\r
-\r
-\r
-void /*APIENTRY*/ WMesaSwapBuffers( void )\r
-{\r
- HDC DC = Current->hDC;\r
- GET_CURRENT_CONTEXT(ctx);\r
-\r
- /* If we're swapping the buffer associated with the current context\r
- * we have to flush any pending rendering commands first.\r
- */\r
- if (Current && Current->gl_ctx == ctx)\r
- _mesa_swapbuffers(ctx);\r
-\r
- if (Current->db_flag)\r
- wmFlush(Current);\r
-}\r
-\r
-\r
-\r
-void /*APIENTRY*/ WMesaPaletteChange(HPALETTE Pal)\r
-{\r
- int vRet;\r
- LPPALETTEENTRY pPal;\r
- if (Current && (Current->rgb_flag==GL_FALSE || Current->dither_flag == GL_TRUE))\r
- {\r
- pPal = (PALETTEENTRY *)malloc( 256 * sizeof(PALETTEENTRY));\r
- Current->hPal=Pal;\r
- // GetPaletteEntries( Pal, 0, 256, pPal );\r
- GetPalette( Pal, pPal );\r
-#ifdef DDRAW\r
- Current->lpDD->lpVtbl->CreatePalette(Current->lpDD,DDPCAPS_8BIT,\r
- pPal, &(Current->lpDDPal), NULL);\r
- if (Current->lpDDPal)\r
- Current->lpDDSPrimary->lpVtbl->SetPalette(Current->lpDDSPrimary,Current->lpDDPal);\r
-#else\r
- vRet = SetDIBColorTable(Current->dib.hDC,0,256,pPal);\r
-#endif\r
- free( pPal );\r
- }\r
-\r
-}\r
-\r
-\r
-\r
-\r
-static unsigned char threeto8[8] = {\r
- 0, 0111>>1, 0222>>1, 0333>>1, 0444>>1, 0555>>1, 0666>>1, 0377\r
-};\r
-\r
-static unsigned char twoto8[4] = {\r
- 0, 0x55, 0xaa, 0xff\r
-};\r
-\r
-static unsigned char oneto8[2] = {\r
- 0, 255\r
-};\r
-\r
-static unsigned char componentFromIndex(UCHAR i, UINT nbits, UINT shift)\r
-{\r
- unsigned char val;\r
-\r
- val = i >> shift;\r
- switch (nbits) {\r
-\r
- case 1:\r
- val &= 0x1;\r
- return oneto8[val];\r
-\r
- case 2:\r
- val &= 0x3;\r
- return twoto8[val];\r
-\r
- case 3:\r
- val &= 0x7;\r
- return threeto8[val];\r
-\r
- default:\r
- return 0;\r
- }\r
-}\r
-\r
-void /*WINAPI*/ wmCreatePalette( PWMC pwdc )\r
-{\r
- /* Create a compressed and re-expanded 3:3:2 palette */\r
- int i;\r
- LOGPALETTE *pPal;\r
- BYTE rb, rs, gb, gs, bb, bs;\r
-\r
- pwdc->nColors = 0x100;\r
-\r
- pPal = (PLOGPALETTE)malloc(sizeof(LOGPALETTE) + pwdc->nColors * sizeof(PALETTEENTRY));\r
- memset( pPal, 0, sizeof(LOGPALETTE) + pwdc->nColors * sizeof(PALETTEENTRY) );\r
-\r
- pPal->palVersion = 0x300;\r
-\r
- rb = REDBITS;\r
- rs = REDSHIFT;\r
- gb = GREENBITS;\r
- gs = GREENSHIFT;\r
- bb = BLUEBITS;\r
- bs = BLUESHIFT;\r
-\r
- if (pwdc->db_flag) {\r
-\r
- /* Need to make two palettes: one for the screen DC and one for the DIB. */\r
- pPal->palNumEntries = pwdc->nColors;\r
- for (i = 0; i < pwdc->nColors; i++) {\r
- pPal->palPalEntry[i].peRed = componentFromIndex( i, rb, rs );\r
- pPal->palPalEntry[i].peGreen = componentFromIndex( i, gb, gs );\r
- pPal->palPalEntry[i].peBlue = componentFromIndex( i, bb, bs );\r
- pPal->palPalEntry[i].peFlags = 0;\r
- }\r
- pwdc->hGLPalette = CreatePalette( pPal );\r
- pwdc->hPalette = CreatePalette( pPal );\r
- }\r
-\r
- else {\r
- pPal->palNumEntries = pwdc->nColors;\r
- for (i = 0; i < pwdc->nColors; i++) {\r
- pPal->palPalEntry[i].peRed = componentFromIndex( i, rb, rs );\r
- pPal->palPalEntry[i].peGreen = componentFromIndex( i, gb, gs );\r
- pPal->palPalEntry[i].peBlue = componentFromIndex( i, bb, bs );\r
- pPal->palPalEntry[i].peFlags = 0;\r
- }\r
- pwdc->hGLPalette = CreatePalette( pPal );\r
- }\r
-\r
- free(pPal);\r
-\r
-}\r
-\r
-void /*WINAPI*/ wmSetPixel(PWMC pwc, int iScanLine, int iPixel, BYTE r, BYTE g, BYTE b)\r
-{\r
- if (Current->db_flag) {\r
- LPBYTE lpb = pwc->pbPixels;\r
- LPDWORD lpdw;\r
- LPWORD lpw;\r
- UINT nBypp = pwc->cColorBits >> 3;\r
- UINT nOffset = iPixel % nBypp;\r
-\r
- // Move the pixel buffer pointer to the scanline that we\r
- // want to access\r
-\r
- // pwc->dib.fFlushed = FALSE;\r
-\r
- lpb += pwc->ScanWidth * iScanLine;\r
- // Now move to the desired pixel\r
- lpb += iPixel * nBypp;\r
- lpb = PIXELADDR(iPixel, iScanLine);\r
- lpdw = (LPDWORD)lpb;\r
- lpw = (LPWORD)lpb;\r
-\r
- if(nBypp == 1){\r
- if(pwc->dither_flag)\r
- *lpb = DITHER_RGB_2_8BIT(r,g,b,iScanLine,iPixel);\r
- else\r
- *lpb = BGR8(r,g,b);\r
- }\r
- else if(nBypp == 2)\r
- *lpw = BGR16(r,g,b);\r
- else if (nBypp == 3){\r
- *lpdw = BGR24(r,g,b);\r
- }\r
- else if (nBypp == 4)\r
- *lpdw = BGR32(r,g,b);\r
- }\r
- else{\r
- SetPixel(Current->hDC, iPixel, iScanLine, RGB(r,g,b));\r
- DD_RELEASEDC;\r
- }\r
-}\r
-\r
-void /*WINAPI*/ wmCreateDIBSection(\r
- HDC hDC,\r
- PWMC pwc, // handle of device context\r
- CONST BITMAPINFO *pbmi, // address of structure containing bitmap size, format, and color data\r
- UINT iUsage // color data type indicator: RGB values or palette indices\r
- )\r
-{\r
- DWORD dwSize = 0;\r
- DWORD dwScanWidth;\r
- UINT nBypp = pwc->cColorBits / 8;\r
- HDC hic;\r
-\r
- dwScanWidth = (((pwc->ScanWidth * nBypp)+ 3) & ~3);\r
-\r
- pwc->ScanWidth =pwc->pitch = dwScanWidth;\r
-\r
- if (stereo_flag)\r
- pwc->ScanWidth = 2* pwc->pitch;\r
-\r
- dwSize = sizeof(BITMAPINFO) + (dwScanWidth * pwc->height);\r
-\r
- pwc->dib.hFileMap = CreateFileMapping((HANDLE)PAGE_FILE,\r
- NULL,\r
- PAGE_READWRITE | SEC_COMMIT,\r
- 0,\r
- dwSize,\r
- NULL);\r
-\r
- if (!pwc->dib.hFileMap)\r
- return;\r
-\r
- pwc->dib.base = MapViewOfFile(pwc->dib.hFileMap,\r
- FILE_MAP_ALL_ACCESS,\r
- 0,\r
- 0,\r
- 0);\r
-\r
- if(!pwc->dib.base){\r
- CloseHandle(pwc->dib.hFileMap);\r
- return;\r
- }\r
-\r
- // pwc->pbPixels = pwc->addrOffScreen = ((LPBYTE)pwc->dib.base) + sizeof(BITMAPINFO);\r
-\r
- // pwc->dib.hDC = CreateCompatibleDC(hDC);\r
-\r
- CopyMemory(pwc->dib.base, pbmi, sizeof(BITMAPINFO));\r
-\r
- hic = CreateIC("display", NULL, NULL, NULL);\r
- pwc->dib.hDC = CreateCompatibleDC(hic);\r
-\r
-\r
- /* pwc->hbmDIB = CreateDIBitmap(hic,\r
- &(pwc->bmi.bmiHeader),\r
- CBM_INIT,\r
- pwc->pbPixels,\r
- &(pwc->bmi),\r
- DIB_RGB_COLORS);\r
- */\r
- pwc->hbmDIB = CreateDIBSection(hic,\r
- &(pwc->bmi),\r
- (iUsage ? DIB_PAL_COLORS : DIB_RGB_COLORS),\r
- &(pwc->pbPixels),\r
- pwc->dib.hFileMap,\r
- 0);\r
- /*\r
- pwc->hbmDIB = CreateDIBSection(hic,\r
- &(pwc->bmi),\r
- DIB_RGB_COLORS,\r
- &(pwc->pbPixels),\r
- pwc->dib.hFileMap,\r
- 0);\r
- */\r
- pwc->ScreenMem = pwc->addrOffScreen = pwc->pbPixels;\r
- pwc->hOldBitmap = SelectObject(pwc->dib.hDC, pwc->hbmDIB);\r
-\r
- DeleteDC(hic);\r
-\r
- return;\r
-\r
-}\r
-\r
-//\r
-// Blit memory DC to screen DC\r
-//\r
-BOOL /*WINAPI*/ wmFlush(PWMC pwc)\r
-{\r
- BOOL bRet = 0;\r
- DWORD dwErr = 0;\r
-#ifdef DDRAW\r
- HRESULT ddrval;\r
-#endif\r
-\r
- // Now search through the torus frames and mark used colors\r
- if(pwc->db_flag){\r
-#ifdef DDRAW\r
- if (pwc->lpDDSOffScreen == NULL)\r
- if(DDCreateOffScreen(pwc) == GL_FALSE)\r
- return;\r
-\r
- pwc->lpDDSOffScreen->lpVtbl->Unlock(pwc->lpDDSOffScreen, NULL);\r
-\r
- while( 1 )\r
- {\r
- ddrval = pwc->lpDDSPrimary->lpVtbl->Blt( pwc->lpDDSPrimary,\r
- &(pwc->rectSurface), pwc->lpDDSOffScreen, &(pwc->rectOffScreen), 0, NULL );\r
-\r
- if( ddrval == DD_OK )\r
- {\r
- break;\r
- }\r
- if( ddrval == DDERR_SURFACELOST )\r
- {\r
- if(!DDRestoreAll(pwc))\r
- {\r
- break;\r
- }\r
- }\r
- if( ddrval != DDERR_WASSTILLDRAWING )\r
- {\r
- break;\r
- }\r
- }\r
-\r
- while (pwc->lpDDSOffScreen->lpVtbl->Lock(pwc->lpDDSOffScreen,\r
- NULL, &(pwc->ddsd), 0, NULL) == DDERR_WASSTILLDRAWING)\r
- ;\r
-\r
- if(ddrval != DD_OK)\r
- dwErr = GetLastError();\r
-#else\r
- bRet = BitBlt(pwc->hDC, 0, 0, pwc->width, pwc->height,\r
- pwc->dib.hDC, 0, 0, SRCCOPY);\r
-#endif\r
- }\r
-\r
- return(TRUE);\r
-\r
-}\r
-\r
-\r
-// The following code is added by Li Wei to enable stereo display\r
-\r
-#if !defined(NO_STEREO)\r
-\r
-void WMesaShowStereo(GLuint list)\r
-{\r
-\r
- GLbitfield mask = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT;\r
- GLfloat cm[16];\r
- GLint matrix_mode;\r
- // Must use double Buffer\r
- if( ! Current-> db_flag )\r
- return;\r
-\r
-\r
- glGetIntegerv(GL_MATRIX_MODE,&matrix_mode);\r
-\r
- // glPushMatrix(); //****\r
- WMesaViewport(Current->gl_ctx,0,Current->height/2,Current->width,Current->height/2);\r
- // Current->gl_ctx->NewState = 0;\r
-\r
- // glViewport(0,0,Current->width,Current->height/2);\r
- if(matrix_mode!=GL_MODELVIEW)\r
- glMatrixMode(GL_MODELVIEW);\r
-\r
- glGetFloatv(GL_MODELVIEW_MATRIX,cm);\r
- glLoadIdentity();\r
- gluLookAt(viewDistance/2,0.0,0.0 ,\r
- viewDistance/2,0.0,-1.0,\r
- 0.0,1.0,0.0 );\r
- // glTranslatef(viewDistance/2.0,0.,0.);\r
- glMultMatrixf( cm );\r
-\r
- Current->ScreenMem = Current->pbPixels = Current->addrOffScreen;\r
- //glPushMatrix();\r
- glCallList( list );\r
- //glPopMatrix();\r
-\r
- glGetFloatv(GL_MODELVIEW_MATRIX,cm);\r
- glLoadIdentity();\r
- gluLookAt(-viewDistance/2,0.0,0.0 ,\r
- -viewDistance/2,0.0,-1.0,\r
- 0.0,1.0,0.0 );\r
- // glTranslatef(-viewDistance/2.0,0.,0.);\r
- glMultMatrixf(cm);\r
-\r
- Current->ScreenMem = Current->pbPixels = Current->addrOffScreen + Current->pitch;\r
- glCallList(list);\r
- if(matrix_mode!=GL_MODELVIEW)\r
- glMatrixMode(matrix_mode);\r
-\r
- // glPopMatrix();\r
- glFlush();\r
-\r
- WMesaViewport(Current->gl_ctx,0,0,Current->width,Current->height);\r
- // Current->gl_ctx->NewState = 0;\r
- WMesaSwapBuffers();\r
-\r
-}\r
-\r
-void toggleStereoMode()\r
-{\r
- if(!Current->db_flag)\r
- return;\r
- if(!stereo_flag){\r
- stereo_flag = 1;\r
- if(stereoBuffer==GL_FALSE)\r
-#if !defined(NO_PARALLEL)\r
- if(!parallelFlag)\r
-#endif\r
- {\r
- Current->ScanWidth = Current->pitch*2;\r
- }\r
- }\r
- else {\r
- stereo_flag = 0;\r
-#if !defined(NO_PARALLEL)\r
- if(!parallelFlag)\r
-#endif\r
- Current->ScanWidth = Current->pitch;\r
- Current->pbPixels = Current->addrOffScreen;\r
- }\r
-}\r
-\r
-/* if in stereo mode, the following function is called */\r
-void glShowStereo(GLuint list)\r
-{\r
- WMesaShowStereo(list);\r
-}\r
-\r
-#endif // End if NO_STEREO not defined\r
-\r
-#if !defined(NO_PARALLEL)\r
-\r
-void toggleParallelMode(void)\r
-{\r
- if(!parallelFlag){\r
- parallelFlag = GL_TRUE;\r
- if(parallelMachine==GL_FALSE){\r
- PRCreateRenderBuffer( Current->rgb_flag? GL_RGBA :GL_COLOR_INDEX,\r
- Current->cColorBits/8,\r
- Current->width ,Current->height,\r
- Current->ScanWidth,\r
- Current->rgb_flag? Current->pbPixels: Current->ScreenMem);\r
- parallelMachine = GL_TRUE;\r
- }\r
- }\r
- else {\r
- parallelFlag = GL_FALSE;\r
- if(parallelMachine==GL_TRUE){\r
- PRDestroyRenderBuffer();\r
- parallelMachine=GL_FALSE;\r
- ReadyForNextFrame = GL_TRUE;\r
- }\r
-\r
- /***********************************************\r
- // Seems something wrong!!!!\r
- ************************************************/\r
-\r
- WMesaMakeCurrent(Current);\r
-#if !defined(NO_STEREO)\r
- stereo_flag = GL_FALSE ;\r
-#endif\r
- }\r
-}\r
-\r
-void PRShowRenderResult(void)\r
-{\r
- int flag = 0;\r
- if(!glImageRendered())\r
- return;\r
-\r
- if (parallelFlag)\r
- {\r
- WMesaSwapBuffers();\r
- }\r
-\r
-}\r
-#endif //End if NO_PARALLEL not defined\r
-\r
-//end modification\r
-\r
-BYTE DITHER_RGB_2_8BIT( int red, int green, int blue, int pixel, int scanline)\r
-{\r
- char unsigned redtemp, greentemp, bluetemp, paletteindex;\r
-\r
- //*** now, look up each value in the halftone matrix\r
- //*** using an 8x8 ordered dither.\r
- redtemp = aDividedBy51[red]\r
- + (aModulo51[red] > aHalftone8x8[(pixel%8)*8\r
- + scanline%8]);\r
- greentemp = aDividedBy51[(char unsigned)green]\r
- + (aModulo51[green] > aHalftone8x8[\r
- (pixel%8)*8 + scanline%8]);\r
- bluetemp = aDividedBy51[(char unsigned)blue]\r
- + (aModulo51[blue] > aHalftone8x8[\r
- (pixel%8)*8 +scanline%8]);\r
-\r
- //*** recombine the halftoned rgb values into a palette index\r
- paletteindex =\r
- redtemp + aTimes6[greentemp] + aTimes36[bluetemp];\r
-\r
- //*** and translate through the wing halftone palette\r
- //*** translation vector to give the correct value.\r
- return aWinGHalftoneTranslation[paletteindex];\r
-}\r
-\r
-#ifdef DDRAW\r
-/*\r
-* restoreAll\r
-*\r
-* restore all lost objects\r
-*/\r
-HRESULT DDRestoreAll( WMesaContext wc )\r
-{\r
- HRESULT ddrval;\r
-\r
- ddrval = wc->lpDDSPrimary->lpVtbl->Restore(wc->lpDDSPrimary);\r
- if( ddrval == DD_OK )\r
- {\r
- ddrval = wc->lpDDSOffScreen->lpVtbl->Restore(wc->lpDDSOffScreen);\r
- }\r
- return ddrval;\r
-\r
-} /* restoreAll */\r
-\r
-\r
- /*\r
- * This function is called if the initialization function fails\r
-*/\r
-BOOL initFail( HWND hwnd, WMesaContext wc )\r
-{\r
- DDFree(wc);\r
- MessageBox( hwnd, "DirectDraw Init FAILED", "", MB_OK );\r
- return FALSE;\r
-\r
-} /* initFail */\r
-\r
-\r
-static void DDDeleteOffScreen(WMesaContext wc)\r
-{\r
- if( wc->lpDDSOffScreen != NULL )\r
- {\r
- wc->lpDDSOffScreen->lpVtbl->Unlock(wc->lpDDSOffScreen,NULL);\r
- wc->lpDDSOffScreen->lpVtbl->Release(wc->lpDDSOffScreen);\r
- wc->lpDDSOffScreen = NULL;\r
- }\r
-\r
-}\r
-\r
-static void DDFreePrimarySurface(WMesaContext wc)\r
-{\r
- if( wc->lpDDSPrimary != NULL )\r
- {\r
- if(wc->db_flag == GL_FALSE)\r
- wc->lpDDSPrimary->lpVtbl->ReleaseDC(wc->lpDDSPrimary, wc->hDC);\r
- wc->lpDDSPrimary->lpVtbl->Release(wc->lpDDSPrimary);\r
- wc->lpDDSPrimary = NULL;\r
- }\r
-}\r
-\r
-static BOOL DDCreatePrimarySurface(WMesaContext wc)\r
-{\r
- HRESULT ddrval;\r
- DDSCAPS ddscaps;\r
- wc->ddsd.dwSize = sizeof( wc->ddsd );\r
- wc->ddsd.dwFlags = DDSD_CAPS;\r
- wc->ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;\r
-\r
- ddrval = wc->lpDD->lpVtbl->CreateSurface( wc->lpDD,&(wc->ddsd), &(wc->lpDDSPrimary), NULL );\r
- if( ddrval != DD_OK )\r
- {\r
- return initFail(wc->hwnd , wc);\r
- }\r
- if(wc->db_flag == GL_FALSE)\r
- wc->lpDDSPrimary->lpVtbl->GetDC(wc->lpDDSPrimary, wc->hDC);\r
- return TRUE;\r
-}\r
-\r
-static BOOL DDCreateOffScreen(WMesaContext wc)\r
-{\r
- POINT pt;\r
- HRESULT ddrval;\r
- if(wc->lpDD == NULL)\r
- return FALSE;\r
- GetClientRect( wc->hwnd, &(wc->rectOffScreen) );\r
- wc->ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;\r
- wc->ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;\r
- wc->ddsd.dwHeight = wc->rectOffScreen.bottom - wc->rectOffScreen.top;\r
- wc->ddsd.dwWidth = wc->rectOffScreen.right - wc->rectOffScreen.left;\r
-\r
- ddrval = wc->lpDD->lpVtbl->CreateSurface( wc->lpDD, &(wc->ddsd), &(wc->lpDDSOffScreen), NULL );\r
- if( ddrval != DD_OK )\r
- {\r
- return FALSE;\r
- }\r
-\r
- while (wc->lpDDSOffScreen->lpVtbl->Lock(wc->lpDDSOffScreen,NULL, &(wc->ddsd), 0, NULL) == DDERR_WASSTILLDRAWING)\r
- ;\r
- // while ((ddrval = wc->lpDDSOffScreen->lpVtbl->Lock(wc->lpDDSOffScreen,NULL, &(wc->ddsd), DDLOCK_SURFACEMEMORYPTR , NULL)) != DD_OK)\r
- ;\r
- if(wc->ddsd.lpSurface==NULL)\r
- return initFail(wc->hwnd, wc);\r
-\r
- wc->ScreenMem = wc->pbPixels = wc->addrOffScreen = (PBYTE)(wc->ddsd.lpSurface);\r
- wc->ScanWidth = wc->pitch = wc->ddsd.lPitch;\r
- if (stereo_flag)\r
- wc->ScanWidth = wc->ddsd.lPitch*2;\r
-\r
- GetClientRect( wc->hwnd, &(wc->rectSurface) );\r
- pt.x = pt.y = 0;\r
- ClientToScreen( wc->hwnd, &pt );\r
- OffsetRect(&(wc->rectSurface), pt.x, pt.y);\r
- wmSetPixelFormat(wc, wc->hDC);\r
- return TRUE;\r
-}\r
-\r
-/*\r
-* doInit - do work required for every instance of the application:\r
-* create the window, initialize data\r
-*/\r
-static BOOL DDInit( WMesaContext wc, HWND hwnd)\r
-{\r
- HRESULT ddrval;\r
- DWORD dwFrequency;\r
-\r
- LPDIRECTDRAW lpDD; // DirectDraw object\r
- LPDIRECTDRAW2 lpDD2;\r
-\r
-\r
- wc->fullScreen = displayOptions.fullScreen;\r
- wc->gMode = displayOptions.mode;\r
- wc->hwnd = hwnd;\r
- stereo_flag = displayOptions.stereo;\r
- if(wc->db_flag!= GL_TRUE)\r
- stereo_flag = GL_FALSE;\r
- /*\r
- * create the main DirectDraw object\r
- */\r
- ddrval = DirectDrawCreate( NULL, &(wc->lpDD), NULL );\r
- if( ddrval != DD_OK )\r
- {\r
- return initFail(hwnd,wc);\r
- }\r
-\r
- // Get exclusive mode if requested\r
- if(wc->fullScreen)\r
- {\r
- ddrval = wc->lpDD->lpVtbl->SetCooperativeLevel( wc->lpDD, hwnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN );\r
- }\r
- else\r
- {\r
- ddrval = wc->lpDD->lpVtbl->SetCooperativeLevel( wc->lpDD, hwnd, DDSCL_NORMAL );\r
- }\r
- if( ddrval != DD_OK )\r
- {\r
- return initFail(hwnd , wc);\r
- }\r
-\r
-\r
- /* ddrval = wc->lpDD->lpVtbl->QueryInterface(wc->lpDD, IID_IDirectDraw2,\r
- (LPVOID *)((wc->lpDD2)));\r
-\r
- */\r
- if(ddrval != DD_OK)\r
- return initFail(hwnd , wc);\r
-\r
-\r
- //ddrval = wc->lpDD->lpVtbl->GetDisplayMode( wc->lpDD, &(wc->ddsd));\r
- // wc->lpDD2->lpVtbl->GetMonitorFrequency(wc->lpDD, &dwFrequency);\r
- switch( wc->gMode )\r
- {\r
- case 1: ddrval = wc->lpDD->lpVtbl->SetDisplayMode( wc->lpDD, 640, 480, displayOptions.bpp); break;\r
- case 2: ddrval = wc->lpDD->lpVtbl->SetDisplayMode( wc->lpDD, 800, 600, displayOptions.bpp); break;\r
- case 3: ddrval = wc->lpDD->lpVtbl->SetDisplayMode( wc->lpDD, 1024, 768, displayOptions.bpp); break;\r
- case 4: ddrval = wc->lpDD->lpVtbl->SetDisplayMode( wc->lpDD, 1152, 864, displayOptions.bpp); break;\r
- case 5: ddrval = wc->lpDD->lpVtbl->SetDisplayMode( wc->lpDD, 1280, 1024, displayOptions.bpp); break;\r
- }\r
-\r
- if( ddrval != DD_OK )\r
- {\r
- printf("Can't modify display mode, current mode used\n");\r
- // return initFail(hwnd , wc);\r
- }\r
- //ddrval = wc->lpDD->lpVtbl->GetDisplayMode( wc->lpDD, &(wc->ddsd));\r
- switch(ddrval){\r
- case DDERR_INVALIDOBJECT:\r
- break;\r
- case DDERR_INVALIDPARAMS:\r
- break;\r
- case DDERR_UNSUPPORTEDMODE:\r
- ;\r
- }\r
-\r
- if(DDCreatePrimarySurface(wc) == GL_FALSE)\r
- return initFail(hwnd, wc);\r
-\r
- if(wc->db_flag)\r
- return DDCreateOffScreen(wc);\r
-} /* DDInit */\r
-\r
-static void DDFree( WMesaContext wc)\r
-{\r
- if( wc->lpDD != NULL )\r
- {\r
- DDFreePrimarySurface(wc);\r
- DDDeleteOffScreen(wc);\r
- wc->lpDD->lpVtbl->Release(wc->lpDD);\r
- wc->lpDD = NULL;\r
- }\r
- // Clean up the screen on exit\r
- RedrawWindow( NULL, NULL, NULL, RDW_INVALIDATE | RDW_ERASE |\r
- RDW_ALLCHILDREN );\r
-\r
-}\r
-#endif\r
-\r
-void WMesaMove(void)\r
-{\r
- WMesaContext wc = Current;\r
- POINT pt;\r
- if (Current != NULL){\r
- GetClientRect( wc->hwnd, &(wc->rectSurface) );\r
- pt.x = pt.y = 0;\r
- ClientToScreen( wc->hwnd, &pt );\r
- OffsetRect(&(wc->rectSurface), pt.x, pt.y);\r
- }\r
-}\r
-\r
-\r
-\r
-/*\r
-* Like PACK_8A8B8G8R() but don't use alpha. This is usually an acceptable\r
-* shortcut.\r
-*/\r
-#define PACK_8B8G8R( R, G, B ) ( ((B) << 16) | ((G) << 8) | (R) )\r
-\r
-\r
-/**********************************************************************/\r
-/*** Triangle rendering ***/\r
-/**********************************************************************/\r
-\r
-/*\r
- * XImage, smooth, depth-buffered, PF_8A8B8G8R triangle.\r
- */\r
-static void smooth_8A8B8G8R_z_triangle( GLcontext *ctx,\r
- GLuint v0, GLuint v1, GLuint v2,\r
- GLuint pv )\r
-{\r
- WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;\r
-#define INTERP_Z 1\r
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE\r
-#define INTERP_RGB 1\r
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)\r
-#define PIXEL_TYPE GLuint\r
- //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)\r
-#define BYTES_PER_ROW (wmesa->ScanWidth)\r
-#define INNER_LOOP( LEFT, RIGHT, Y ) \\r
- { \\r
- GLint i, len = RIGHT-LEFT; \\r
- for (i=0;i<len;i++) { \\r
- GLdepth z = FixedToDepth(ffz); \\r
- if (z < zRow[i]) { \\r
- pRow[i] = PACK_8B8G8R( FixedToInt(ffr), FixedToInt(ffg), \\r
- FixedToInt(ffb) ); \\r
- zRow[i] = z; \\r
- } \\r
- ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \\r
- ffz += fdzdx; \\r
- } \\r
- }\r
-\r
-#ifdef __MINGW32__\r
- #include "tritemp.h"\r
-#else\r
-\r
- #ifdef WIN32\r
-// #include "..\tritemp.h"\r
- #else\r
- #include "tritemp.h"\r
- #endif\r
-#endif\r
-}\r
-\r
-\r
-/*\r
-* XImage, smooth, depth-buffered, PF_8R8G8B triangle.\r
-*/\r
-static void smooth_8R8G8B_z_triangle( GLcontext *ctx,\r
- GLuint v0, GLuint v1, GLuint v2,\r
- GLuint pv )\r
-{\r
- WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;\r
-#define INTERP_Z 1\r
-#define INTERP_RGB 1\r
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)\r
-#define PIXEL_TYPE GLuint\r
- //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)\r
-#define BYTES_PER_ROW (wmesa->ScanWidth)\r
-#define INNER_LOOP( LEFT, RIGHT, Y ) \\r
- { \\r
- GLint i, len = RIGHT-LEFT; \\r
- for (i=0;i<len;i++) { \\r
- GLdepth z = FixedToDepth(ffz); \\r
- if (z < zRow[i]) { \\r
- pRow[i] = PACK_8R8G8B( FixedToInt(ffr), FixedToInt(ffg), \\r
- FixedToInt(ffb) ); \\r
- zRow[i] = z; \\r
- } \\r
- ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \\r
- ffz += fdzdx; \\r
- } \\r
- }\r
-#ifdef __MINGW32__\r
- #include "tritemp.h"\r
-#else\r
-\r
- #ifdef WIN32\r
-// #include "..\tritemp.h"\r
- #else\r
- #include "tritemp.h"\r
- #endif\r
-#endif\r
-}\r
-\r
-\r
-\r
-/*\r
-* XImage, smooth, depth-buffered, PF_5R6G5B triangle.\r
-*/\r
-static void smooth_5R6G5B_z_triangle( GLcontext *ctx,\r
- GLuint v0, GLuint v1, GLuint v2,\r
- GLuint pv )\r
-{\r
- WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;\r
-#define INTERP_Z 1\r
-#define INTERP_RGB 1\r
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(X,Y)\r
-#define PIXEL_TYPE GLushort\r
- //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)\r
-#define BYTES_PER_ROW (wmesa->ScanWidth)\r
-#define INNER_LOOP( LEFT, RIGHT, Y ) \\r
- { \\r
- GLint i, len = RIGHT-LEFT; \\r
- for (i=0;i<len;i++) { \\r
- GLdepth z = FixedToDepth(ffz); \\r
- if (z < zRow[i]) { \\r
- pRow[i] = PACK_5R6G5B( FixedToInt(ffr), FixedToInt(ffg), \\r
- FixedToInt(ffb) ); \\r
- zRow[i] = z; \\r
- } \\r
- ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \\r
- ffz += fdzdx; \\r
- } \\r
- }\r
-#ifdef __MINGW32__\r
- #include "tritemp.h"\r
-#else\r
-\r
- #ifdef WIN32\r
-// #include "..\tritemp.h"\r
- #else\r
- #include "tritemp.h"\r
- #endif\r
-#endif\r
-}\r
-\r
-/*\r
-* XImage, flat, depth-buffered, PF_8A8B8G8R triangle.\r
-*/\r
-static void flat_8A8B8G8R_z_triangle( GLcontext *ctx, GLuint v0,\r
- GLuint v1, GLuint v2, GLuint pv )\r
-{\r
- WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;\r
-#define INTERP_Z 1\r
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)\r
-#define PIXEL_TYPE GLuint\r
- //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)\r
-#define BYTES_PER_ROW (wmesa->ScanWidth)\r
-#define SETUP_CODE \\r
- unsigned long p = PACK_8B8G8R( VB->ColorPtr->data[pv][0], \\r
- VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );\r
-#define INNER_LOOP( LEFT, RIGHT, Y ) \\r
- { \\r
- GLint i, len = RIGHT-LEFT; \\r
- for (i=0;i<len;i++) { \\r
- GLdepth z = FixedToDepth(ffz); \\r
- if (z < zRow[i]) { \\r
- pRow[i] = p; \\r
- zRow[i] = z; \\r
- } \\r
- ffz += fdzdx; \\r
- } \\r
- }\r
-#ifdef __MINGW32__\r
- #include "tritemp.h"\r
-#else\r
-\r
- #ifdef WIN32\r
-// #include "..\tritemp.h"\r
- #else\r
- #include "tritemp.h"\r
- #endif\r
-#endif\r
-}\r
-\r
-\r
-/*\r
-* XImage, flat, depth-buffered, PF_8R8G8B triangle.\r
-*/\r
-static void flat_8R8G8B_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,\r
- GLuint v2, GLuint pv )\r
-{\r
- WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;\r
-#define INTERP_Z 1\r
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)\r
-#define PIXEL_TYPE GLuint\r
- //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)\r
-#define BYTES_PER_ROW (wmesa->ScanWidth)\r
-#define SETUP_CODE \\r
- unsigned long p = PACK_8R8G8B( VB->ColorPtr->data[pv][0], \\r
- VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );\r
-#define INNER_LOOP( LEFT, RIGHT, Y ) \\r
- { \\r
- GLint i, len = RIGHT-LEFT; \\r
- for (i=0;i<len;i++) { \\r
- GLdepth z = FixedToDepth(ffz); \\r
- if (z < zRow[i]) { \\r
- pRow[i] = p; \\r
- zRow[i] = z; \\r
- } \\r
- ffz += fdzdx; \\r
- } \\r
- }\r
-#ifdef __MINGW32__\r
- #include "tritemp.h"\r
-#else\r
-\r
- #ifdef WIN32\r
-// #include "..\tritemp.h"\r
- #else\r
- #include "tritemp.h"\r
- #endif\r
-#endif\r
-}\r
-\r
-\r
-/*\r
-* XImage, flat, depth-buffered, PF_5R6G5B triangle.\r
-*/\r
-static void flat_5R6G5B_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,\r
- GLuint v2, GLuint pv )\r
-{\r
- WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;\r
-#define INTERP_Z 1\r
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(X,Y)\r
-#define PIXEL_TYPE GLushort\r
- //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)\r
-#define BYTES_PER_ROW (wmesa->ScanWidth)\r
-#define SETUP_CODE \\r
- unsigned long p = PACK_5R6G5B( VB->ColorPtr->data[pv][0], \\r
- VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );\r
-#define INNER_LOOP( LEFT, RIGHT, Y ) \\r
- { \\r
- GLint i, len = RIGHT-LEFT; \\r
- for (i=0;i<len;i++) { \\r
- GLdepth z = FixedToDepth(ffz); \\r
- if (z < zRow[i]) { \\r
- pRow[i] = p; \\r
- zRow[i] = z; \\r
- } \\r
- ffz += fdzdx; \\r
- } \\r
- }\r
-#ifdef __MINGW32__\r
- #include "tritemp.h"\r
-#else\r
-\r
- #ifdef WIN32\r
-// #include "..\tritemp.h"\r
- #else\r
- #include "tritemp.h"\r
- #endif\r
-#endif\r
-}\r
-\r
-\r
-/*\r
-* XImage, smooth, NON-depth-buffered, PF_8A8B8G8R triangle.\r
-*/\r
-static void smooth_8A8B8G8R_triangle( GLcontext *ctx, GLuint v0, GLuint v1,\r
- GLuint v2, GLuint pv )\r
-{\r
- WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;\r
-#define INTERP_RGB 1\r
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)\r
-#define PIXEL_TYPE GLuint\r
- //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)\r
-#define BYTES_PER_ROW (wmesa->ScanWidth)\r
-#define INNER_LOOP( LEFT, RIGHT, Y ) \\r
- { \\r
- GLint xx; \\r
- PIXEL_TYPE *pixel = pRow; \\r
- for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \\r
- *pixel = PACK_8B8G8R( FixedToInt(ffr), FixedToInt(ffg), \\r
- FixedToInt(ffb) ); \\r
- ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \\r
- } \\r
- }\r
-#ifdef __MINGW32__\r
- #include "tritemp.h"\r
-#else\r
-\r
- #ifdef WIN32\r
-// #include "..\tritemp.h"\r
- #else\r
- #include "tritemp.h"\r
- #endif\r
-#endif\r
-}\r
-\r
-\r
-/*\r
-* XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.\r
-*/\r
-static void smooth_8R8G8B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,\r
- GLuint v2, GLuint pv )\r
-{\r
- WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;\r
-#define INTERP_RGB 1\r
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)\r
-#define PIXEL_TYPE GLuint\r
- //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)\r
-#define BYTES_PER_ROW (wmesa->ScanWidth)\r
-#define INNER_LOOP( LEFT, RIGHT, Y ) \\r
- { \\r
- GLint xx; \\r
- PIXEL_TYPE *pixel = pRow; \\r
- for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \\r
- *pixel = PACK_8R8G8B( FixedToInt(ffr), FixedToInt(ffg), \\r
- FixedToInt(ffb) ); \\r
- ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \\r
- } \\r
- }\r
-#ifdef __MINGW32__\r
- #include "tritemp.h"\r
-#else\r
-\r
- #ifdef WIN32\r
-// #include "..\tritemp.h"\r
- #else\r
- #include "tritemp.h"\r
- #endif\r
-#endif\r
-}\r
-\r
-\r
-/*\r
-* XImage, smooth, NON-depth-buffered, PF_5R6G5B triangle.\r
-*/\r
-static void smooth_5R6G5B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,\r
- GLuint v2, GLuint pv )\r
-{\r
- WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;\r
-#define INTERP_RGB 1\r
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(X,Y)\r
-#define PIXEL_TYPE GLushort\r
- //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)\r
-#define BYTES_PER_ROW (wmesa->ScanWidth)\r
-#define INNER_LOOP( LEFT, RIGHT, Y ) \\r
- { \\r
- GLint xx; \\r
- PIXEL_TYPE *pixel = pRow; \\r
- for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \\r
- *pixel = PACK_5R6G5B( FixedToInt(ffr), FixedToInt(ffg), \\r
- FixedToInt(ffb) ); \\r
- ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \\r
- } \\r
- }\r
-#ifdef __MINGW32__\r
- #include "tritemp.h"\r
-#else\r
-\r
- #ifdef WIN32\r
-// #include "..\tritemp.h"\r
- #else\r
- #include "tritemp.h"\r
- #endif\r
-#endif\r
-}\r
-\r
-\r
-\r
-/*\r
-* XImage, flat, NON-depth-buffered, PF_8A8B8G8R triangle.\r
-*/\r
-static void flat_8A8B8G8R_triangle( GLcontext *ctx, GLuint v0,\r
- GLuint v1, GLuint v2, GLuint pv )\r
-{\r
- WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;\r
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)\r
-#define PIXEL_TYPE GLuint\r
- //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)\r
-#define BYTES_PER_ROW (wmesa->ScanWidth)\r
-#define SETUP_CODE \\r
- unsigned long p = PACK_8B8G8R( VB->ColorPtr->data[pv][0], \\r
- VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );\r
-#define INNER_LOOP( LEFT, RIGHT, Y ) \\r
- { \\r
- GLint xx; \\r
- PIXEL_TYPE *pixel = pRow; \\r
- for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \\r
- *pixel = p; \\r
- } \\r
- }\r
-\r
-#ifdef __MINGW32__\r
- #include "tritemp.h"\r
-#else\r
-\r
- #ifdef WIN32\r
-// #include "..\tritemp.h"\r
- #else\r
- #include "tritemp.h"\r
- #endif\r
-#endif\r
-}\r
-\r
-\r
-/*\r
-* XImage, flat, NON-depth-buffered, PF_8R8G8B triangle.\r
-*/\r
-static void flat_8R8G8B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,\r
- GLuint v2, GLuint pv )\r
-{\r
- WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;\r
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)\r
-#define PIXEL_TYPE GLuint\r
- //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)\r
-#define BYTES_PER_ROW (wmesa->ScanWidth)\r
-#define SETUP_CODE \\r
- unsigned long p = PACK_8R8G8B( VB->ColorPtr->data[pv][0], \\r
- VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );\r
-#define INNER_LOOP( LEFT, RIGHT, Y ) \\r
- { \\r
- GLint xx; \\r
- PIXEL_TYPE *pixel = pRow; \\r
- for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \\r
- *pixel = p; \\r
- } \\r
- }\r
-#ifdef __MINGW32__\r
- #include "tritemp.h"\r
-#else\r
-\r
- #ifdef WIN32\r
-// #include "..\tritemp.h"\r
- #else\r
- #include "tritemp.h"\r
- #endif\r
-#endif\r
-}\r
-\r
-\r
-/*\r
-* XImage, flat, NON-depth-buffered, PF_5R6G5B triangle.\r
-*/\r
-static void flat_5R6G5B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,\r
- GLuint v2, GLuint pv )\r
-{\r
- WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;\r
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(X,Y)\r
-#define PIXEL_TYPE GLushort\r
- //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)\r
-#define BYTES_PER_ROW (wmesa->ScanWidth)\r
-#define SETUP_CODE \\r
- unsigned long p = PACK_5R6G5B( VB->ColorPtr->data[pv][0], \\r
- VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );\r
-#define INNER_LOOP( LEFT, RIGHT, Y ) \\r
- { \\r
- GLint xx; \\r
- PIXEL_TYPE *pixel = pRow; \\r
- for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \\r
- *pixel = p; \\r
- } \\r
- }\r
-#ifdef __MINGW32__\r
- #include "tritemp.h"\r
-#else\r
-\r
- #ifdef WIN32\r
-// #include "..\tritemp.h"\r
- #else\r
- #include "tritemp.h"\r
- #endif\r
-#endif\r
-}\r
-\r
-\r
-/*\r
-* XImage, smooth, depth-buffered, 8-bit PF_LOOKUP triangle.\r
-*/\r
-\r
-static void smooth_ci_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,\r
- GLuint v2, GLuint pv )\r
-{\r
- WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;\r
-#define INTERP_Z 1\r
-#define INTERP_INDEX 1\r
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)\r
-#define PIXEL_TYPE GLubyte\r
-#define BYTES_PER_ROW (wmesa->ScanWidth)\r
-#define INNER_LOOP( LEFT, RIGHT, Y ) \\r
- { \\r
- GLint i, len = RIGHT-LEFT; \\r
- for (i=0;i<len;i++) { \\r
- GLdepth z = FixedToDepth(ffz); \\r
- if (z < zRow[i]) { \\r
- pRow[i] = FixedToInt(ffi); \\r
- zRow[i] = z; \\r
- } \\r
- ffi += fdidx; \\r
- ffz += fdzdx; \\r
- } \\r
- }\r
-#ifdef __MINGW32__\r
- #include "tritemp.h"\r
-#else\r
-\r
- #ifdef WIN32\r
-// #include "..\tritemp.h"\r
- #else\r
- #include "tritemp.h"\r
- #endif\r
-#endif\r
-}\r
-\r
-\r
-/*\r
-* XImage, flat, depth-buffered, 8-bit PF_LOOKUP triangle.\r
-*/\r
-\r
-static void flat_ci_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,\r
- GLuint v2, GLuint pv )\r
-{\r
- WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;\r
-#define INTERP_Z 1\r
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)\r
-#define PIXEL_TYPE GLubyte\r
-#define BYTES_PER_ROW (wmesa->ScanWidth)\r
-#define SETUP_CODE \\r
- GLuint index = VB->IndexPtr->data[pv]; \\r
- (*ctx->Driver.Index)( ctx, index );\r
-#define INNER_LOOP( LEFT, RIGHT, Y ) \\r
- { \\r
- GLint i, len = RIGHT-LEFT; \\r
- for (i=0;i<len;i++) { \\r
- GLdepth z = FixedToDepth(ffz); \\r
- if (z < zRow[i]) { \\r
- pRow[i] = index; \\r
- zRow[i] = z; \\r
- } \\r
- ffz += fdzdx; \\r
- } \\r
- }\r
-#ifdef __MINGW32__\r
- #include "tritemp.h"\r
-#else\r
-\r
- #ifdef WIN32\r
-// #include "..\tritemp.h"\r
- #else\r
- #include "tritemp.h"\r
- #endif\r
-#endif\r
-}\r
-\r
-\r
-\r
-/*\r
-* XImage, smooth, NON-depth-buffered, 8-bit PF_LOOKUP triangle.\r
-*/\r
-\r
-static void smooth_ci_triangle( GLcontext *ctx, GLuint v0, GLuint v1,\r
- GLuint v2, GLuint pv )\r
-{\r
- WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;\r
-#define INTERP_Z 1\r
-#define INTERP_INDEX 1\r
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)\r
-#define PIXEL_TYPE GLubyte\r
-#define BYTES_PER_ROW (wmesa->ScanWidth)\r
-#define INNER_LOOP( LEFT, RIGHT, Y ) \\r
- { \\r
- GLint xx; \\r
- PIXEL_TYPE *pixel = pRow; \\r
- for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \\r
- *pixel = FixedToInt(ffi); \\r
- ffi += fdidx; \\r
- } \\r
- }\r
-#ifdef __MINGW32__\r
- #include "tritemp.h"\r
-#else\r
-\r
- #ifdef WIN32\r
-// #include "..\tritemp.h"\r
- #else\r
- #include "tritemp.h"\r
- #endif\r
-#endif\r
-}\r
-\r
-\r
-/*\r
-* XImage, flat, NON-depth-buffered, 8-bit PF_LOOKUP triangle.\r
-*/\r
-static void flat_ci_triangle( GLcontext *ctx, GLuint v0, GLuint v1,\r
- GLuint v2, GLuint pv )\r
-{\r
- WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;\r
-#define INTERP_Z 1\r
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)\r
-#define PIXEL_TYPE GLubyte\r
-#define BYTES_PER_ROW (wmesa->ScanWidth)\r
-#define SETUP_CODE \\r
- GLuint index = VB->IndexPtr->data[pv]; \\r
- (*ctx->Driver.Index)( ctx, index );\r
-#define INNER_LOOP( LEFT, RIGHT, Y ) \\r
- { \\r
- GLint xx; \\r
- PIXEL_TYPE *pixel = pRow; \\r
- for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \\r
- *pixel = index; \\r
- } \\r
- }\r
-#ifdef __MINGW32__\r
- #include "tritemp.h"\r
-#else\r
-\r
- #ifdef WIN32\r
-// #include "..\tritemp.h"\r
- #else\r
- #include "tritemp.h"\r
- #endif\r
-#endif\r
-}\r
-\r
-/*\r
-* XImage, smooth, depth-buffered, 8-bit, PF_DITHER8 triangle.\r
-*/\r
-static void smooth_DITHER8_z_triangle( GLcontext *ctx,\r
- GLuint v0, GLuint v1, GLuint v2,\r
- GLuint pv )\r
-{\r
- WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;\r
- DITHER_RGB_TO_8BIT_SETUP\r
-#define INTERP_Z 1\r
-#define INTERP_RGB 1\r
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)\r
-#define PIXEL_TYPE GLubyte\r
-#define BYTES_PER_ROW (wmesa->ScanWidth)\r
-#define INNER_LOOP( LEFT, RIGHT, Y ) \\r
- { \\r
- GLint i, xx = LEFT, yy = FLIP(Y), len = RIGHT-LEFT; \\r
- for (i=0;i<len;i++,xx++) { \\r
- GLdepth z = FixedToDepth(ffz); \\r
- if (z < zRow[i]) { \\r
- DITHER_RGB_TO_8BIT( FixedToInt(ffr), FixedToInt(ffg), \\r
- FixedToInt(ffb), xx, yy); \\r
- pRow[i] = pixelDithered; \\r
- zRow[i] = z; \\r
- } \\r
- ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \\r
- ffz += fdzdx; \\r
- } \\r
- }\r
-#ifdef __MINGW32__\r
- #include "tritemp.h"\r
-#else\r
-\r
- #ifdef WIN32\r
-// #include "..\tritemp.h"\r
- #else\r
- #include "tritemp.h"\r
- #endif\r
-#endif\r
-}\r
-\r
-/*\r
-* XImage, flat, depth-buffered, 8-bit PF_DITHER triangle.\r
-*/\r
-static void flat_DITHER8_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,\r
- GLuint v2, GLuint pv )\r
-{\r
- WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;\r
- DITHER_RGB_TO_8BIT_SETUP\r
-#define INTERP_Z 1\r
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)\r
-#define PIXEL_TYPE GLubyte\r
-#define BYTES_PER_ROW (wmesa->ScanWidth)\r
-\r
-#define INNER_LOOP( LEFT, RIGHT, Y ) \\r
- { \\r
- GLint i, xx = LEFT, yy = FLIP(Y), len = RIGHT-LEFT; \\r
- for (i=0;i<len;i++,xx++) { \\r
- GLdepth z = FixedToDepth(ffz); \\r
- if (z < zRow[i]) { \\r
- DITHER_RGB_TO_8BIT( VB->ColorPtr->data[pv][0], \\r
- VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2], xx, yy); \\r
- pRow[i] = pixelDithered; \\r
- zRow[i] = z; \\r
- } \\r
- ffz += fdzdx; \\r
- } \\r
- }\r
-#ifdef __MINGW32__\r
- #include "tritemp.h"\r
-#else\r
-\r
- #ifdef WIN32\r
-// #include "..\tritemp.h"\r
- #else\r
- #include "tritemp.h"\r
- #endif\r
-#endif\r
-}\r
-\r
-/*\r
-* XImage, smooth, NON-depth-buffered, 8-bit PF_DITHER triangle.\r
-*/\r
-static void smooth_DITHER8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,\r
- GLuint v2, GLuint pv )\r
-{\r
- WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;\r
- DITHER_RGB_TO_8BIT_SETUP\r
-#define INTERP_RGB 1\r
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)\r
-#define PIXEL_TYPE GLubyte\r
-#define BYTES_PER_ROW (wmesa->ScanWidth)\r
-#define INNER_LOOP( LEFT, RIGHT, Y ) \\r
- { \\r
- GLint xx, yy = FLIP(Y); \\r
- PIXEL_TYPE *pixel = pRow; \\r
- for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \\r
- DITHER_RGB_TO_8BIT( VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2], xx, yy);\\r
- *pixel = pixelDithered; \\r
- ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \\r
- } \\r
- }\r
-#ifdef __MINGW32__\r
- #include "tritemp.h"\r
-#else\r
-\r
- #ifdef WIN32\r
-// #include "..\tritemp.h"\r
- #else\r
- #include "tritemp.h"\r
- #endif\r
-#endif\r
-}\r
-\r
-/*\r
-* XImage, flat, NON-depth-buffered, 8-bit PF_DITHER triangle.\r
-*/\r
-\r
-static void flat_DITHER8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,\r
- GLuint v2, GLuint pv )\r
-{\r
- WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;\r
- DITHER_RGB_TO_8BIT_SETUP\r
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)\r
-#define PIXEL_TYPE GLubyte\r
-#define BYTES_PER_ROW (wmesa->ScanWidth)\r
-\r
-#define INNER_LOOP( LEFT, RIGHT, Y ) \\r
- { \\r
- GLint xx, yy = FLIP(Y); \\r
- PIXEL_TYPE *pixel = pRow; \\r
- for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \\r
- DITHER_RGB_TO_8BIT( VB->ColorPtr->data[pv][0], \\r
- VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2], xx, yy); \\r
- *pixel = pixelDithered; \\r
- } \\r
- }\r
-#ifdef __MINGW32__\r
- #include "tritemp.h"\r
-#else\r
-\r
- #ifdef WIN32\r
-// #include "..\tritemp.h"\r
- #else\r
- #include "tritemp.h"\r
- #endif\r
-#endif\r
-}\r
-\r
-\r
-\r
-\r
-static /*triangle_func*/ choose_triangle_function( GLcontext *ctx )\r
-{\r
-#if 0\r
- WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;\r
- int depth = wmesa->cColorBits;\r
-\r
- if (ctx->Polygon.SmoothFlag) return NULL;\r
- if (ctx->Texture._ReallyEnabled) return NULL;\r
- if (!wmesa->db_flag) return NULL;\r
- /*if (wmesa->xm_buffer->buffer==XIMAGE)*/ {\r
- if ( ctx->Light.ShadeModel==GL_SMOOTH\r
- && ctx->_RasterMask==DEPTH_BIT\r
- && ctx->Depth.Func==GL_LESS\r
- && ctx->Depth.Mask==GL_TRUE\r
- && ctx->Polygon.StippleFlag==GL_FALSE) {\r
- switch (wmesa->pixelformat) {\r
- case PF_8A8B8G8R:\r
- return smooth_8A8B8G8R_z_triangle;\r
- case PF_8R8G8B:\r
- return smooth_8R8G8B_z_triangle;\r
- case PF_5R6G5B:\r
- return smooth_5R6G5B_z_triangle;\r
- case PF_DITHER8:\r
- return smooth_DITHER8_z_triangle;\r
- case PF_INDEX8:\r
- return smooth_ci_z_triangle;\r
- default:\r
- return NULL;\r
- }\r
- }\r
- if ( ctx->Light.ShadeModel==GL_FLAT\r
- && ctx->_RasterMask==DEPTH_BIT\r
- && ctx->Depth.Func==GL_LESS\r
- && ctx->Depth.Mask==GL_TRUE\r
- && ctx->Polygon.StippleFlag==GL_FALSE) {\r
- switch (wmesa->pixelformat) {\r
- case PF_8A8B8G8R:\r
- return flat_8A8B8G8R_z_triangle;\r
- case PF_8R8G8B:\r
- return flat_8R8G8B_z_triangle;\r
- case PF_5R6G5B:\r
- return flat_5R6G5B_z_triangle;\r
- case PF_DITHER8:\r
- return flat_DITHER8_z_triangle;\r
- case PF_INDEX8:\r
- return flat_ci_z_triangle;\r
- default:\r
- return NULL;\r
- }\r
- }\r
- if ( ctx->_RasterMask==0 /* no depth test */\r
- && ctx->Light.ShadeModel==GL_SMOOTH\r
- && ctx->Polygon.StippleFlag==GL_FALSE) {\r
- switch (wmesa->pixelformat) {\r
- case PF_8A8B8G8R:\r
- return smooth_8A8B8G8R_triangle;\r
- case PF_8R8G8B:\r
- return smooth_8R8G8B_triangle;\r
- case PF_5R6G5B:\r
- return smooth_5R6G5B_triangle;\r
- case PF_DITHER8:\r
- return smooth_DITHER8_triangle;\r
- case PF_INDEX8:\r
- return smooth_ci_triangle;\r
- default:\r
- return NULL;\r
- }\r
- }\r
-\r
- if ( ctx->_RasterMask==0 /* no depth test */\r
- && ctx->Light.ShadeModel==GL_FLAT\r
- && ctx->Polygon.StippleFlag==GL_FALSE) {\r
- switch (wmesa->pixelformat) {\r
- case PF_8A8B8G8R:\r
- return flat_8A8B8G8R_triangle;\r
- case PF_8R8G8B:\r
- return flat_8R8G8B_triangle;\r
- case PF_5R6G5B:\r
- return flat_5R6G5B_triangle;\r
- case PF_DITHER8:\r
- return flat_DITHER8_triangle;\r
- case PF_INDEX8:\r
- return flat_ci_triangle;\r
- default:\r
- return NULL;\r
- }\r
- }\r
-\r
- return NULL;\r
- }\r
-#endif\r
-}\r
-\r
-/*\r
-* Define a new viewport and reallocate auxillary buffers if the size of\r
-* the window (color buffer) has changed.\r
-*/\r
-void WMesaViewport( GLcontext *ctx,\r
- GLint x, GLint y, GLsizei width, GLsizei height )\r
-{\r
-#if 0\r
- /* Save viewport */\r
- ctx->Viewport.X = x;\r
- ctx->Viewport.Width = width;\r
- ctx->Viewport.Y = y;\r
- ctx->Viewport.Height = height;\r
-\r
- /* compute scale and bias values */\r
-/* Pre-Keith 3.1 changes\r
- ctx->Viewport.Map.m[Sx] = (GLfloat) width / 2.0F;\r
- ctx->Viewport.Map.m[Tx] = ctx->Viewport.Sx + x;\r
- ctx->Viewport.Map.m[Sy] = (GLfloat) height / 2.0F;\r
- ctx->Viewport.Map.m[Ty] = ctx->Viewport.Sy + y;\r
-*/\r
- ctx->Viewport.WindowMap.m[MAT_SX] = (GLfloat) width / 2.0F;\r
- ctx->Viewport.WindowMap.m[MAT_TX] = ctx->Viewport.WindowMap.m[MAT_SX] + x;\r
- ctx->Viewport.WindowMap.m[MAT_SY] = (GLfloat) height / 2.0F;\r
- ctx->Viewport.WindowMap.m[MAT_TY] = ctx->Viewport.WindowMap.m[MAT_SY] + y;\r
-#endif\r
-}\r
+/* $Id: wmesa.c,v 1.19 2001/09/18 16:39:38 kschultz Exp $ */
+
+/*
+ * Windows (Win32) device driver for Mesa 3.4
+ *
+ * Original author:
+ *
+ * Copyright (C) 1996- Li Wei
+ * Address : Institute of Artificial Intelligence
+ * : & Robotics
+ * : Xi'an Jiaotong University
+ * Email : liwei@aiar.xjtu.edu.cn
+ * Web page : http://sun.aiar.xjtu.edu.cn
+ *
+ * This file and its associations are partially borrowed from the
+ * Windows NT driver for Mesa 1.8 , written by Mark Leaming
+ * (mark@rsinc.com).
+ */
+
+
+#define WMESA_STEREO_C
+
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <GL/wmesa.h>
+#include "mesa_extend.h"
+#include "colors.h"
+#include "macros.h"
+#include "context.h"
+#include "dd.h"
+//#include "xform.h"
+//#include "vb.h"
+#include "matrix.h"
+#include "depth.h"
+#include "wmesadef.h"
+
+#pragma warning ( disable : 4100 4133 4761 )
+
+#ifdef PROFILE
+// #include "profile.h"
+#endif
+
+#ifdef DITHER
+#include <wing.h>
+#endif
+
+#ifdef __CYGWIN32__
+#include "macros.h"
+#include <string.h>
+#define CopyMemory memcpy
+#endif
+
+#if !defined(NO_STEREO)
+
+#include "gl\glu.h"
+#include "stereo.h"
+
+#endif
+#if !defined(NO_PARALLEL)
+ #include "parallel.h"
+#endif
+
+struct DISPLAY_OPTIONS displayOptions;
+
+GLenum stereoCompile = GL_FALSE ;
+GLenum stereoShowing = GL_FALSE ;
+GLenum stereoBuffer = GL_FALSE;
+#if !defined(NO_STEREO)
+GLint displayList = MAXIMUM_DISPLAY_LIST ;
+#endif
+GLint stereo_flag = 0 ;
+
+/* end of added code*/
+
+static PWMC Current = NULL;
+WMesaContext WC = NULL;
+
+#ifdef NDEBUG
+#define assert(ignore) ((void) 0)
+#else
+void Mesa_Assert(void *Cond,void *File,unsigned Line)
+{
+ char Msg[512];
+ sprintf(Msg,"%s %s %d",Cond,File,Line);
+ MessageBox(NULL,Msg,"Assertion failed.",MB_OK);
+ exit(1);
+}
+#define assert(e) if (!e) Mesa_Assert(#e,__FILE__,__LINE__);
+#endif
+
+//#define DD_GETDC (Current->hDC )
+#define DD_GETDC ((Current->db_flag) ? Current->dib.hDC : Current->hDC )
+//#define DD_GETDC ((Current->db_flag) ? Current->hDCPrimary : Current->hDCBack )
+#define DD_RELEASEDC
+
+//#define BEGINGDICALL if(Current->rgb_flag)wmFlushBits(Current);
+#define BEGINGDICALL
+//#define ENDGDICALL if(Current->rgb_flag)wmGetBits(Current);
+#define ENDGDICALL
+
+//#define FLIP(Y) (Current->dither_flag? Y : Current->height-(Y)-1)
+//#define FLIP(Y) (Current->height-(Y)-1)
+//#define FLIP(Y) Y
+/*
+ * XXX Why only flip Y coord if single buffered???
+ */
+#define FLIP(Y) (Current->db_flag? Y: Current->height-(Y)-1)
+#define STARTPROFILE
+#define ENDPROFILE(PARA)
+
+#define DITHER_RGB_TO_8BIT_SETUP \
+GLubyte pixelDithered;
+
+#define DITHER_RGB_TO_8BIT(red, green, blue, pixel, scanline) \
+{ \
+ char unsigned redtemp, greentemp, bluetemp, paletteindex; \
+ redtemp = aDividedBy51[red] \
+ + (aModulo51[red] > aHalftone8x8[(pixel%8)*8 \
+ + scanline%8]); \
+ greentemp = aDividedBy51[(char unsigned)green] \
+ + (aModulo51[green] > aHalftone8x8[ \
+ (pixel%8)*8 + scanline%8]); \
+ bluetemp = aDividedBy51[(char unsigned)blue] \
+ + (aModulo51[blue] > aHalftone8x8[ \
+ (pixel%8)*8 +scanline%8]); \
+ paletteindex = redtemp + aTimes6[greentemp] + aTimes36[bluetemp]; \
+ pixelDithered = aWinGHalftoneTranslation[paletteindex]; \
+}
+
+
+#ifdef DDRAW
+static BOOL DDInit( WMesaContext wc, HWND hwnd);
+static void DDFree( WMesaContext wc);
+static HRESULT DDRestoreAll( WMesaContext wc );
+static void DDDeleteOffScreen(WMesaContext wc);
+static BOOL DDCreateOffScreen(WMesaContext wc);
+#endif
+
+static void FlushToFile(PWMC pwc, PSTR szFile);
+
+BOOL wmCreateBackingStore(PWMC pwc, long lxSize, long lySize);
+BOOL wmDeleteBackingStore(PWMC pwc);
+void wmCreatePalette( PWMC pwdc );
+BOOL wmSetDibColors(PWMC pwc);
+void wmSetPixel(PWMC pwc, int iScanLine, int iPixel, BYTE r, BYTE g, BYTE b);
+
+void wmCreateDIBSection(
+ HDC hDC,
+ PWMC pwc, // handle of device context
+ CONST BITMAPINFO *pbmi, // address of structure containing bitmap size, format, and color data
+ UINT iUsage // color data type indicator: RGB values or palette indices
+ );
+
+
+void WMesaViewport( GLcontext *ctx,
+ GLint x, GLint y, GLsizei width, GLsizei height );
+
+
+//static triangle_func choose_triangle_function( GLcontext *ctx );
+
+
+static void wmSetPixelFormat( PWMC wc, HDC hDC)
+{
+ if(wc->rgb_flag)
+ wc->cColorBits = GetDeviceCaps(hDC, BITSPIXEL);
+ else
+ wc->cColorBits = 8;
+ switch(wc->cColorBits){
+ case 8:
+ if(wc->dither_flag != GL_TRUE)
+ wc->pixelformat = PF_INDEX8;
+ else
+ wc->pixelformat = PF_DITHER8;
+ break;
+ case 16:
+ wc->pixelformat = PF_5R6G5B;
+ break;
+ case 32:
+ wc->pixelformat = PF_8R8G8B;
+ break;
+ default:
+ wc->pixelformat = PF_BADFORMAT;
+ }
+}
+
+//
+// This function sets the color table of a DIB section
+// to match that of the destination DC
+//
+BOOL /*WINAPI*/ wmSetDibColors(PWMC pwc)
+{
+ RGBQUAD *pColTab, *pRGB;
+ PALETTEENTRY *pPal, *pPE;
+ int i, nColors;
+ BOOL bRet=TRUE;
+ DWORD dwErr=0;
+
+ /* Build a color table in the DIB that maps to the
+ selected palette in the DC.
+ */
+ nColors = 1 << pwc->cColorBits;
+ pPal = (PALETTEENTRY *)malloc( nColors * sizeof(PALETTEENTRY));
+ memset( pPal, 0, nColors * sizeof(PALETTEENTRY) );
+ GetPaletteEntries( pwc->hGLPalette, 0, nColors, pPal );
+ pColTab = (RGBQUAD *)malloc( nColors * sizeof(RGBQUAD));
+ for (i = 0, pRGB = pColTab, pPE = pPal; i < nColors; i++, pRGB++, pPE++) {
+ pRGB->rgbRed = pPE->peRed;
+ pRGB->rgbGreen = pPE->peGreen;
+ pRGB->rgbBlue = pPE->peBlue;
+ }
+ if(pwc->db_flag)
+ bRet = SetDIBColorTable(pwc->dib.hDC, 0, nColors, pColTab );
+
+ if(!bRet)
+ dwErr = GetLastError();
+
+ free( pColTab );
+ free( pPal );
+
+ return(bRet);
+}
+
+
+//
+// Free up the dib section that was created
+//
+BOOL wmDeleteBackingStore(PWMC pwc)
+{
+ SelectObject(pwc->dib.hDC, pwc->hOldBitmap);
+ DeleteDC(pwc->dib.hDC);
+ DeleteObject(pwc->hbmDIB);
+ UnmapViewOfFile(pwc->dib.base);
+ CloseHandle(pwc->dib.hFileMap);
+ return TRUE;
+}
+
+
+//
+// This function creates the DIB section that is used for combined
+// GL and GDI calls
+//
+BOOL /*WINAPI*/ wmCreateBackingStore(PWMC pwc, long lxSize, long lySize)
+{
+ HDC hdc = pwc->hDC;
+ LPBITMAPINFO pbmi = &(pwc->bmi);
+ int iUsage;
+
+ pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+ pbmi->bmiHeader.biWidth = lxSize;
+ pbmi->bmiHeader.biHeight= -lySize;
+ pbmi->bmiHeader.biPlanes = 1;
+ if(pwc->rgb_flag)
+ pbmi->bmiHeader.biBitCount = GetDeviceCaps(pwc->hDC, BITSPIXEL);
+ else
+ pbmi->bmiHeader.biBitCount = 8;
+ pbmi->bmiHeader.biCompression = BI_RGB;
+ pbmi->bmiHeader.biSizeImage = 0;
+ pbmi->bmiHeader.biXPelsPerMeter = 0;
+ pbmi->bmiHeader.biYPelsPerMeter = 0;
+ pbmi->bmiHeader.biClrUsed = 0;
+ pbmi->bmiHeader.biClrImportant = 0;
+
+ iUsage = (pbmi->bmiHeader.biBitCount <= 8) ? DIB_PAL_COLORS : DIB_RGB_COLORS;
+
+ pwc->cColorBits = pbmi->bmiHeader.biBitCount;
+ pwc->ScanWidth = pwc->pitch = lxSize;
+
+ wmCreateDIBSection(hdc, pwc, pbmi, iUsage);
+
+ if ((iUsage == DIB_PAL_COLORS) && !(pwc->hGLPalette)) {
+ wmCreatePalette( pwc );
+ wmSetDibColors( pwc );
+ }
+ wmSetPixelFormat(pwc, pwc->hDC);
+ return(TRUE);
+
+}
+
+
+//
+// This function copies one scan line in a DIB section to another
+//
+BOOL WINAPI wmSetDIBits(PWMC pwc, UINT uiScanWidth, UINT uiNumScans, UINT nBypp, UINT uiNewWidth, LPBYTE pBits)
+{
+ UINT uiScans = 0;
+ LPBYTE pDest = pwc->pbPixels;
+ DWORD dwNextScan = uiScanWidth;
+ DWORD dwNewScan = uiNewWidth;
+ DWORD dwScanWidth = (uiScanWidth * nBypp);
+
+ //
+ // We need to round up to the nearest DWORD
+ // and multiply by the number of bytes per
+ // pixel
+ //
+ dwNextScan = (((dwNextScan * nBypp)+ 3) & ~3);
+ dwNewScan = (((dwNewScan * nBypp)+ 3) & ~3);
+
+ for(uiScans = 0; uiScans < uiNumScans; uiScans++){
+ CopyMemory(pDest, pBits, dwScanWidth);
+ pBits += dwNextScan;
+ pDest += dwNewScan;
+ }
+
+ return(TRUE);
+
+}
+
+
+BOOL wmFlush(PWMC pwc);
+
+/*
+* Useful macros:
+Modified from file osmesa.c
+*/
+
+
+#define PIXELADDR(X,Y) ((GLubyte *)Current->pbPixels + (Current->height-Y-1)* Current->ScanWidth + (X)*nBypp)
+#define PIXELADDR1( X, Y ) \
+((GLubyte *)wmesa->pbPixels + (wmesa->height-Y-1)* wmesa->ScanWidth + (X))
+#define PIXELADDR2( X, Y ) \
+((GLubyte *)wmesa->pbPixels + (wmesa->height-Y-1)* wmesa->ScanWidth + (X)*2)
+#define PIXELADDR4( X, Y ) \
+((GLubyte *)wmesa->pbPixels + (wmesa->height-Y-1)* wmesa->ScanWidth + (X)*4)
+
+
+BYTE DITHER_RGB_2_8BIT( int r, int g, int b, int x, int y);
+
+/* Finish all pending operations and synchronize. */
+static void finish(GLcontext* ctx)
+{
+ /* No op */
+}
+
+
+//
+// We cache all gl draw routines until a flush is made
+//
+static void flush(GLcontext* ctx)
+{
+ STARTPROFILE
+ if((Current->rgb_flag /*&& !(Current->dib.fFlushed)*/&&!(Current->db_flag))
+ ||(!Current->rgb_flag))
+ {
+ wmFlush(Current);
+ }
+ ENDPROFILE(flush)
+
+}
+
+
+
+/*
+* Set the color index used to clear the color buffer.
+*/
+static void clear_index(GLcontext* ctx, GLuint index)
+{
+ STARTPROFILE
+ Current->clearpixel = index;
+ ENDPROFILE(clear_index)
+}
+
+
+
+/*
+* Set the color used to clear the color buffer.
+*/
+static void clear_color( GLcontext* ctx, const GLchan color[4] )
+{
+ STARTPROFILE
+ Current->clearpixel = RGB(color[0], color[1], color[2]);
+ ENDPROFILE(clear_color)
+}
+
+
+
+/*
+* Clear the specified region of the color buffer using the clear color
+* or index as specified by one of the two functions above.
+*/
+//static void clear(GLcontext* ctx,
+// GLboolean all,GLint x, GLint y, GLint width, GLint height )
+// TODO: I modified this function to match the prototype in
+// dd.h. (swansma@geocities.com)
+
+static GLbitfield clear(GLcontext* ctx, GLbitfield mask,
+ GLboolean all, GLint x, GLint y, GLint width, GLint height)
+{
+ DWORD dwColor;
+ WORD wColor;
+ BYTE bColor;
+ LPDWORD lpdw = (LPDWORD)Current->pbPixels;
+ LPWORD lpw = (LPWORD)Current->pbPixels;
+ LPBYTE lpb = Current->pbPixels;
+ int lines;
+
+ STARTPROFILE
+
+ if (all){
+ x=y=0;
+ width=Current->width;
+ height=Current->height;
+ }
+ if(Current->db_flag==GL_TRUE){
+ UINT nBypp = Current->cColorBits / 8;
+ int i = 0;
+ int iSize = 0;
+
+ if(nBypp ==1 ){
+ /* Need rectification */
+ iSize = Current->width/4;
+ bColor = BGR8(GetRValue(Current->clearpixel),
+ GetGValue(Current->clearpixel),
+ GetBValue(Current->clearpixel));
+ wColor = MAKEWORD(bColor,bColor);
+ dwColor = MAKELONG(wColor, wColor);
+ }
+ if(nBypp == 2){
+ iSize = Current->width / 2;
+ wColor = BGR16(GetRValue(Current->clearpixel),
+ GetGValue(Current->clearpixel),
+ GetBValue(Current->clearpixel));
+ dwColor = MAKELONG(wColor, wColor);
+ }
+ else if(nBypp == 4){
+ iSize = Current->width;
+ dwColor = BGR32(GetRValue(Current->clearpixel),
+ GetGValue(Current->clearpixel),
+ GetBValue(Current->clearpixel));
+ }
+
+ while(i < iSize){
+ *lpdw = dwColor;
+ lpdw++;
+ i++;
+ }
+
+ //
+ // This is the 24bit case
+ //
+ if (nBypp == 3) {
+ iSize = Current->width *3/4;
+ dwColor = BGR24(GetRValue(Current->clearpixel),
+ GetGValue(Current->clearpixel),
+ GetBValue(Current->clearpixel));
+ while(i < iSize){
+ *lpdw = dwColor;
+ lpb += nBypp;
+ lpdw = (LPDWORD)lpb;
+ i++;
+ }
+ }
+
+ i = 0;
+ if (stereo_flag)
+ lines = height /2;
+ else
+ lines = height;
+ do {
+ memcpy(lpb, Current->pbPixels, iSize*4);
+ lpb += Current->ScanWidth;
+ i++;
+ }
+ while (i<lines-1);
+ }
+ else { // For single buffer
+ HDC DC=DD_GETDC;
+ HPEN Pen=CreatePen(PS_SOLID,1,Current->clearpixel);
+ HBRUSH Brush=CreateSolidBrush(Current->clearpixel);
+ HPEN Old_Pen=SelectObject(DC,Pen);
+ HBRUSH Old_Brush=SelectObject(DC,Brush);
+ Rectangle(DC,x,y,x+width,y+height);
+ SelectObject(DC,Old_Pen);
+ SelectObject(DC,Old_Brush);
+ DeleteObject(Pen);
+ DeleteObject(Brush);
+ DD_RELEASEDC;
+ }
+
+
+
+ ENDPROFILE(clear)
+
+ return mask; // TODO: I doubt this is correct. dd.h doesn't explain what this should
+ // be...
+}
+
+
+
+static void enable( GLcontext* ctx, GLenum pname, GLboolean enable )
+{
+ if (!Current)
+ return;
+
+ if (pname == GL_DITHER) {
+ if(enable == GL_FALSE){
+ Current->dither_flag = GL_FALSE;
+ if(Current->cColorBits == 8)
+ Current->pixelformat = PF_INDEX8;
+ }
+ else{
+ if (Current->rgb_flag && Current->cColorBits == 8){
+ Current->pixelformat = PF_DITHER8;
+ Current->dither_flag = GL_TRUE;
+ }
+ else
+ Current->dither_flag = GL_FALSE;
+ }
+ }
+}
+
+
+
+static GLboolean set_draw_buffer( GLcontext* ctx, GLenum mode )
+{
+ STARTPROFILE
+ /* TODO: this could be better */
+ if (mode==GL_FRONT_LEFT || mode==GL_BACK_LEFT) {
+ return GL_TRUE;
+ }
+ else {
+ return GL_FALSE;
+ }
+ ENDPROFILE(set_draw_buffer)
+}
+
+
+static void set_read_buffer(GLcontext *ctx, GLframebuffer *colorBuffer,
+ GLenum buffer )
+{
+ /* XXX todo */
+ return;
+}
+
+
+
+/* Return characteristics of the output buffer. */
+static void buffer_size( GLcontext* ctx, GLuint *width, GLuint *height )
+{
+ int New_Size;
+ RECT CR;
+
+ STARTPROFILE
+ GetClientRect(Current->Window,&CR);
+
+ *width=CR.right;
+ *height=CR.bottom;
+
+ New_Size=((*width)!=Current->width) || ((*height)!=Current->height);
+
+ if (New_Size){
+ Current->width=*width;
+ Current->height=*height;
+ Current->ScanWidth=Current->width;
+ if ((Current->ScanWidth%sizeof(long))!=0)
+ Current->ScanWidth+=(sizeof(long)-(Current->ScanWidth%sizeof(long)));
+
+ if (Current->db_flag){
+#ifdef DDRAW
+ DDDeleteOffScreen(Current);
+ DDCreateOffScreen(Current);
+#else
+ if (Current->rgb_flag==GL_TRUE && Current->dither_flag!=GL_TRUE){
+ wmDeleteBackingStore(Current);
+ wmCreateBackingStore(Current, Current->width, Current->height);
+ }
+#endif
+ }
+
+ // Resize OsmesaBuffer if in Parallel mode
+#if !defined(NO_PARALLEL)
+ if(parallelFlag)
+ PRSizeRenderBuffer(Current->width, Current->height,Current->ScanWidth,
+ Current->rgb_flag == GL_TRUE ? Current->pbPixels: Current->ScreenMem);
+#endif
+ }
+ ENDPROFILE(buffer_size)
+}
+
+
+
+/**********************************************************************/
+/***** Accelerated point, line, polygon rendering *****/
+/**********************************************************************/
+
+
+static void fast_rgb_points( GLcontext* ctx, GLuint first, GLuint last )
+{
+#if 0
+ GLuint i;
+ // HDC DC=DD_GETDC;
+ PWMC pwc = Current;
+
+ STARTPROFILE
+
+ if (0 /*Current->gl_ctx->VB->MonoColor*/) {
+ /* all drawn with current color */
+ for (i=first;i<=last;i++) {
+ if (!Current->gl_ctx->VB->ClipMask[i]) {
+ int x, y;
+ x = (GLint) Current->gl_ctx->VB->Win.data[i][0];
+ y = FLIP( (GLint) Current->gl_ctx->VB->Win.data[i][1] );
+ wmSetPixel(pwc, y,x,GetRValue(Current->pixel),
+ GetGValue(Current->pixel), GetBValue(Current->pixel));
+ }
+ }
+ }
+ else {
+ /* draw points of different colors */
+ for (i=first;i<=last;i++) {
+ if (!Current->gl_ctx->VB->ClipMask[i]) {
+ int x, y;
+ unsigned long pixel=RGB(Current->gl_ctx->VB->ColorPtr->data[i][0]*255.0,
+ Current->gl_ctx->VB->ColorPtr->data[i][1]*255.0,
+ Current->gl_ctx->VB->ColorPtr->data[i][2]*255.0);
+ x = (GLint) Current->gl_ctx->VB->Win.data[i][0];
+ y = FLIP( (GLint) Current->gl_ctx->VB->Win.data[i][1] );
+ wmSetPixel(pwc, y,x,Current->gl_ctx->VB->ColorPtr->data[i][0]*255.0,
+ Current->gl_ctx->VB->ColorPtr->data[i][1]*255.0,
+ Current->gl_ctx->VB->ColorPtr->data[i][2]*255.0);
+ }
+ }
+ }
+ // DD_RELEASEDC;
+ ENDPROFILE(fast_rgb_points)
+#endif
+}
+
+
+
+/* Return pointer to accerated points function */
+extern /*points_func*/ choose_points_function( GLcontext* ctx )
+{
+#if 0
+ STARTPROFILE
+ if (ctx->Point.Size==1.0 && !ctx->Point.SmoothFlag && ctx->_RasterMask==0
+ && !ctx->Texture._ReallyEnabled && ctx->Visual->RGBAflag) {
+ ENDPROFILE(choose_points_function)
+ return fast_rgb_points;
+ }
+ else {
+ ENDPROFILE(choose_points_function)
+ return NULL;
+ }
+#endif
+}
+
+
+
+/* Draw a line using the color specified by Current->gl_ctx->VB->ColorPtr->data[pv] */
+static void fast_flat_rgb_line( GLcontext* ctx, GLuint v0, GLuint v1, GLuint pv )
+{
+#if 0
+ STARTPROFILE
+ int x0, y0, x1, y1;
+ unsigned long pixel;
+ HDC DC=DD_GETDC;
+ HPEN Pen;
+ HPEN Old_Pen;
+
+ if (0 /*Current->gl_ctx->VB->MonoColor*/) {
+ pixel = Current->pixel; /* use current color */
+ }
+ else {
+ pixel = RGB(Current->gl_ctx->VB->ColorPtr->data[pv][0]*255.0, Current->gl_ctx->VB->ColorPtr->data[pv][1]*255.0, Current->gl_ctx->VB->ColorPtr->data[pv][2]*255.0);
+ }
+
+ x0 = (int) Current->gl_ctx->VB->Win.data[v0][0];
+ y0 = FLIP( (int) Current->gl_ctx->VB->Win.data[v0][1] );
+ x1 = (int) Current->gl_ctx->VB->Win.data[v1][0];
+ y1 = FLIP( (int) Current->gl_ctx->VB->Win.data[v1][1] );
+
+
+ BEGINGDICALL
+
+ Pen=CreatePen(PS_SOLID,1,pixel);
+ Old_Pen=SelectObject(DC,Pen);
+ MoveToEx(DC,x0,y0,NULL);
+ LineTo(DC,x1,y1);
+ SelectObject(DC,Old_Pen);
+ DeleteObject(Pen);
+ DD_RELEASEDC;
+
+ ENDGDICALL
+
+ ENDPROFILE(fast_flat_rgb_line)
+#endif
+}
+
+
+
+/* Return pointer to accerated line function */
+static /*line_func*/ choose_line_function( GLcontext* ctx )
+{
+#if 0
+ STARTPROFILE
+ if (ctx->Line.Width==1.0 && !ctx->Line.SmoothFlag && !ctx->Line.StippleFlag
+ && ctx->Light.ShadeModel==GL_FLAT && ctx->_RasterMask==0
+ && !ctx->Texture._ReallyEnabled && Current->rgb_flag) {
+ ENDPROFILE(choose_line_function)
+ return fast_flat_rgb_line;
+ }
+ else {
+ ENDPROFILE(choose_line_function)
+ return NULL;
+ }
+#endif
+}
+
+
+/**********************************************************************/
+/***** Span-based pixel drawing *****/
+/**********************************************************************/
+
+
+/* Write a horizontal span of 32-bit color-index pixels with a boolean mask. */
+static void write_ci32_span( const GLcontext* ctx,
+ GLuint n, GLint x, GLint y,
+ const GLuint index[],
+ const GLubyte mask[] )
+{
+ STARTPROFILE
+ GLuint i;
+ PBYTE Mem=Current->ScreenMem+FLIP(y)*Current->ScanWidth+x;
+ assert(Current->rgb_flag==GL_FALSE);
+ for (i=0; i<n; i++)
+ if (mask[i])
+ Mem[i]=index[i];
+ ENDPROFILE(write_ci32_span)
+}
+
+
+/* Write a horizontal span of 8-bit color-index pixels with a boolean mask. */
+static void write_ci8_span( const GLcontext* ctx,
+ GLuint n, GLint x, GLint y,
+ const GLubyte index[],
+ const GLubyte mask[] )
+{
+ STARTPROFILE
+ GLuint i;
+ PBYTE Mem=Current->ScreenMem+FLIP(y)*Current->ScanWidth+x;
+ assert(Current->rgb_flag==GL_FALSE);
+ for (i=0; i<n; i++)
+ if (mask[i])
+ Mem[i]=index[i];
+ ENDPROFILE(write_ci8_span)
+}
+
+
+
+/*
+* Write a horizontal span of pixels with a boolean mask. The current
+* color index is used for all pixels.
+*/
+static void write_mono_ci_span(const GLcontext* ctx,
+ GLuint n,GLint x,GLint y,
+ GLuint colorIndex, const GLubyte mask[])
+{
+ STARTPROFILE
+ GLuint i;
+ BYTE *Mem=Current->ScreenMem+FLIP(y)*Current->ScanWidth+x;
+ assert(Current->rgb_flag==GL_FALSE);
+ for (i=0; i<n; i++)
+ if (mask[i])
+ Mem[i]=colorIndex;
+ ENDPROFILE(write_mono_ci_span)
+}
+
+/*
+ * To improve the performance of this routine, frob the data into an actual
+ * scanline and call bitblt on the complete scan line instead of SetPixel.
+ */
+
+/* Write a horizontal span of RGBA color pixels with a boolean mask. */
+static void write_rgba_span( const GLcontext* ctx, GLuint n, GLint x, GLint y,
+ const GLubyte rgba[][4], const GLubyte mask[] )
+{
+ STARTPROFILE
+ PWMC pwc = Current;
+
+ if (pwc->rgb_flag==GL_TRUE)
+ {
+ GLuint i;
+ HDC DC=DD_GETDC;
+ y=FLIP(y);
+ if (mask) {
+ for (i=0; i<n; i++)
+ if (mask[i])
+ wmSetPixel(pwc, y, x + i, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+ }
+ else {
+ for (i=0; i<n; i++)
+ wmSetPixel(pwc, y, x + i, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ }
+ DD_RELEASEDC;
+ }
+ else
+ {
+ GLuint i;
+ BYTE *Mem=Current->ScreenMem+y*Current->ScanWidth+x;
+ y = FLIP(y);
+ if (mask) {
+ for (i=0; i<n; i++)
+ if (mask[i])
+ Mem[i] = GetNearestPaletteIndex(Current->hPal,RGB(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]));
+ }
+ else {
+ for (i=0; i<n; i++)
+ Mem[i] = GetNearestPaletteIndex(Current->hPal,RGB(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]));
+ }
+ }
+ ENDPROFILE(write_rgba_span)
+
+}
+
+/* Write a horizontal span of RGB color pixels with a boolean mask. */
+static void write_rgb_span( const GLcontext* ctx,
+ GLuint n, GLint x, GLint y,
+ const GLubyte rgb[][3], const GLubyte mask[] )
+{
+ STARTPROFILE
+ PWMC pwc = Current;
+
+ if (pwc->rgb_flag==GL_TRUE)
+ {
+ GLuint i;
+ HDC DC=DD_GETDC;
+ y=FLIP(y);
+ if (mask) {
+ for (i=0; i<n; i++)
+ if (mask[i])
+ wmSetPixel(pwc, y, x + i, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+ }
+ else {
+ for (i=0; i<n; i++)
+ wmSetPixel(pwc, y, x + i, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+ }
+ DD_RELEASEDC;
+ }
+ else
+ {
+ GLuint i;
+ BYTE *Mem=Current->ScreenMem+y*Current->ScanWidth+x;
+ y = FLIP(y);
+ if (mask) {
+ for (i=0; i<n; i++)
+ if (mask[i])
+ Mem[i] = GetNearestPaletteIndex(Current->hPal,RGB(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]));
+ }
+ else {
+ for (i=0; i<n; i++)
+ Mem[i] = GetNearestPaletteIndex(Current->hPal,RGB(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]));
+ }
+ }
+ ENDPROFILE(write_rgb_span)
+
+}
+
+/*
+* Write a horizontal span of pixels with a boolean mask. The current color
+* is used for all pixels.
+*/
+static void write_mono_rgba_span( const GLcontext* ctx,
+ GLuint n, GLint x, GLint y,
+ const GLchan color[4], const GLubyte mask[])
+{
+ ULONG pixel = RGB( color[RCOMP], color[GCOMP], color[BCOMP] );
+ STARTPROFILE
+ GLuint i;
+ HDC DC=DD_GETDC;
+ PWMC pwc = Current;
+ assert(Current->rgb_flag==GL_TRUE);
+ y=FLIP(y);
+ if(Current->rgb_flag==GL_TRUE){
+ for (i=0; i<n; i++)
+ if (mask[i])
+ // Trying
+ wmSetPixel(pwc,y,x+i,color[RCOMP], color[GCOMP], color[BCOMP]);
+ }
+ else {
+ for (i=0; i<n; i++)
+ if (mask[i])
+ SetPixel(DC, y, x+i, pixel);
+ }
+ DD_RELEASEDC;
+ ENDPROFILE(write_mono_rgba_span)
+}
+
+
+
+/**********************************************************************/
+/***** Array-based pixel drawing *****/
+/**********************************************************************/
+
+
+/* Write an array of 32-bit index pixels with a boolean mask. */
+static void write_ci32_pixels( const GLcontext* ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ const GLuint index[], const GLubyte mask[] )
+{
+ STARTPROFILE
+ GLuint i;
+ assert(Current->rgb_flag==GL_FALSE);
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ BYTE *Mem=Current->ScreenMem+FLIP(y[i])*Current->ScanWidth+x[i];
+ *Mem = index[i];
+ }
+ }
+ ENDPROFILE(write_ci32_pixels)
+}
+
+
+
+/*
+* Write an array of pixels with a boolean mask. The current color
+* index is used for all pixels.
+*/
+static void write_mono_ci_pixels( const GLcontext* ctx,
+ GLuint n,
+ const GLint x[], const GLint y[],
+ GLuint colorIndex, const GLubyte mask[] )
+{
+ STARTPROFILE
+ GLuint i;
+ assert(Current->rgb_flag==GL_FALSE);
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ BYTE *Mem=Current->ScreenMem+FLIP(y[i])*Current->ScanWidth+x[i];
+ *Mem = colorIndex;
+ }
+ }
+ ENDPROFILE(write_mono_ci_pixels)
+}
+
+
+
+/* Write an array of RGBA pixels with a boolean mask. */
+static void write_rgba_pixels( const GLcontext* ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ const GLubyte rgba[][4], const GLubyte mask[] )
+{
+ STARTPROFILE
+ GLuint i;
+ PWMC pwc = Current;
+ HDC DC=DD_GETDC;
+ assert(Current->rgb_flag==GL_TRUE);
+ for (i=0; i<n; i++)
+ if (mask[i])
+ wmSetPixel(pwc, FLIP(y[i]), x[i],
+ rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+ DD_RELEASEDC;
+ ENDPROFILE(write_rgba_pixels)
+}
+
+
+
+/*
+* Write an array of pixels with a boolean mask. The current color
+* is used for all pixels.
+*/
+static void write_mono_rgba_pixels( const GLcontext* ctx,
+ GLuint n,
+ const GLint x[], const GLint y[],
+ const GLchan color[4],
+ const GLubyte mask[] )
+{
+ STARTPROFILE
+ GLuint i;
+ PWMC pwc = Current;
+ HDC DC=DD_GETDC;
+ assert(Current->rgb_flag==GL_TRUE);
+ for (i=0; i<n; i++)
+ if (mask[i])
+ wmSetPixel(pwc, FLIP(y[i]),x[i],color[RCOMP],
+ color[GCOMP], color[BCOMP]);
+ DD_RELEASEDC;
+ ENDPROFILE(write_mono_rgba_pixels)
+}
+
+
+
+/**********************************************************************/
+/***** Read spans/arrays of pixels *****/
+/**********************************************************************/
+
+
+/* Read a horizontal span of color-index pixels. */
+static void read_ci32_span( const GLcontext* ctx, GLuint n, GLint x, GLint y,
+ GLuint index[])
+{
+ STARTPROFILE
+ GLuint i;
+ BYTE *Mem=Current->ScreenMem+FLIP(y)*Current->ScanWidth+x;
+ assert(Current->rgb_flag==GL_FALSE);
+ for (i=0; i<n; i++)
+ index[i]=Mem[i];
+ ENDPROFILE(read_ci32_span)
+}
+
+
+
+
+/* Read an array of color index pixels. */
+static void read_ci32_pixels( const GLcontext* ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ GLuint indx[], const GLubyte mask[] )
+{
+ STARTPROFILE
+ GLuint i;
+ assert(Current->rgb_flag==GL_FALSE);
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ indx[i]=*(Current->ScreenMem+FLIP(y[i])*Current->ScanWidth+x[i]);
+ }
+ }
+ ENDPROFILE(read_ci32_pixels)
+}
+
+
+
+/* Read a horizontal span of color pixels. */
+static void read_rgba_span( const GLcontext* ctx,
+ GLuint n, GLint x, GLint y,
+ GLubyte rgba[][4] )
+{
+ STARTPROFILE
+ UINT i;
+ COLORREF Color;
+ HDC DC=DD_GETDC;
+ assert(Current->rgb_flag==GL_TRUE);
+ /* y=FLIP(y);*/
+ y = Current->height - y - 1;
+ for (i=0; i<n; i++) {
+ Color=GetPixel(DC,x+i,y);
+ rgba[i][RCOMP] = GetRValue(Color);
+ rgba[i][GCOMP] = GetGValue(Color);
+ rgba[i][BCOMP] = GetBValue(Color);
+ rgba[i][ACOMP] = 255;
+ }
+ DD_RELEASEDC;
+// Brian P. Has mentioned to comment this out.
+// memset(alpha,0,n*sizeof(GLubyte));
+ ENDPROFILE(read_rgba_span)
+}
+
+
+/* Read an array of color pixels. */
+static void read_rgba_pixels( const GLcontext* ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ GLubyte rgba[][4], const GLubyte mask[] )
+{
+ STARTPROFILE
+ GLuint i;
+ COLORREF Color;
+ HDC DC=DD_GETDC;
+ assert(Current->rgb_flag==GL_TRUE);
+ for (i=0; i<n; i++) {
+ if (mask[i]) {
+ GLint y2 = Current->height - y[i] - 1;
+ Color=GetPixel(DC,x[i],y2);
+ rgba[i][RCOMP] = GetRValue(Color);
+ rgba[i][GCOMP] = GetGValue(Color);
+ rgba[i][BCOMP] = GetBValue(Color);
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ DD_RELEASEDC;
+// Brian P. has mentioned to comment this out.
+// memset(alpha,0,n*sizeof(GLint));
+ ENDPROFILE(read_rgba_pixels)
+}
+
+
+
+/**********************************************************************/
+/**********************************************************************/
+
+
+static const GLubyte *get_string(GLcontext *ctx, GLenum name)
+{
+ if (name == GL_RENDERER) {
+ return (GLubyte *) "Mesa Windows";
+ }
+ else {
+ return NULL;
+ }
+}
+
+
+
+void setup_DD_pointers( GLcontext* ctx )
+{
+#if 0
+ ctx->Driver.GetString = get_string;
+ ctx->Driver.UpdateState = setup_DD_pointers;
+ ctx->Driver.GetBufferSize = buffer_size;
+ ctx->Driver.Finish = finish;
+ ctx->Driver.Flush = flush;
+
+ ctx->Driver.ClearIndex = clear_index;
+ ctx->Driver.ClearColor = clear_color;
+ ctx->Driver.Clear = clear;
+
+ ctx->Driver.Enable = enable;
+
+ ctx->Driver.SetDrawBuffer = set_draw_buffer;
+ ctx->Driver.SetReadBuffer = set_read_buffer;
+ ctx->Driver.GetBufferSize = buffer_size;
+
+ ctx->Driver.PointsFunc = choose_points_function(ctx);
+ ctx->Driver.LineFunc = choose_line_function(ctx);
+ ctx->Driver.TriangleFunc = choose_triangle_function( ctx );
+
+ /* Pixel/span writing functions: */
+ ctx->Driver.WriteRGBASpan = write_rgba_span;
+ ctx->Driver.WriteRGBSpan = write_rgb_span;
+ ctx->Driver.WriteMonoRGBASpan = write_mono_rgba_span;
+ ctx->Driver.WriteRGBAPixels = write_rgba_pixels;
+ ctx->Driver.WriteMonoRGBAPixels = write_mono_rgba_pixels;
+ ctx->Driver.WriteCI32Span = write_ci32_span;
+ ctx->Driver.WriteCI8Span = write_ci8_span;
+ ctx->Driver.WriteMonoCISpan = write_mono_ci_span;
+ ctx->Driver.WriteCI32Pixels = write_ci32_pixels;
+ ctx->Driver.WriteMonoCIPixels = write_mono_ci_pixels;
+
+ ctx->Driver.ReadCI32Span = read_ci32_span;
+ ctx->Driver.ReadRGBASpan = read_rgba_span;
+ ctx->Driver.ReadCI32Pixels = read_ci32_pixels;
+ ctx->Driver.ReadRGBAPixels = read_rgba_pixels;
+#endif
+}
+
+
+/**********************************************************************/
+/***** WMesa API Functions *****/
+/**********************************************************************/
+
+
+
+#define PAL_SIZE 256
+static void GetPalette(HPALETTE Pal,RGBQUAD *aRGB)
+{
+ STARTPROFILE
+ int i;
+ HDC hdc;
+ struct
+ {
+ WORD Version;
+ WORD NumberOfEntries;
+ PALETTEENTRY aEntries[PAL_SIZE];
+ } Palette =
+ {
+ 0x300,
+ PAL_SIZE
+ };
+ hdc=GetDC(NULL);
+ if (Pal!=NULL)
+ GetPaletteEntries(Pal,0,PAL_SIZE,Palette.aEntries);
+ else
+ GetSystemPaletteEntries(hdc,0,PAL_SIZE,Palette.aEntries);
+ if (GetSystemPaletteUse(hdc) == SYSPAL_NOSTATIC)
+ {
+ for(i = 0; i <PAL_SIZE; i++)
+ Palette.aEntries[i].peFlags = PC_RESERVED;
+ Palette.aEntries[255].peRed = 255;
+ Palette.aEntries[255].peGreen = 255;
+ Palette.aEntries[255].peBlue = 255;
+ Palette.aEntries[255].peFlags = 0;
+ Palette.aEntries[0].peRed = 0;
+ Palette.aEntries[0].peGreen = 0;
+ Palette.aEntries[0].peBlue = 0;
+ Palette.aEntries[0].peFlags = 0;
+ }
+ else
+ {
+ int nStaticColors;
+ int nUsableColors;
+ nStaticColors = GetDeviceCaps(hdc, NUMCOLORS)/2;
+ for (i=0; i<nStaticColors; i++)
+ Palette.aEntries[i].peFlags = 0;
+ nUsableColors = PAL_SIZE-nStaticColors;
+ for (; i<nUsableColors; i++)
+ Palette.aEntries[i].peFlags = PC_RESERVED;
+ for (; i<PAL_SIZE-nStaticColors; i++)
+ Palette.aEntries[i].peFlags = PC_RESERVED;
+ for (i=PAL_SIZE-nStaticColors; i<PAL_SIZE; i++)
+ Palette.aEntries[i].peFlags = 0;
+ }
+ ReleaseDC(NULL,hdc);
+ for (i=0; i<PAL_SIZE; i++)
+ {
+ aRGB[i].rgbRed=Palette.aEntries[i].peRed;
+ aRGB[i].rgbGreen=Palette.aEntries[i].peGreen;
+ aRGB[i].rgbBlue=Palette.aEntries[i].peBlue;
+ aRGB[i].rgbReserved=Palette.aEntries[i].peFlags;
+ }
+ ENDPROFILE(GetPalette)
+}
+
+
+WMesaContext WMesaCreateContext( HWND hWnd, HPALETTE* Pal,
+ GLboolean rgb_flag,
+ GLboolean db_flag )
+{
+ RECT CR;
+ WMesaContext c;
+ GLboolean true_color_flag;
+ c = (struct wmesa_context * ) calloc(1,sizeof(struct wmesa_context));
+ if (!c)
+ return NULL;
+
+ c->Window=hWnd;
+ c->hDC = GetDC(hWnd);
+ true_color_flag = GetDeviceCaps(c->hDC, BITSPIXEL) > 8;
+#ifdef DDRAW
+ if(true_color_flag) c->rgb_flag = rgb_flag = GL_TRUE;
+#endif
+
+
+#ifdef DITHER
+ if ((true_color_flag==GL_FALSE) && (rgb_flag == GL_TRUE)){
+ c->dither_flag = GL_TRUE;
+ c->hPalHalfTone = WinGCreateHalftonePalette();
+ }
+ else
+ c->dither_flag = GL_FALSE;
+#else
+ c->dither_flag = GL_FALSE;
+#endif
+
+
+ if (rgb_flag==GL_FALSE)
+ {
+ c->rgb_flag = GL_FALSE;
+ // c->pixel = 1;
+ c->db_flag = db_flag =GL_TRUE; // WinG requires double buffering
+ printf("Single buffer is not supported in color index mode, setting to double buffer.\n");
+ }
+ else
+ {
+ c->rgb_flag = GL_TRUE;
+ // c->pixel = 0;
+ }
+ GetClientRect(c->Window,&CR);
+ c->width=CR.right;
+ c->height=CR.bottom;
+ if (db_flag)
+ {
+ c->db_flag = 1;
+ /* Double buffered */
+#ifndef DDRAW
+ // if (c->rgb_flag==GL_TRUE && c->dither_flag != GL_TRUE )
+ {
+ wmCreateBackingStore(c, c->width, c->height);
+
+ }
+#endif
+ }
+ else
+ {
+ /* Single Buffered */
+ if (c->rgb_flag)
+ c->db_flag = 0;
+ }
+#ifdef DDRAW
+ if (DDInit(c,hWnd) == GL_FALSE) {
+ free( (void *) c );
+ exit(1);
+ }
+#endif
+
+
+ c->gl_visual = _mesa_create_visual(rgb_flag,
+ db_flag, /* db_flag */
+ GL_FALSE, /* stereo */
+ 8,8,8,8, /* r, g, b, a bits */
+ 0, /* index bits */
+ 16, /* depth_bits */
+ 8, /* stencil_bits */
+ 16,16,16,16,/* accum_bits */
+ 1);
+
+ if (!c->gl_visual) {
+ return NULL;
+ }
+
+ /* allocate a new Mesa context */
+ c->gl_ctx = _mesa_create_context( c->gl_visual, NULL, c, GL_TRUE);
+
+ if (!c->gl_ctx) {
+ _mesa_destroy_visual( c->gl_visual );
+ free(c);
+ return NULL;
+ }
+
+ _mesa_enable_sw_extensions(c->gl_ctx);
+#if 0
+ c->gl_buffer = _mesa_create_framebuffer( c->gl_visual,
+ c->gl_visual->DepthBits > 0,
+ c->gl_visual->StencilBits > 0,
+ c->gl_visual->AccumRedBits > 0,
+ c->gl_visual->AlphaBits > 0 );
+#endif
+ c->gl_buffer = NULL; /* TEMP */
+ if (!c->gl_buffer) {
+ _mesa_destroy_visual( c->gl_visual );
+ _mesa_destroy_context( c->gl_ctx );
+ free(c);
+ return NULL;
+ }
+
+ c->gl_ctx->Driver.UpdateState = setup_DD_pointers;
+
+ // setup_DD_pointers(c->gl_ctx);
+
+ return c;
+}
+
+void WMesaDestroyContext( void )
+{
+ WMesaContext c = Current;
+ ReleaseDC(c->Window,c->hDC);
+ WC = c;
+ if(c->hPalHalfTone != NULL)
+ DeleteObject(c->hPalHalfTone);
+ _mesa_destroy_visual( c->gl_visual );
+ _mesa_destroy_framebuffer( c->gl_buffer );
+ _mesa_destroy_context( c->gl_ctx );
+
+ if (c->db_flag)
+#ifdef DDRAW
+ DDFree(c);
+#else
+ wmDeleteBackingStore(c);
+#endif
+ free( (void *) c );
+ //Following code is added to enable parallel render
+ // Parallel render only work in double buffer mode
+#if !defined(NO_PARALLEL)
+ if(parallelMachine)
+ PRDestroyRenderBuffer();
+#endif
+ // End modification
+}
+
+
+
+void /*APIENTRY*/ WMesaMakeCurrent( WMesaContext c )
+{
+ if(!c){
+ Current = c;
+ return;
+ }
+
+ //
+ // A little optimization
+ // If it already is current,
+ // don't set it again
+ //
+ if(Current == c)
+ return;
+
+ //gl_set_context( c->gl_ctx );
+ _mesa_make_current(c->gl_ctx, c->gl_buffer);
+ setup_DD_pointers(c->gl_ctx);
+ Current = c;
+ if (Current->gl_ctx->Viewport.Width==0) {
+ /* initialize viewport to window size */
+ _mesa_set_viewport( Current->gl_ctx,
+ 0, 0, Current->width, Current->height );
+ }
+ if ((c->cColorBits <= 8 ) && (c->rgb_flag == GL_TRUE)){
+ WMesaPaletteChange(c->hPalHalfTone);
+ }
+}
+
+
+
+void /*APIENTRY*/ WMesaSwapBuffers( void )
+{
+ HDC DC = Current->hDC;
+ GET_CURRENT_CONTEXT(ctx);
+
+ /* If we're swapping the buffer associated with the current context
+ * we have to flush any pending rendering commands first.
+ */
+ if (Current && Current->gl_ctx == ctx)
+ _mesa_swapbuffers(ctx);
+
+ if (Current->db_flag)
+ wmFlush(Current);
+}
+
+
+
+void /*APIENTRY*/ WMesaPaletteChange(HPALETTE Pal)
+{
+ int vRet;
+ LPPALETTEENTRY pPal;
+ if (Current && (Current->rgb_flag==GL_FALSE || Current->dither_flag == GL_TRUE))
+ {
+ pPal = (PALETTEENTRY *)malloc( 256 * sizeof(PALETTEENTRY));
+ Current->hPal=Pal;
+ // GetPaletteEntries( Pal, 0, 256, pPal );
+ GetPalette( Pal, pPal );
+#ifdef DDRAW
+ Current->lpDD->lpVtbl->CreatePalette(Current->lpDD,DDPCAPS_8BIT,
+ pPal, &(Current->lpDDPal), NULL);
+ if (Current->lpDDPal)
+ Current->lpDDSPrimary->lpVtbl->SetPalette(Current->lpDDSPrimary,Current->lpDDPal);
+#else
+ vRet = SetDIBColorTable(Current->dib.hDC,0,256,pPal);
+#endif
+ free( pPal );
+ }
+
+}
+
+
+
+
+static unsigned char threeto8[8] = {
+ 0, 0111>>1, 0222>>1, 0333>>1, 0444>>1, 0555>>1, 0666>>1, 0377
+};
+
+static unsigned char twoto8[4] = {
+ 0, 0x55, 0xaa, 0xff
+};
+
+static unsigned char oneto8[2] = {
+ 0, 255
+};
+
+static unsigned char componentFromIndex(UCHAR i, UINT nbits, UINT shift)
+{
+ unsigned char val;
+
+ val = i >> shift;
+ switch (nbits) {
+
+ case 1:
+ val &= 0x1;
+ return oneto8[val];
+
+ case 2:
+ val &= 0x3;
+ return twoto8[val];
+
+ case 3:
+ val &= 0x7;
+ return threeto8[val];
+
+ default:
+ return 0;
+ }
+}
+
+void /*WINAPI*/ wmCreatePalette( PWMC pwdc )
+{
+ /* Create a compressed and re-expanded 3:3:2 palette */
+ int i;
+ LOGPALETTE *pPal;
+ BYTE rb, rs, gb, gs, bb, bs;
+
+ pwdc->nColors = 0x100;
+
+ pPal = (PLOGPALETTE)malloc(sizeof(LOGPALETTE) + pwdc->nColors * sizeof(PALETTEENTRY));
+ memset( pPal, 0, sizeof(LOGPALETTE) + pwdc->nColors * sizeof(PALETTEENTRY) );
+
+ pPal->palVersion = 0x300;
+
+ rb = REDBITS;
+ rs = REDSHIFT;
+ gb = GREENBITS;
+ gs = GREENSHIFT;
+ bb = BLUEBITS;
+ bs = BLUESHIFT;
+
+ if (pwdc->db_flag) {
+
+ /* Need to make two palettes: one for the screen DC and one for the DIB. */
+ pPal->palNumEntries = pwdc->nColors;
+ for (i = 0; i < pwdc->nColors; i++) {
+ pPal->palPalEntry[i].peRed = componentFromIndex( i, rb, rs );
+ pPal->palPalEntry[i].peGreen = componentFromIndex( i, gb, gs );
+ pPal->palPalEntry[i].peBlue = componentFromIndex( i, bb, bs );
+ pPal->palPalEntry[i].peFlags = 0;
+ }
+ pwdc->hGLPalette = CreatePalette( pPal );
+ pwdc->hPalette = CreatePalette( pPal );
+ }
+
+ else {
+ pPal->palNumEntries = pwdc->nColors;
+ for (i = 0; i < pwdc->nColors; i++) {
+ pPal->palPalEntry[i].peRed = componentFromIndex( i, rb, rs );
+ pPal->palPalEntry[i].peGreen = componentFromIndex( i, gb, gs );
+ pPal->palPalEntry[i].peBlue = componentFromIndex( i, bb, bs );
+ pPal->palPalEntry[i].peFlags = 0;
+ }
+ pwdc->hGLPalette = CreatePalette( pPal );
+ }
+
+ free(pPal);
+
+}
+
+void /*WINAPI*/ wmSetPixel(PWMC pwc, int iScanLine, int iPixel, BYTE r, BYTE g, BYTE b)
+{
+ if (Current->db_flag) {
+ LPBYTE lpb = pwc->pbPixels;
+ LPDWORD lpdw;
+ LPWORD lpw;
+ UINT nBypp = pwc->cColorBits >> 3;
+ UINT nOffset = iPixel % nBypp;
+
+ // Move the pixel buffer pointer to the scanline that we
+ // want to access
+
+ // pwc->dib.fFlushed = FALSE;
+
+ lpb += pwc->ScanWidth * iScanLine;
+ // Now move to the desired pixel
+ lpb += iPixel * nBypp;
+ lpb = PIXELADDR(iPixel, iScanLine);
+ lpdw = (LPDWORD)lpb;
+ lpw = (LPWORD)lpb;
+
+ if(nBypp == 1){
+ if(pwc->dither_flag)
+ *lpb = DITHER_RGB_2_8BIT(r,g,b,iScanLine,iPixel);
+ else
+ *lpb = BGR8(r,g,b);
+ }
+ else if(nBypp == 2)
+ *lpw = BGR16(r,g,b);
+ else if (nBypp == 3){
+ *lpdw = BGR24(r,g,b);
+ }
+ else if (nBypp == 4)
+ *lpdw = BGR32(r,g,b);
+ }
+ else{
+ SetPixel(Current->hDC, iPixel, iScanLine, RGB(r,g,b));
+ DD_RELEASEDC;
+ }
+}
+
+void /*WINAPI*/ wmCreateDIBSection(
+ HDC hDC,
+ PWMC pwc, // handle of device context
+ CONST BITMAPINFO *pbmi, // address of structure containing bitmap size, format, and color data
+ UINT iUsage // color data type indicator: RGB values or palette indices
+ )
+{
+ DWORD dwSize = 0;
+ DWORD dwScanWidth;
+ UINT nBypp = pwc->cColorBits / 8;
+ HDC hic;
+
+ dwScanWidth = (((pwc->ScanWidth * nBypp)+ 3) & ~3);
+
+ pwc->ScanWidth =pwc->pitch = dwScanWidth;
+
+ if (stereo_flag)
+ pwc->ScanWidth = 2* pwc->pitch;
+
+ dwSize = sizeof(BITMAPINFO) + (dwScanWidth * pwc->height);
+
+ pwc->dib.hFileMap = CreateFileMapping((HANDLE)PAGE_FILE,
+ NULL,
+ PAGE_READWRITE | SEC_COMMIT,
+ 0,
+ dwSize,
+ NULL);
+
+ if (!pwc->dib.hFileMap)
+ return;
+
+ pwc->dib.base = MapViewOfFile(pwc->dib.hFileMap,
+ FILE_MAP_ALL_ACCESS,
+ 0,
+ 0,
+ 0);
+
+ if(!pwc->dib.base){
+ CloseHandle(pwc->dib.hFileMap);
+ return;
+ }
+
+ // pwc->pbPixels = pwc->addrOffScreen = ((LPBYTE)pwc->dib.base) + sizeof(BITMAPINFO);
+
+ // pwc->dib.hDC = CreateCompatibleDC(hDC);
+
+ CopyMemory(pwc->dib.base, pbmi, sizeof(BITMAPINFO));
+
+ hic = CreateIC("display", NULL, NULL, NULL);
+ pwc->dib.hDC = CreateCompatibleDC(hic);
+
+
+ /* pwc->hbmDIB = CreateDIBitmap(hic,
+ &(pwc->bmi.bmiHeader),
+ CBM_INIT,
+ pwc->pbPixels,
+ &(pwc->bmi),
+ DIB_RGB_COLORS);
+ */
+ pwc->hbmDIB = CreateDIBSection(hic,
+ &(pwc->bmi),
+ (iUsage ? DIB_PAL_COLORS : DIB_RGB_COLORS),
+ &(pwc->pbPixels),
+ pwc->dib.hFileMap,
+ 0);
+ /*
+ pwc->hbmDIB = CreateDIBSection(hic,
+ &(pwc->bmi),
+ DIB_RGB_COLORS,
+ &(pwc->pbPixels),
+ pwc->dib.hFileMap,
+ 0);
+ */
+ pwc->ScreenMem = pwc->addrOffScreen = pwc->pbPixels;
+ pwc->hOldBitmap = SelectObject(pwc->dib.hDC, pwc->hbmDIB);
+
+ DeleteDC(hic);
+
+ return;
+
+}
+
+//
+// Blit memory DC to screen DC
+//
+BOOL /*WINAPI*/ wmFlush(PWMC pwc)
+{
+ BOOL bRet = 0;
+ DWORD dwErr = 0;
+#ifdef DDRAW
+ HRESULT ddrval;
+#endif
+
+ // Now search through the torus frames and mark used colors
+ if(pwc->db_flag){
+#ifdef DDRAW
+ if (pwc->lpDDSOffScreen == NULL)
+ if(DDCreateOffScreen(pwc) == GL_FALSE)
+ return;
+
+ pwc->lpDDSOffScreen->lpVtbl->Unlock(pwc->lpDDSOffScreen, NULL);
+
+ while( 1 )
+ {
+ ddrval = pwc->lpDDSPrimary->lpVtbl->Blt( pwc->lpDDSPrimary,
+ &(pwc->rectSurface), pwc->lpDDSOffScreen, &(pwc->rectOffScreen), 0, NULL );
+
+ if( ddrval == DD_OK )
+ {
+ break;
+ }
+ if( ddrval == DDERR_SURFACELOST )
+ {
+ if(!DDRestoreAll(pwc))
+ {
+ break;
+ }
+ }
+ if( ddrval != DDERR_WASSTILLDRAWING )
+ {
+ break;
+ }
+ }
+
+ while (pwc->lpDDSOffScreen->lpVtbl->Lock(pwc->lpDDSOffScreen,
+ NULL, &(pwc->ddsd), 0, NULL) == DDERR_WASSTILLDRAWING)
+ ;
+
+ if(ddrval != DD_OK)
+ dwErr = GetLastError();
+#else
+ bRet = BitBlt(pwc->hDC, 0, 0, pwc->width, pwc->height,
+ pwc->dib.hDC, 0, 0, SRCCOPY);
+#endif
+ }
+
+ return(TRUE);
+
+}
+
+
+// The following code is added by Li Wei to enable stereo display
+
+#if !defined(NO_STEREO)
+
+void WMesaShowStereo(GLuint list)
+{
+
+ GLbitfield mask = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT;
+ GLfloat cm[16];
+ GLint matrix_mode;
+ // Must use double Buffer
+ if( ! Current-> db_flag )
+ return;
+
+
+ glGetIntegerv(GL_MATRIX_MODE,&matrix_mode);
+
+ // glPushMatrix(); //****
+ WMesaViewport(Current->gl_ctx,0,Current->height/2,Current->width,Current->height/2);
+ // Current->gl_ctx->NewState = 0;
+
+ // glViewport(0,0,Current->width,Current->height/2);
+ if(matrix_mode!=GL_MODELVIEW)
+ glMatrixMode(GL_MODELVIEW);
+
+ glGetFloatv(GL_MODELVIEW_MATRIX,cm);
+ glLoadIdentity();
+ gluLookAt(viewDistance/2,0.0,0.0 ,
+ viewDistance/2,0.0,-1.0,
+ 0.0,1.0,0.0 );
+ // glTranslatef(viewDistance/2.0,0.,0.);
+ glMultMatrixf( cm );
+
+ Current->ScreenMem = Current->pbPixels = Current->addrOffScreen;
+ //glPushMatrix();
+ glCallList( list );
+ //glPopMatrix();
+
+ glGetFloatv(GL_MODELVIEW_MATRIX,cm);
+ glLoadIdentity();
+ gluLookAt(-viewDistance/2,0.0,0.0 ,
+ -viewDistance/2,0.0,-1.0,
+ 0.0,1.0,0.0 );
+ // glTranslatef(-viewDistance/2.0,0.,0.);
+ glMultMatrixf(cm);
+
+ Current->ScreenMem = Current->pbPixels = Current->addrOffScreen + Current->pitch;
+ glCallList(list);
+ if(matrix_mode!=GL_MODELVIEW)
+ glMatrixMode(matrix_mode);
+
+ // glPopMatrix();
+ glFlush();
+
+ WMesaViewport(Current->gl_ctx,0,0,Current->width,Current->height);
+ // Current->gl_ctx->NewState = 0;
+ WMesaSwapBuffers();
+
+}
+
+void toggleStereoMode()
+{
+ if(!Current->db_flag)
+ return;
+ if(!stereo_flag){
+ stereo_flag = 1;
+ if(stereoBuffer==GL_FALSE)
+#if !defined(NO_PARALLEL)
+ if(!parallelFlag)
+#endif
+ {
+ Current->ScanWidth = Current->pitch*2;
+ }
+ }
+ else {
+ stereo_flag = 0;
+#if !defined(NO_PARALLEL)
+ if(!parallelFlag)
+#endif
+ Current->ScanWidth = Current->pitch;
+ Current->pbPixels = Current->addrOffScreen;
+ }
+}
+
+/* if in stereo mode, the following function is called */
+void glShowStereo(GLuint list)
+{
+ WMesaShowStereo(list);
+}
+
+#endif // End if NO_STEREO not defined
+
+#if !defined(NO_PARALLEL)
+
+void toggleParallelMode(void)
+{
+ if(!parallelFlag){
+ parallelFlag = GL_TRUE;
+ if(parallelMachine==GL_FALSE){
+ PRCreateRenderBuffer( Current->rgb_flag? GL_RGBA :GL_COLOR_INDEX,
+ Current->cColorBits/8,
+ Current->width ,Current->height,
+ Current->ScanWidth,
+ Current->rgb_flag? Current->pbPixels: Current->ScreenMem);
+ parallelMachine = GL_TRUE;
+ }
+ }
+ else {
+ parallelFlag = GL_FALSE;
+ if(parallelMachine==GL_TRUE){
+ PRDestroyRenderBuffer();
+ parallelMachine=GL_FALSE;
+ ReadyForNextFrame = GL_TRUE;
+ }
+
+ /***********************************************
+ // Seems something wrong!!!!
+ ************************************************/
+
+ WMesaMakeCurrent(Current);
+#if !defined(NO_STEREO)
+ stereo_flag = GL_FALSE ;
+#endif
+ }
+}
+
+void PRShowRenderResult(void)
+{
+ int flag = 0;
+ if(!glImageRendered())
+ return;
+
+ if (parallelFlag)
+ {
+ WMesaSwapBuffers();
+ }
+
+}
+#endif //End if NO_PARALLEL not defined
+
+//end modification
+
+BYTE DITHER_RGB_2_8BIT( int red, int green, int blue, int pixel, int scanline)
+{
+ char unsigned redtemp, greentemp, bluetemp, paletteindex;
+
+ //*** now, look up each value in the halftone matrix
+ //*** using an 8x8 ordered dither.
+ redtemp = aDividedBy51[red]
+ + (aModulo51[red] > aHalftone8x8[(pixel%8)*8
+ + scanline%8]);
+ greentemp = aDividedBy51[(char unsigned)green]
+ + (aModulo51[green] > aHalftone8x8[
+ (pixel%8)*8 + scanline%8]);
+ bluetemp = aDividedBy51[(char unsigned)blue]
+ + (aModulo51[blue] > aHalftone8x8[
+ (pixel%8)*8 +scanline%8]);
+
+ //*** recombine the halftoned rgb values into a palette index
+ paletteindex =
+ redtemp + aTimes6[greentemp] + aTimes36[bluetemp];
+
+ //*** and translate through the wing halftone palette
+ //*** translation vector to give the correct value.
+ return aWinGHalftoneTranslation[paletteindex];
+}
+
+#ifdef DDRAW
+/*
+* restoreAll
+*
+* restore all lost objects
+*/
+HRESULT DDRestoreAll( WMesaContext wc )
+{
+ HRESULT ddrval;
+
+ ddrval = wc->lpDDSPrimary->lpVtbl->Restore(wc->lpDDSPrimary);
+ if( ddrval == DD_OK )
+ {
+ ddrval = wc->lpDDSOffScreen->lpVtbl->Restore(wc->lpDDSOffScreen);
+ }
+ return ddrval;
+
+} /* restoreAll */
+
+
+ /*
+ * This function is called if the initialization function fails
+*/
+BOOL initFail( HWND hwnd, WMesaContext wc )
+{
+ DDFree(wc);
+ MessageBox( hwnd, "DirectDraw Init FAILED", "", MB_OK );
+ return FALSE;
+
+} /* initFail */
+
+
+static void DDDeleteOffScreen(WMesaContext wc)
+{
+ if( wc->lpDDSOffScreen != NULL )
+ {
+ wc->lpDDSOffScreen->lpVtbl->Unlock(wc->lpDDSOffScreen,NULL);
+ wc->lpDDSOffScreen->lpVtbl->Release(wc->lpDDSOffScreen);
+ wc->lpDDSOffScreen = NULL;
+ }
+
+}
+
+static void DDFreePrimarySurface(WMesaContext wc)
+{
+ if( wc->lpDDSPrimary != NULL )
+ {
+ if(wc->db_flag == GL_FALSE)
+ wc->lpDDSPrimary->lpVtbl->ReleaseDC(wc->lpDDSPrimary, wc->hDC);
+ wc->lpDDSPrimary->lpVtbl->Release(wc->lpDDSPrimary);
+ wc->lpDDSPrimary = NULL;
+ }
+}
+
+static BOOL DDCreatePrimarySurface(WMesaContext wc)
+{
+ HRESULT ddrval;
+ DDSCAPS ddscaps;
+ wc->ddsd.dwSize = sizeof( wc->ddsd );
+ wc->ddsd.dwFlags = DDSD_CAPS;
+ wc->ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
+
+ ddrval = wc->lpDD->lpVtbl->CreateSurface( wc->lpDD,&(wc->ddsd), &(wc->lpDDSPrimary), NULL );
+ if( ddrval != DD_OK )
+ {
+ return initFail(wc->hwnd , wc);
+ }
+ if(wc->db_flag == GL_FALSE)
+ wc->lpDDSPrimary->lpVtbl->GetDC(wc->lpDDSPrimary, wc->hDC);
+ return TRUE;
+}
+
+static BOOL DDCreateOffScreen(WMesaContext wc)
+{
+ POINT pt;
+ HRESULT ddrval;
+ if(wc->lpDD == NULL)
+ return FALSE;
+ GetClientRect( wc->hwnd, &(wc->rectOffScreen) );
+ wc->ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
+ wc->ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
+ wc->ddsd.dwHeight = wc->rectOffScreen.bottom - wc->rectOffScreen.top;
+ wc->ddsd.dwWidth = wc->rectOffScreen.right - wc->rectOffScreen.left;
+
+ ddrval = wc->lpDD->lpVtbl->CreateSurface( wc->lpDD, &(wc->ddsd), &(wc->lpDDSOffScreen), NULL );
+ if( ddrval != DD_OK )
+ {
+ return FALSE;
+ }
+
+ while (wc->lpDDSOffScreen->lpVtbl->Lock(wc->lpDDSOffScreen,NULL, &(wc->ddsd), 0, NULL) == DDERR_WASSTILLDRAWING)
+ ;
+ // while ((ddrval = wc->lpDDSOffScreen->lpVtbl->Lock(wc->lpDDSOffScreen,NULL, &(wc->ddsd), DDLOCK_SURFACEMEMORYPTR , NULL)) != DD_OK)
+ ;
+ if(wc->ddsd.lpSurface==NULL)
+ return initFail(wc->hwnd, wc);
+
+ wc->ScreenMem = wc->pbPixels = wc->addrOffScreen = (PBYTE)(wc->ddsd.lpSurface);
+ wc->ScanWidth = wc->pitch = wc->ddsd.lPitch;
+ if (stereo_flag)
+ wc->ScanWidth = wc->ddsd.lPitch*2;
+
+ GetClientRect( wc->hwnd, &(wc->rectSurface) );
+ pt.x = pt.y = 0;
+ ClientToScreen( wc->hwnd, &pt );
+ OffsetRect(&(wc->rectSurface), pt.x, pt.y);
+ wmSetPixelFormat(wc, wc->hDC);
+ return TRUE;
+}
+
+/*
+* doInit - do work required for every instance of the application:
+* create the window, initialize data
+*/
+static BOOL DDInit( WMesaContext wc, HWND hwnd)
+{
+ HRESULT ddrval;
+ DWORD dwFrequency;
+
+ LPDIRECTDRAW lpDD; // DirectDraw object
+ LPDIRECTDRAW2 lpDD2;
+
+
+ wc->fullScreen = displayOptions.fullScreen;
+ wc->gMode = displayOptions.mode;
+ wc->hwnd = hwnd;
+ stereo_flag = displayOptions.stereo;
+ if(wc->db_flag!= GL_TRUE)
+ stereo_flag = GL_FALSE;
+ /*
+ * create the main DirectDraw object
+ */
+ ddrval = DirectDrawCreate( NULL, &(wc->lpDD), NULL );
+ if( ddrval != DD_OK )
+ {
+ return initFail(hwnd,wc);
+ }
+
+ // Get exclusive mode if requested
+ if(wc->fullScreen)
+ {
+ ddrval = wc->lpDD->lpVtbl->SetCooperativeLevel( wc->lpDD, hwnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN );
+ }
+ else
+ {
+ ddrval = wc->lpDD->lpVtbl->SetCooperativeLevel( wc->lpDD, hwnd, DDSCL_NORMAL );
+ }
+ if( ddrval != DD_OK )
+ {
+ return initFail(hwnd , wc);
+ }
+
+
+ /* ddrval = wc->lpDD->lpVtbl->QueryInterface(wc->lpDD, IID_IDirectDraw2,
+ (LPVOID *)((wc->lpDD2)));
+
+ */
+ if(ddrval != DD_OK)
+ return initFail(hwnd , wc);
+
+
+ //ddrval = wc->lpDD->lpVtbl->GetDisplayMode( wc->lpDD, &(wc->ddsd));
+ // wc->lpDD2->lpVtbl->GetMonitorFrequency(wc->lpDD, &dwFrequency);
+ switch( wc->gMode )
+ {
+ case 1: ddrval = wc->lpDD->lpVtbl->SetDisplayMode( wc->lpDD, 640, 480, displayOptions.bpp); break;
+ case 2: ddrval = wc->lpDD->lpVtbl->SetDisplayMode( wc->lpDD, 800, 600, displayOptions.bpp); break;
+ case 3: ddrval = wc->lpDD->lpVtbl->SetDisplayMode( wc->lpDD, 1024, 768, displayOptions.bpp); break;
+ case 4: ddrval = wc->lpDD->lpVtbl->SetDisplayMode( wc->lpDD, 1152, 864, displayOptions.bpp); break;
+ case 5: ddrval = wc->lpDD->lpVtbl->SetDisplayMode( wc->lpDD, 1280, 1024, displayOptions.bpp); break;
+ }
+
+ if( ddrval != DD_OK )
+ {
+ printf("Can't modify display mode, current mode used\n");
+ // return initFail(hwnd , wc);
+ }
+ //ddrval = wc->lpDD->lpVtbl->GetDisplayMode( wc->lpDD, &(wc->ddsd));
+ switch(ddrval){
+ case DDERR_INVALIDOBJECT:
+ break;
+ case DDERR_INVALIDPARAMS:
+ break;
+ case DDERR_UNSUPPORTEDMODE:
+ ;
+ }
+
+ if(DDCreatePrimarySurface(wc) == GL_FALSE)
+ return initFail(hwnd, wc);
+
+ if(wc->db_flag)
+ return DDCreateOffScreen(wc);
+} /* DDInit */
+
+static void DDFree( WMesaContext wc)
+{
+ if( wc->lpDD != NULL )
+ {
+ DDFreePrimarySurface(wc);
+ DDDeleteOffScreen(wc);
+ wc->lpDD->lpVtbl->Release(wc->lpDD);
+ wc->lpDD = NULL;
+ }
+ // Clean up the screen on exit
+ RedrawWindow( NULL, NULL, NULL, RDW_INVALIDATE | RDW_ERASE |
+ RDW_ALLCHILDREN );
+
+}
+#endif
+
+void WMesaMove(void)
+{
+ WMesaContext wc = Current;
+ POINT pt;
+ if (Current != NULL){
+ GetClientRect( wc->hwnd, &(wc->rectSurface) );
+ pt.x = pt.y = 0;
+ ClientToScreen( wc->hwnd, &pt );
+ OffsetRect(&(wc->rectSurface), pt.x, pt.y);
+ }
+}
+
+
+
+/*
+* Like PACK_8A8B8G8R() but don't use alpha. This is usually an acceptable
+* shortcut.
+*/
+#define PACK_8B8G8R( R, G, B ) ( ((B) << 16) | ((G) << 8) | (R) )
+
+
+/**********************************************************************/
+/*** Triangle rendering ***/
+/**********************************************************************/
+
+/*
+ * XImage, smooth, depth-buffered, PF_8A8B8G8R triangle.
+ */
+static void smooth_8A8B8G8R_z_triangle( GLcontext *ctx,
+ GLuint v0, GLuint v1, GLuint v2,
+ GLuint pv )
+{
+ WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
+#define PIXEL_TYPE GLuint
+ //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint i, len = RIGHT-LEFT; \
+ for (i=0;i<len;i++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ pRow[i] = PACK_8B8G8R( FixedToInt(ffr), FixedToInt(ffg), \
+ FixedToInt(ffb) ); \
+ zRow[i] = z; \
+ } \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ ffz += fdzdx; \
+ } \
+ }
+
+#ifdef __MINGW32__
+ #include "tritemp.h"
+#else
+
+ #ifdef WIN32
+// #include "..\tritemp.h"
+ #else
+ #include "tritemp.h"
+ #endif
+#endif
+}
+
+
+/*
+* XImage, smooth, depth-buffered, PF_8R8G8B triangle.
+*/
+static void smooth_8R8G8B_z_triangle( GLcontext *ctx,
+ GLuint v0, GLuint v1, GLuint v2,
+ GLuint pv )
+{
+ WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
+#define PIXEL_TYPE GLuint
+ //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint i, len = RIGHT-LEFT; \
+ for (i=0;i<len;i++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ pRow[i] = PACK_8R8G8B( FixedToInt(ffr), FixedToInt(ffg), \
+ FixedToInt(ffb) ); \
+ zRow[i] = z; \
+ } \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ ffz += fdzdx; \
+ } \
+ }
+#ifdef __MINGW32__
+ #include "tritemp.h"
+#else
+
+ #ifdef WIN32
+// #include "..\tritemp.h"
+ #else
+ #include "tritemp.h"
+ #endif
+#endif
+}
+
+
+
+/*
+* XImage, smooth, depth-buffered, PF_5R6G5B triangle.
+*/
+static void smooth_5R6G5B_z_triangle( GLcontext *ctx,
+ GLuint v0, GLuint v1, GLuint v2,
+ GLuint pv )
+{
+ WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(X,Y)
+#define PIXEL_TYPE GLushort
+ //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint i, len = RIGHT-LEFT; \
+ for (i=0;i<len;i++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ pRow[i] = PACK_5R6G5B( FixedToInt(ffr), FixedToInt(ffg), \
+ FixedToInt(ffb) ); \
+ zRow[i] = z; \
+ } \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ ffz += fdzdx; \
+ } \
+ }
+#ifdef __MINGW32__
+ #include "tritemp.h"
+#else
+
+ #ifdef WIN32
+// #include "..\tritemp.h"
+ #else
+ #include "tritemp.h"
+ #endif
+#endif
+}
+
+/*
+* XImage, flat, depth-buffered, PF_8A8B8G8R triangle.
+*/
+static void flat_8A8B8G8R_z_triangle( GLcontext *ctx, GLuint v0,
+ GLuint v1, GLuint v2, GLuint pv )
+{
+ WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
+#define PIXEL_TYPE GLuint
+ //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define SETUP_CODE \
+ unsigned long p = PACK_8B8G8R( VB->ColorPtr->data[pv][0], \
+ VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint i, len = RIGHT-LEFT; \
+ for (i=0;i<len;i++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ pRow[i] = p; \
+ zRow[i] = z; \
+ } \
+ ffz += fdzdx; \
+ } \
+ }
+#ifdef __MINGW32__
+ #include "tritemp.h"
+#else
+
+ #ifdef WIN32
+// #include "..\tritemp.h"
+ #else
+ #include "tritemp.h"
+ #endif
+#endif
+}
+
+
+/*
+* XImage, flat, depth-buffered, PF_8R8G8B triangle.
+*/
+static void flat_8R8G8B_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
+#define PIXEL_TYPE GLuint
+ //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define SETUP_CODE \
+ unsigned long p = PACK_8R8G8B( VB->ColorPtr->data[pv][0], \
+ VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint i, len = RIGHT-LEFT; \
+ for (i=0;i<len;i++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ pRow[i] = p; \
+ zRow[i] = z; \
+ } \
+ ffz += fdzdx; \
+ } \
+ }
+#ifdef __MINGW32__
+ #include "tritemp.h"
+#else
+
+ #ifdef WIN32
+// #include "..\tritemp.h"
+ #else
+ #include "tritemp.h"
+ #endif
+#endif
+}
+
+
+/*
+* XImage, flat, depth-buffered, PF_5R6G5B triangle.
+*/
+static void flat_5R6G5B_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(X,Y)
+#define PIXEL_TYPE GLushort
+ //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define SETUP_CODE \
+ unsigned long p = PACK_5R6G5B( VB->ColorPtr->data[pv][0], \
+ VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint i, len = RIGHT-LEFT; \
+ for (i=0;i<len;i++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ pRow[i] = p; \
+ zRow[i] = z; \
+ } \
+ ffz += fdzdx; \
+ } \
+ }
+#ifdef __MINGW32__
+ #include "tritemp.h"
+#else
+
+ #ifdef WIN32
+// #include "..\tritemp.h"
+ #else
+ #include "tritemp.h"
+ #endif
+#endif
+}
+
+
+/*
+* XImage, smooth, NON-depth-buffered, PF_8A8B8G8R triangle.
+*/
+static void smooth_8A8B8G8R_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
+#define PIXEL_TYPE GLuint
+ //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint xx; \
+ PIXEL_TYPE *pixel = pRow; \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ *pixel = PACK_8B8G8R( FixedToInt(ffr), FixedToInt(ffg), \
+ FixedToInt(ffb) ); \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ } \
+ }
+#ifdef __MINGW32__
+ #include "tritemp.h"
+#else
+
+ #ifdef WIN32
+// #include "..\tritemp.h"
+ #else
+ #include "tritemp.h"
+ #endif
+#endif
+}
+
+
+/*
+* XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
+*/
+static void smooth_8R8G8B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
+#define PIXEL_TYPE GLuint
+ //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint xx; \
+ PIXEL_TYPE *pixel = pRow; \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ *pixel = PACK_8R8G8B( FixedToInt(ffr), FixedToInt(ffg), \
+ FixedToInt(ffb) ); \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ } \
+ }
+#ifdef __MINGW32__
+ #include "tritemp.h"
+#else
+
+ #ifdef WIN32
+// #include "..\tritemp.h"
+ #else
+ #include "tritemp.h"
+ #endif
+#endif
+}
+
+
+/*
+* XImage, smooth, NON-depth-buffered, PF_5R6G5B triangle.
+*/
+static void smooth_5R6G5B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(X,Y)
+#define PIXEL_TYPE GLushort
+ //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint xx; \
+ PIXEL_TYPE *pixel = pRow; \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ *pixel = PACK_5R6G5B( FixedToInt(ffr), FixedToInt(ffg), \
+ FixedToInt(ffb) ); \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ } \
+ }
+#ifdef __MINGW32__
+ #include "tritemp.h"
+#else
+
+ #ifdef WIN32
+// #include "..\tritemp.h"
+ #else
+ #include "tritemp.h"
+ #endif
+#endif
+}
+
+
+
+/*
+* XImage, flat, NON-depth-buffered, PF_8A8B8G8R triangle.
+*/
+static void flat_8A8B8G8R_triangle( GLcontext *ctx, GLuint v0,
+ GLuint v1, GLuint v2, GLuint pv )
+{
+ WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
+#define PIXEL_TYPE GLuint
+ //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define SETUP_CODE \
+ unsigned long p = PACK_8B8G8R( VB->ColorPtr->data[pv][0], \
+ VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint xx; \
+ PIXEL_TYPE *pixel = pRow; \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ *pixel = p; \
+ } \
+ }
+
+#ifdef __MINGW32__
+ #include "tritemp.h"
+#else
+
+ #ifdef WIN32
+// #include "..\tritemp.h"
+ #else
+ #include "tritemp.h"
+ #endif
+#endif
+}
+
+
+/*
+* XImage, flat, NON-depth-buffered, PF_8R8G8B triangle.
+*/
+static void flat_8R8G8B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
+#define PIXEL_TYPE GLuint
+ //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define SETUP_CODE \
+ unsigned long p = PACK_8R8G8B( VB->ColorPtr->data[pv][0], \
+ VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint xx; \
+ PIXEL_TYPE *pixel = pRow; \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ *pixel = p; \
+ } \
+ }
+#ifdef __MINGW32__
+ #include "tritemp.h"
+#else
+
+ #ifdef WIN32
+// #include "..\tritemp.h"
+ #else
+ #include "tritemp.h"
+ #endif
+#endif
+}
+
+
+/*
+* XImage, flat, NON-depth-buffered, PF_5R6G5B triangle.
+*/
+static void flat_5R6G5B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(X,Y)
+#define PIXEL_TYPE GLushort
+ //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define SETUP_CODE \
+ unsigned long p = PACK_5R6G5B( VB->ColorPtr->data[pv][0], \
+ VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint xx; \
+ PIXEL_TYPE *pixel = pRow; \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ *pixel = p; \
+ } \
+ }
+#ifdef __MINGW32__
+ #include "tritemp.h"
+#else
+
+ #ifdef WIN32
+// #include "..\tritemp.h"
+ #else
+ #include "tritemp.h"
+ #endif
+#endif
+}
+
+
+/*
+* XImage, smooth, depth-buffered, 8-bit PF_LOOKUP triangle.
+*/
+
+static void smooth_ci_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define INTERP_INDEX 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint i, len = RIGHT-LEFT; \
+ for (i=0;i<len;i++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ pRow[i] = FixedToInt(ffi); \
+ zRow[i] = z; \
+ } \
+ ffi += fdidx; \
+ ffz += fdzdx; \
+ } \
+ }
+#ifdef __MINGW32__
+ #include "tritemp.h"
+#else
+
+ #ifdef WIN32
+// #include "..\tritemp.h"
+ #else
+ #include "tritemp.h"
+ #endif
+#endif
+}
+
+
+/*
+* XImage, flat, depth-buffered, 8-bit PF_LOOKUP triangle.
+*/
+
+static void flat_ci_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define SETUP_CODE \
+ GLuint index = VB->IndexPtr->data[pv]; \
+ (*ctx->Driver.Index)( ctx, index );
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint i, len = RIGHT-LEFT; \
+ for (i=0;i<len;i++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ pRow[i] = index; \
+ zRow[i] = z; \
+ } \
+ ffz += fdzdx; \
+ } \
+ }
+#ifdef __MINGW32__
+ #include "tritemp.h"
+#else
+
+ #ifdef WIN32
+// #include "..\tritemp.h"
+ #else
+ #include "tritemp.h"
+ #endif
+#endif
+}
+
+
+
+/*
+* XImage, smooth, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
+*/
+
+static void smooth_ci_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define INTERP_INDEX 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint xx; \
+ PIXEL_TYPE *pixel = pRow; \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ *pixel = FixedToInt(ffi); \
+ ffi += fdidx; \
+ } \
+ }
+#ifdef __MINGW32__
+ #include "tritemp.h"
+#else
+
+ #ifdef WIN32
+// #include "..\tritemp.h"
+ #else
+ #include "tritemp.h"
+ #endif
+#endif
+}
+
+
+/*
+* XImage, flat, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
+*/
+static void flat_ci_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define SETUP_CODE \
+ GLuint index = VB->IndexPtr->data[pv]; \
+ (*ctx->Driver.Index)( ctx, index );
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint xx; \
+ PIXEL_TYPE *pixel = pRow; \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ *pixel = index; \
+ } \
+ }
+#ifdef __MINGW32__
+ #include "tritemp.h"
+#else
+
+ #ifdef WIN32
+// #include "..\tritemp.h"
+ #else
+ #include "tritemp.h"
+ #endif
+#endif
+}
+
+/*
+* XImage, smooth, depth-buffered, 8-bit, PF_DITHER8 triangle.
+*/
+static void smooth_DITHER8_z_triangle( GLcontext *ctx,
+ GLuint v0, GLuint v1, GLuint v2,
+ GLuint pv )
+{
+ WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+ DITHER_RGB_TO_8BIT_SETUP
+#define INTERP_Z 1
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint i, xx = LEFT, yy = FLIP(Y), len = RIGHT-LEFT; \
+ for (i=0;i<len;i++,xx++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ DITHER_RGB_TO_8BIT( FixedToInt(ffr), FixedToInt(ffg), \
+ FixedToInt(ffb), xx, yy); \
+ pRow[i] = pixelDithered; \
+ zRow[i] = z; \
+ } \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ ffz += fdzdx; \
+ } \
+ }
+#ifdef __MINGW32__
+ #include "tritemp.h"
+#else
+
+ #ifdef WIN32
+// #include "..\tritemp.h"
+ #else
+ #include "tritemp.h"
+ #endif
+#endif
+}
+
+/*
+* XImage, flat, depth-buffered, 8-bit PF_DITHER triangle.
+*/
+static void flat_DITHER8_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+ DITHER_RGB_TO_8BIT_SETUP
+#define INTERP_Z 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint i, xx = LEFT, yy = FLIP(Y), len = RIGHT-LEFT; \
+ for (i=0;i<len;i++,xx++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ DITHER_RGB_TO_8BIT( VB->ColorPtr->data[pv][0], \
+ VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2], xx, yy); \
+ pRow[i] = pixelDithered; \
+ zRow[i] = z; \
+ } \
+ ffz += fdzdx; \
+ } \
+ }
+#ifdef __MINGW32__
+ #include "tritemp.h"
+#else
+
+ #ifdef WIN32
+// #include "..\tritemp.h"
+ #else
+ #include "tritemp.h"
+ #endif
+#endif
+}
+
+/*
+* XImage, smooth, NON-depth-buffered, 8-bit PF_DITHER triangle.
+*/
+static void smooth_DITHER8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+ DITHER_RGB_TO_8BIT_SETUP
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint xx, yy = FLIP(Y); \
+ PIXEL_TYPE *pixel = pRow; \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ DITHER_RGB_TO_8BIT( VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2], xx, yy);\
+ *pixel = pixelDithered; \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ } \
+ }
+#ifdef __MINGW32__
+ #include "tritemp.h"
+#else
+
+ #ifdef WIN32
+// #include "..\tritemp.h"
+ #else
+ #include "tritemp.h"
+ #endif
+#endif
+}
+
+/*
+* XImage, flat, NON-depth-buffered, 8-bit PF_DITHER triangle.
+*/
+
+static void flat_DITHER8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+ DITHER_RGB_TO_8BIT_SETUP
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+ { \
+ GLint xx, yy = FLIP(Y); \
+ PIXEL_TYPE *pixel = pRow; \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ DITHER_RGB_TO_8BIT( VB->ColorPtr->data[pv][0], \
+ VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2], xx, yy); \
+ *pixel = pixelDithered; \
+ } \
+ }
+#ifdef __MINGW32__
+ #include "tritemp.h"
+#else
+
+ #ifdef WIN32
+// #include "..\tritemp.h"
+ #else
+ #include "tritemp.h"
+ #endif
+#endif
+}
+
+
+
+
+static /*triangle_func*/ choose_triangle_function( GLcontext *ctx )
+{
+#if 0
+ WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+ int depth = wmesa->cColorBits;
+
+ if (ctx->Polygon.SmoothFlag) return NULL;
+ if (ctx->Texture._ReallyEnabled) return NULL;
+ if (!wmesa->db_flag) return NULL;
+ /*if (wmesa->xm_buffer->buffer==XIMAGE)*/ {
+ if ( ctx->Light.ShadeModel==GL_SMOOTH
+ && ctx->_RasterMask==DEPTH_BIT
+ && ctx->Depth.Func==GL_LESS
+ && ctx->Depth.Mask==GL_TRUE
+ && ctx->Polygon.StippleFlag==GL_FALSE) {
+ switch (wmesa->pixelformat) {
+ case PF_8A8B8G8R:
+ return smooth_8A8B8G8R_z_triangle;
+ case PF_8R8G8B:
+ return smooth_8R8G8B_z_triangle;
+ case PF_5R6G5B:
+ return smooth_5R6G5B_z_triangle;
+ case PF_DITHER8:
+ return smooth_DITHER8_z_triangle;
+ case PF_INDEX8:
+ return smooth_ci_z_triangle;
+ default:
+ return NULL;
+ }
+ }
+ if ( ctx->Light.ShadeModel==GL_FLAT
+ && ctx->_RasterMask==DEPTH_BIT
+ && ctx->Depth.Func==GL_LESS
+ && ctx->Depth.Mask==GL_TRUE
+ && ctx->Polygon.StippleFlag==GL_FALSE) {
+ switch (wmesa->pixelformat) {
+ case PF_8A8B8G8R:
+ return flat_8A8B8G8R_z_triangle;
+ case PF_8R8G8B:
+ return flat_8R8G8B_z_triangle;
+ case PF_5R6G5B:
+ return flat_5R6G5B_z_triangle;
+ case PF_DITHER8:
+ return flat_DITHER8_z_triangle;
+ case PF_INDEX8:
+ return flat_ci_z_triangle;
+ default:
+ return NULL;
+ }
+ }
+ if ( ctx->_RasterMask==0 /* no depth test */
+ && ctx->Light.ShadeModel==GL_SMOOTH
+ && ctx->Polygon.StippleFlag==GL_FALSE) {
+ switch (wmesa->pixelformat) {
+ case PF_8A8B8G8R:
+ return smooth_8A8B8G8R_triangle;
+ case PF_8R8G8B:
+ return smooth_8R8G8B_triangle;
+ case PF_5R6G5B:
+ return smooth_5R6G5B_triangle;
+ case PF_DITHER8:
+ return smooth_DITHER8_triangle;
+ case PF_INDEX8:
+ return smooth_ci_triangle;
+ default:
+ return NULL;
+ }
+ }
+
+ if ( ctx->_RasterMask==0 /* no depth test */
+ && ctx->Light.ShadeModel==GL_FLAT
+ && ctx->Polygon.StippleFlag==GL_FALSE) {
+ switch (wmesa->pixelformat) {
+ case PF_8A8B8G8R:
+ return flat_8A8B8G8R_triangle;
+ case PF_8R8G8B:
+ return flat_8R8G8B_triangle;
+ case PF_5R6G5B:
+ return flat_5R6G5B_triangle;
+ case PF_DITHER8:
+ return flat_DITHER8_triangle;
+ case PF_INDEX8:
+ return flat_ci_triangle;
+ default:
+ return NULL;
+ }
+ }
+
+ return NULL;
+ }
+#endif
+}
+
+/*
+* Define a new viewport and reallocate auxillary buffers if the size of
+* the window (color buffer) has changed.
+*/
+void WMesaViewport( GLcontext *ctx,
+ GLint x, GLint y, GLsizei width, GLsizei height )
+{
+#if 0
+ /* Save viewport */
+ ctx->Viewport.X = x;
+ ctx->Viewport.Width = width;
+ ctx->Viewport.Y = y;
+ ctx->Viewport.Height = height;
+
+ /* compute scale and bias values */
+/* Pre-Keith 3.1 changes
+ ctx->Viewport.Map.m[Sx] = (GLfloat) width / 2.0F;
+ ctx->Viewport.Map.m[Tx] = ctx->Viewport.Sx + x;
+ ctx->Viewport.Map.m[Sy] = (GLfloat) height / 2.0F;
+ ctx->Viewport.Map.m[Ty] = ctx->Viewport.Sy + y;
+*/
+ ctx->Viewport.WindowMap.m[MAT_SX] = (GLfloat) width / 2.0F;
+ ctx->Viewport.WindowMap.m[MAT_TX] = ctx->Viewport.WindowMap.m[MAT_SX] + x;
+ ctx->Viewport.WindowMap.m[MAT_SY] = (GLfloat) height / 2.0F;
+ ctx->Viewport.WindowMap.m[MAT_TY] = ctx->Viewport.WindowMap.m[MAT_SY] + y;
+#endif
+}
projects / platform / upstream / mesa.git / commitdiff