OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

windows/gdi: Remove.

Browse Source 
This classic driver is so far behind Gallium softpipe/llvmpipe based
one, that's hard to imagine ever being useful.

v2: Drop drivers/windows from src/mesa/Makefile.am:EXTRA_DIST per Emil
Velikov.

Reviewed-by: Emil Velikov <emil.l.velikov@gmail.com>

v3: Update release notes.
This commit is contained in:
Jose Fonseca
2015-03-03 14:52:15 +00:00
parent 40a4797384
commit 17b2825d76
12 changed files with 7 additions and 2127 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
docs/README.WIN32
View File

@@ -11,9 +11,9 @@ no longer shipped or supported.
Run
scons osmesa mesagdi
scons osmesa
to build classic mesa Windows GDI drivers; or
to build classic osmesa driver; or
scons libgl-gdi

5
docs/install.html
View File

@@ -127,14 +127,13 @@ by -debug for debug builds.
To build Mesa with SCons for Windows on Linux using the MinGW crosscompiler toolchain do
</p>
<pre>
scons platform=windows toolchain=crossmingw machine=x86 mesagdi libgl-gdi
scons platform=windows toolchain=crossmingw machine=x86 libgl-gdi
</pre>
<p>
This will create:
</p>
<ul>
<li>build/windows-x86-debug/mesa/drivers/windows/gdi/opengl32.dll &mdash; Mesa + swrast, binary compatible with Windows's opengl32.dll
<li>build/windows-x86-debug/gallium/targets/libgl-gdi/opengl32.dll &mdash; Mesa + Gallium + softpipe, binary compatible with Windows's opengl32.dll
<li>build/windows-x86-debug/gallium/targets/libgl-gdi/opengl32.dll &mdash; Mesa + Gallium + softpipe (or llvmpipe), binary compatible with Windows's opengl32.dll
</ul>
<p>
Put them all in the same directory to test them.

4
docs/relnotes/10.6.0.html
View File

@@ -58,7 +58,9 @@ TBD.
<h2>Changes</h2>
TBD.
<ul>
<li>Removed classic Windows software rasterizer.</li>
</ul>
</div>
</body>

140
include/GL/wmesa.h
View File

@@ -1,140 +0,0 @@
/*
* Mesa 3-D graphics library
* Copyright (C) 1995-1998 Brian Paul
*
* 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.
*
*/
/*
* Windows driver by: Mark E. Peterson (markp@ic.mankato.mn.us)
* Updated by Li Wei (liwei@aiar.xjtu.edu.cn)
*
*
***************************************************************
* WMesa *
* version 2.3 *
* *
* By *
* Li Wei *
* Institute of Artificial Intelligence & Robotics *
* Xi'an Jiaotong University *
* Email: liwei@aiar.xjtu.edu.cn *
* Web page: http://sun.aiar.xjtu.edu.cn *
* *
* July 7th, 1997 *
***************************************************************
*/
#ifndef WMESA_H
#define WMESA_H
#ifdef __cplusplus
extern "C" {
#endif
#include "GL/gl.h"
#if defined(_MSV_VER) && !defined(__GNUC__)
# pragma warning (disable:4273)
# pragma warning( disable : 4244 ) /* '=' : conversion from 'const double ' to 'float ', possible loss of data */
# pragma warning( disable : 4018 ) /* '<' : signed/unsigned mismatch */
# pragma warning( disable : 4305 ) /* '=' : truncation from 'const double ' to 'float ' */
# pragma warning( disable : 4013 ) /* 'function' undefined; assuming extern returning int */
# pragma warning( disable : 4761 ) /* integral size mismatch in argument; conversion supplied */
# pragma warning( disable : 4273 ) /* 'identifier' : inconsistent DLL linkage. dllexport assumed */
# if (MESA_WARNQUIET>1)
# pragma warning( disable : 4146 ) /* unary minus operator applied to unsigned type, result still unsigned */
# endif
#endif
/*
* This is the WMesa context 'handle':
*/
typedef struct wmesa_context *WMesaContext;
/*
* Create a new WMesaContext for rendering into a window. You must
* have already created the window of correct visual type and with an
* appropriate colormap.
*
* Input:
* hDC - Windows device or memory context
* Pal - Palette to use
* rgb_flag - GL_TRUE = RGB mode,
* GL_FALSE = color index mode
* db_flag - GL_TRUE = double-buffered,
* GL_FALSE = single buffered
* alpha_flag - GL_TRUE = create software alpha buffer,
* GL_FALSE = no software alpha buffer
*
* Note: Indexed mode requires double buffering under Windows.
*
* Return: a WMesa_context or NULL if error.
*/
extern WMesaContext WMesaCreateContext(HDC hDC,HPALETTE* pPal,
GLboolean rgb_flag,
GLboolean db_flag,
GLboolean alpha_flag);
/*
* Destroy a rendering context as returned by WMesaCreateContext()
*/
extern void WMesaDestroyContext( WMesaContext ctx );
/*
* Make the specified context the current one.
*/
extern void WMesaMakeCurrent( WMesaContext ctx, HDC hdc );
/*
* Return a handle to the current context.
*/
extern WMesaContext WMesaGetCurrentContext( void );
/*
* Swap the front and back buffers for the current context. No action
* taken if the context is not double buffered.
*/
extern void WMesaSwapBuffers(HDC hdc);
/*
* In indexed color mode we need to know when the palette changes.
*/
extern void WMesaPaletteChange(HPALETTE Pal);
extern void WMesaMove(void);
void WMesaShareLists(WMesaContext ctx_to_share, WMesaContext ctx);
#ifdef __cplusplus
}
#endif
#endif

1
src/mesa/Makefile.am
View File

@@ -62,7 +62,6 @@ include Makefile.sources
EXTRA_DIST = \
drivers/haiku \
drivers/SConscript \
drivers/windows \
main/format_info.py \
main/format_pack.py \
main/format_parser.py \

3
src/mesa/drivers/SConscript
View File

@@ -11,8 +11,5 @@ if env['dri']:
'dri/common/SConscript',
])
if env['platform'] == 'windows':
SConscript('windows/gdi/SConscript')
if env['platform'] == 'haiku':
SConscript('haiku/swrast/SConscript')

40
src/mesa/drivers/windows/gdi/SConscript
View File

@@ -1,40 +0,0 @@
Import('*')
env = env.Clone()
env.Prepend(CPPPATH = [
'#src',
'#src/mapi',
'#src/mesa',
])
env.AppendUnique(CPPDEFINES = [
'_GDI32_', # prevent wgl* being declared __declspec(dllimport)
'BUILD_GL32', # declare gl* as __declspec(dllexport) in Mesa headers
])
if not env['gles']:
# prevent _glapi_* from being declared __declspec(dllimport)
env.Append(CPPDEFINES = ['_GLAPI_NO_EXPORTS'])
env.Prepend(LIBS = [
mesautil,
glapi,
mesa,
glsl,
'gdi32',
'user32',
'kernel32',
])
sources = [
'mesa.def',
'wgl.c',
'wmesa.c',
]
mesagdi = env.SharedLibrary(
target = 'opengl32',
source = sources,
)
env.Alias('mesagdi', mesagdi)

29
src/mesa/drivers/windows/gdi/colors.h
View File

@@ -1,29 +0,0 @@
/* Values for wmesa->pixelformat: */
#define PF_8A8B8G8R 3 /* 32-bit TrueColor: 8-A, 8-B, 8-G, 8-R */
#define PF_8R8G8B 4 /* 32-bit TrueColor: 8-R, 8-G, 8-B */
#define PF_5R6G5B 5 /* 16-bit TrueColor: 5-R, 6-G, 5-B bits */
#define PF_DITHER8 6 /* Dithered RGB using a lookup table */
#define PF_LOOKUP 7 /* Undithered RGB using a lookup table */
#define PF_GRAYSCALE 10 /* Grayscale or StaticGray */
#define PF_BADFORMAT 11
#define PF_INDEX8 12
#define BGR8(r,g,b) (unsigned)(((BYTE)((b & 0xc0) | ((g & 0xe0)>>2) | \
((r & 0xe0)>>5))))
/* Windows uses 5,5,5 for 16-bit */
#define BGR16(r,g,b) ( (((unsigned short)b ) >> 3) | \
(((unsigned short)g & 0xf8) << 2) | \
(((unsigned short)r & 0xf8) << 7) )
#define BGR24(r,g,b) (unsigned long)((DWORD)(((BYTE)(b)| \
((WORD)((BYTE)(g))<<8))| \
(((DWORD)(BYTE)(r))<<16)))
#define BGR32(r,g,b) (unsigned long)((DWORD)(((BYTE)(b)| \
((WORD)((BYTE)(g))<<8))| \
(((DWORD)(BYTE)(r))<<16)))

385
src/mesa/drivers/windows/gdi/mesa.def
View File

@@ -1,385 +0,0 @@
;
; Module definition file for Mesa (OPENGL32.DLL)
;
; Note: The OpenGL functions use the STDCALL
; function calling convention. Microsoft's
; OPENGL32 uses this convention and so must the
; Mesa OPENGL32 so that the Mesa DLL can be used
; as a drop-in replacement.
;
; The linker exports STDCALL entry points with
; 'decorated' names; e.g., _glBegin@0, where the
; trailing number is the number of bytes of
; parameter data pushed onto the stack. The
; callee is responsible for popping this data
; off the stack, usually via a RETF n instruction.
;
; However, the Microsoft OPENGL32.DLL does not export
; the decorated names, even though the calling convention
; is STDCALL. So, this module definition file is
; needed to force the Mesa OPENGL32.DLL to export the
; symbols in the same manner as the Microsoft DLL.
; Were it not for this problem, this file would not
; be needed (for the gl* functions) since the entry
; points are compiled with dllexport declspec.
;
EXPORTS
glAccum
glAlphaFunc
glAreTexturesResident
glArrayElement
glBegin
glBindTexture
glBitmap
glBlendFunc
glCallList
glCallLists
glClear
glClearAccum
glClearColor
glClearDepth
glClearIndex
glClearStencil
glClipPlane
glColor3b
glColor3bv
glColor3d
glColor3dv
glColor3f
glColor3fv
glColor3i
glColor3iv
glColor3s
glColor3sv
glColor3ub
glColor3ubv
glColor3ui
glColor3uiv
glColor3us
glColor3usv
glColor4b
glColor4bv
glColor4d
glColor4dv
glColor4f
glColor4fv
glColor4i
glColor4iv
glColor4s
glColor4sv
glColor4ub
glColor4ubv
glColor4ui
glColor4uiv
glColor4us
glColor4usv
glColorMask
glColorMaterial
glColorPointer
glCopyPixels
glCopyTexImage1D
glCopyTexImage2D
glCopyTexSubImage1D
glCopyTexSubImage2D
glCullFace
glDeleteLists
glDeleteTextures
glDepthFunc
glDepthMask
glDepthRange
glDisable
glDisableClientState
glDrawArrays
glDrawBuffer
glDrawElements
glDrawPixels
glEdgeFlag
glEdgeFlagPointer
glEdgeFlagv
glEnable
glEnableClientState
glEnd
glEndList
glEvalCoord1d
glEvalCoord1dv
glEvalCoord1f
glEvalCoord1fv
glEvalCoord2d
glEvalCoord2dv
glEvalCoord2f
glEvalCoord2fv
glEvalMesh1
glEvalMesh2
glEvalPoint1
glEvalPoint2
glFeedbackBuffer
glFinish
glFlush
glFogf
glFogfv
glFogi
glFogiv
glFrontFace
glFrustum
glGenLists
glGenTextures
glGetBooleanv
glGetClipPlane
glGetDoublev
glGetError
glGetFloatv
glGetIntegerv
glGetLightfv
glGetLightiv
glGetMapdv
glGetMapfv
glGetMapiv
glGetMaterialfv
glGetMaterialiv
glGetPixelMapfv
glGetPixelMapuiv
glGetPixelMapusv
glGetPointerv
glGetPolygonStipple
glGetString
glGetTexEnvfv
glGetTexEnviv
glGetTexGendv
glGetTexGenfv
glGetTexGeniv
glGetTexImage
glGetTexLevelParameterfv
glGetTexLevelParameteriv
glGetTexParameterfv
glGetTexParameteriv
glHint
glIndexMask
glIndexPointer
glIndexd
glIndexdv
glIndexf
glIndexfv
glIndexi
glIndexiv
glIndexs
glIndexsv
glIndexub
glIndexubv
glInitNames
glInterleavedArrays
glIsEnabled
glIsList
glIsTexture
glLightModelf
glLightModelfv
glLightModeli
glLightModeliv
glLightf
glLightfv
glLighti
glLightiv
glLineStipple
glLineWidth
glListBase
glLoadIdentity
glLoadMatrixd
glLoadMatrixf
glLoadName
glLogicOp
glMap1d
glMap1f
glMap2d
glMap2f
glMapGrid1d
glMapGrid1f
glMapGrid2d
glMapGrid2f
glMaterialf
glMaterialfv
glMateriali
glMaterialiv
glMatrixMode
glMultMatrixd
glMultMatrixf
glNewList
glNormal3b
glNormal3bv
glNormal3d
glNormal3dv
glNormal3f
glNormal3fv
glNormal3i
glNormal3iv
glNormal3s
glNormal3sv
glNormalPointer
glOrtho
glPassThrough
glPixelMapfv
glPixelMapuiv
glPixelMapusv
glPixelStoref
glPixelStorei
glPixelTransferf
glPixelTransferi
glPixelZoom
glPointSize
glPolygonMode
glPolygonOffset
glPolygonStipple
glPopAttrib
glPopClientAttrib
glPopMatrix
glPopName
glPrioritizeTextures
glPushAttrib
glPushClientAttrib
glPushMatrix
glPushName
glRasterPos2d
glRasterPos2dv
glRasterPos2f
glRasterPos2fv
glRasterPos2i
glRasterPos2iv
glRasterPos2s
glRasterPos2sv
glRasterPos3d
glRasterPos3dv
glRasterPos3f
glRasterPos3fv
glRasterPos3i
glRasterPos3iv
glRasterPos3s
glRasterPos3sv
glRasterPos4d
glRasterPos4dv
glRasterPos4f
glRasterPos4fv
glRasterPos4i
glRasterPos4iv
glRasterPos4s
glRasterPos4sv
glReadBuffer
glReadPixels
glRectd
glRectdv
glRectf
glRectfv
glRecti
glRectiv
glRects
glRectsv
glRenderMode
glRotated
glRotatef
glScaled
glScalef
glScissor
glSelectBuffer
glShadeModel
glStencilFunc
glStencilMask
glStencilOp
glTexCoord1d
glTexCoord1dv
glTexCoord1f
glTexCoord1fv
glTexCoord1i
glTexCoord1iv
glTexCoord1s
glTexCoord1sv
glTexCoord2d
glTexCoord2dv
glTexCoord2f
glTexCoord2fv
glTexCoord2i
glTexCoord2iv
glTexCoord2s
glTexCoord2sv
glTexCoord3d
glTexCoord3dv
glTexCoord3f
glTexCoord3fv
glTexCoord3i
glTexCoord3iv
glTexCoord3s
glTexCoord3sv
glTexCoord4d
glTexCoord4dv
glTexCoord4f
glTexCoord4fv
glTexCoord4i
glTexCoord4iv
glTexCoord4s
glTexCoord4sv
glTexCoordPointer
glTexEnvf
glTexEnvfv
glTexEnvi
glTexEnviv
glTexGend
glTexGendv
glTexGenf
glTexGenfv
glTexGeni
glTexGeniv
glTexImage1D
glTexImage2D
glTexParameterf
glTexParameterfv
glTexParameteri
glTexParameteriv
glTexSubImage1D
glTexSubImage2D
glTranslated
glTranslatef
glVertex2d
glVertex2dv
glVertex2f
glVertex2fv
glVertex2i
glVertex2iv
glVertex2s
glVertex2sv
glVertex3d
glVertex3dv
glVertex3f
glVertex3fv
glVertex3i
glVertex3iv
glVertex3s
glVertex3sv
glVertex4d
glVertex4dv
glVertex4f
glVertex4fv
glVertex4i
glVertex4iv
glVertex4s
glVertex4sv
glVertexPointer
glViewport
wglChoosePixelFormat
wglCopyContext
wglCreateContext
wglCreateLayerContext
wglDeleteContext
wglDescribeLayerPlane
wglDescribePixelFormat
wglGetCurrentContext
wglGetCurrentDC
wglGetLayerPaletteEntries
wglGetPixelFormat
wglGetProcAddress
wglMakeCurrent
wglRealizeLayerPalette
wglSetLayerPaletteEntries
wglSetPixelFormat
wglShareLists
wglSwapBuffers
wglSwapLayerBuffers
wglUseFontBitmapsA
wglUseFontBitmapsW
wglUseFontOutlinesA
wglUseFontOutlinesW

689
src/mesa/drivers/windows/gdi/wgl.c
View File

@@ -1,689 +0,0 @@
/*
* 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
*/
/*
* This file contains the implementation of the wgl* functions for
* Mesa on Windows. Since these functions are provided by Windows in
* GDI/OpenGL, we must supply our versions that work with Mesa here.
*/
#include <windows.h>
#include "main/config.h"
#include "glapi/glapi.h"
#include "swrast/swrast.h"
#include "GL/wmesa.h" /* protos for wmesa* functions */
/*
* Pixel Format Descriptors
*/
/* Extend the PFD to include DB flag */
struct __pixelformat__
{
PIXELFORMATDESCRIPTOR pfd;
GLboolean doubleBuffered;
};
/* These are the PFD's supported by this driver. */
struct __pixelformat__ pfd[] =
{
#if 0
/* Double Buffer, alpha */
{
{
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,
DEFAULT_SOFTWARE_DEPTH_BITS, 8,
0, 0, 0,
0, 0, 0
},
GL_TRUE
},
/* Single Buffer, alpha */
{
{
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,
DEFAULT_SOFTWARE_DEPTH_BITS, 8,
0, 0, 0,
0, 0, 0
},
GL_FALSE
},
#endif
/* Double Buffer, no alpha */
{
{
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,
0, 0,
0, 0, 0, 0, 0,
DEFAULT_SOFTWARE_DEPTH_BITS, 8,
0, 0, 0,
0, 0, 0
},
GL_TRUE
},
/* Single Buffer, no alpha */
{
{
sizeof(PIXELFORMATDESCRIPTOR), 1,
PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|
PFD_GENERIC_FORMAT,
PFD_TYPE_RGBA,
24,
8, 0,
8, 8,
8, 16,
0, 0,
0, 0, 0, 0, 0,
DEFAULT_SOFTWARE_DEPTH_BITS, 8,
0, 0, 0,
0, 0, 0
},
GL_FALSE
},
};
int npfd = sizeof(pfd) / sizeof(pfd[0]);
/*
* Contexts
*/
typedef struct {
WMesaContext ctx;
} MesaWglCtx;
#define MESAWGL_CTX_MAX_COUNT 20
static MesaWglCtx wgl_ctx[MESAWGL_CTX_MAX_COUNT];
static unsigned ctx_count = 0;
static int ctx_current = -1;
static unsigned curPFD = 0;
static HDC CurrentHDC = 0;
WINGDIAPI HGLRC GLAPIENTRY wglCreateContext(HDC hdc)
{
int i = 0;
if (!ctx_count) {
for(i=0;i<MESAWGL_CTX_MAX_COUNT;i++) {
wgl_ctx[i].ctx = NULL;
}
}
for( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ ) {
if ( wgl_ctx[i].ctx == NULL ) {
wgl_ctx[i].ctx =
WMesaCreateContext(hdc, NULL, (GLboolean)GL_TRUE,
(GLboolean) (pfd[curPFD-1].doubleBuffered ?
GL_TRUE : GL_FALSE),
(GLboolean)(pfd[curPFD-1].pfd.cAlphaBits ?
GL_TRUE : GL_FALSE) );
if (wgl_ctx[i].ctx == NULL)
break;
ctx_count++;
return ((HGLRC)wgl_ctx[i].ctx);
}
}
SetLastError(0);
return(NULL);
}
WINGDIAPI BOOL GLAPIENTRY wglDeleteContext(HGLRC hglrc)
{
int i;
for ( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ ) {
if ( wgl_ctx[i].ctx == (WMesaContext) hglrc ){
WMesaMakeCurrent((WMesaContext) hglrc, NULL);
WMesaDestroyContext(wgl_ctx[i].ctx);
wgl_ctx[i].ctx = NULL;
ctx_count--;
return(TRUE);
}
}
SetLastError(0);
return(FALSE);
}
WINGDIAPI HGLRC GLAPIENTRY wglGetCurrentContext(VOID)
{
if (ctx_current < 0)
return 0;
else
return (HGLRC) wgl_ctx[ctx_current].ctx;
}
WINGDIAPI HDC GLAPIENTRY wglGetCurrentDC(VOID)
{
return CurrentHDC;
}
WINGDIAPI BOOL GLAPIENTRY wglMakeCurrent(HDC hdc, HGLRC hglrc)
{
int i;
CurrentHDC = hdc;
if (!hdc || !hglrc) {
WMesaMakeCurrent(NULL, NULL);
ctx_current = -1;
return TRUE;
}
for ( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ ) {
if ( wgl_ctx[i].ctx == (WMesaContext) hglrc ) {
WMesaMakeCurrent( (WMesaContext) hglrc, hdc );
ctx_current = i;
return TRUE;
}
}
return FALSE;
}
WINGDIAPI int GLAPIENTRY wglChoosePixelFormat(HDC hdc,
CONST
PIXELFORMATDESCRIPTOR *ppfd)
{
int i,best = -1,bestdelta = 0x7FFFFFFF,delta;
(void) hdc;
if(ppfd->nSize != sizeof(PIXELFORMATDESCRIPTOR) || ppfd->nVersion != 1)
{
SetLastError(0);
return(0);
}
for(i = 0; i < npfd;i++)
{
delta = 0;
if(
(ppfd->dwFlags & PFD_DRAW_TO_WINDOW) &&
!(pfd[i].pfd.dwFlags & PFD_DRAW_TO_WINDOW))
continue;
if(
(ppfd->dwFlags & PFD_DRAW_TO_BITMAP) &&
!(pfd[i].pfd.dwFlags & PFD_DRAW_TO_BITMAP))
continue;
if(
(ppfd->dwFlags & PFD_SUPPORT_GDI) &&
!(pfd[i].pfd.dwFlags & PFD_SUPPORT_GDI))
continue;
if(
(ppfd->dwFlags & PFD_SUPPORT_OPENGL) &&
!(pfd[i].pfd.dwFlags & PFD_SUPPORT_OPENGL))
continue;
if(
!(ppfd->dwFlags & PFD_DOUBLEBUFFER_DONTCARE) &&
((ppfd->dwFlags & PFD_DOUBLEBUFFER) !=
(pfd[i].pfd.dwFlags & PFD_DOUBLEBUFFER)))
continue;
if(
!(ppfd->dwFlags & PFD_STEREO_DONTCARE) &&
((ppfd->dwFlags & PFD_STEREO) !=
(pfd[i].pfd.dwFlags & PFD_STEREO)))
continue;
if(ppfd->iPixelType != pfd[i].pfd.iPixelType)
delta++;
if(ppfd->cAlphaBits != pfd[i].pfd.cAlphaBits)
delta++;
if(delta < bestdelta)
{
best = i + 1;
bestdelta = delta;
if(bestdelta == 0)
break;
}
}
if(best == -1)
{
SetLastError(0);
return(0);
}
return(best);
}
WINGDIAPI int GLAPIENTRY wglDescribePixelFormat(HDC hdc,
int iPixelFormat,
UINT nBytes,
LPPIXELFORMATDESCRIPTOR ppfd)
{
(void) hdc;
if(ppfd == NULL)
return(npfd);
if(iPixelFormat < 1 || iPixelFormat > npfd ||
nBytes != sizeof(PIXELFORMATDESCRIPTOR))
{
SetLastError(0);
return(0);
}
*ppfd = pfd[iPixelFormat - 1].pfd;
return(npfd);
}
WINGDIAPI PROC GLAPIENTRY wglGetProcAddress(LPCSTR lpszProc)
{
PROC p = (PROC) _glapi_get_proc_address((const char *) lpszProc);
if (p)
return p;
SetLastError(0);
return(NULL);
}
WINGDIAPI int GLAPIENTRY wglGetPixelFormat(HDC hdc)
{
(void) hdc;
if(curPFD == 0) {
SetLastError(0);
return(0);
}
return(curPFD);
}
WINGDIAPI BOOL GLAPIENTRY wglSetPixelFormat(HDC hdc,int iPixelFormat,
const PIXELFORMATDESCRIPTOR *ppfd)
{
(void) hdc;
/* SetPixelFormat (hence wglSetPixelFormat) must not touch ppfd, per
* http://msdn.microsoft.com/en-us/library/dd369049(v=vs.85).aspx
*/
(void) ppfd;
if(iPixelFormat < 1 || iPixelFormat > npfd) {
SetLastError(0);
return(FALSE);
}
curPFD = iPixelFormat;
return(TRUE);
}
WINGDIAPI BOOL GLAPIENTRY wglSwapBuffers(HDC hdc)
{
WMesaSwapBuffers(hdc);
return TRUE;
}
static FIXED FixedFromDouble(double d)
{
long l = (long) (d * 65536L);
return *(FIXED *) (void *) &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) (void)(a)
TEXTMETRIC metric;
BITMAPINFO *dibInfo;
HDC bitDevice;
COLORREF tempColor;
int i;
VERIFY(GetTextMetrics(fontDevice, &metric));
dibInfo = calloc(sizeof(BITMAPINFO) + sizeof(RGBQUAD), 1);
dibInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
dibInfo->bmiHeader.biPlanes = 1;
dibInfo->bmiHeader.biBitCount = 1;
dibInfo->bmiHeader.biCompression = BI_RGB;
bitDevice = CreateCompatibleDC(fontDevice);
/* Swap fore and back colors so the bitmap has the right polarity */
tempColor = GetBkColor(bitDevice);
SetBkColor(bitDevice, GetTextColor(bitDevice));
SetTextColor(bitDevice, tempColor);
/* Place chars based on base line */
VERIFY(SetTextAlign(bitDevice, TA_BASELINE) != GDI_ERROR ? 1 : 0);
for(i = 0; i < (int)numChars; i++) {
SIZE size;
char curChar;
int charWidth,charHeight,bmapWidth,bmapHeight,numBytes,res;
HBITMAP bitObject;
HGDIOBJ origBmap;
unsigned char *bmap;
curChar = (char)(i + firstChar);
/* Find how high/wide this character is */
VERIFY(GetTextExtentPoint32(bitDevice, &curChar, 1, &size));
/* Create the output bitmap */
charWidth = size.cx;
charHeight = size.cy;
/* Round up to the next multiple of 32 bits */
bmapWidth = ((charWidth + 31) / 32) * 32;
bmapHeight = charHeight;
bitObject = CreateCompatibleBitmap(bitDevice,
bmapWidth,
bmapHeight);
/* VERIFY(bitObject); */
/* Assign the output bitmap to the device */
origBmap = SelectObject(bitDevice, bitObject);
(void) 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, (GLfloat)metric.tmDescent,
(GLfloat)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
}
WINGDIAPI 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 (count == 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 < (int)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, /* ptr 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,
(GLfloat)-gm.gmptGlyphOrigin.x,
(GLfloat)gm.gmptGlyphOrigin.y,
(GLfloat)gm.gmCellIncX,
(GLfloat)gm.gmCellIncY,
(const GLubyte * )lpBits);
GlobalUnlock(hBits);
GlobalFree(hBits);
glEndList( );
}
return success;
}
WINGDIAPI BOOL GLAPIENTRY wglShareLists(HGLRC hglrc1,
HGLRC hglrc2)
{
WMesaShareLists((WMesaContext)hglrc1, (WMesaContext)hglrc2);
return(TRUE);
}
/* NOT IMPLEMENTED YET */
WINGDIAPI BOOL GLAPIENTRY wglCopyContext(HGLRC hglrcSrc,
HGLRC hglrcDst,
UINT mask)
{
(void) hglrcSrc; (void) hglrcDst; (void) mask;
return(FALSE);
}
WINGDIAPI HGLRC GLAPIENTRY wglCreateLayerContext(HDC hdc,
int iLayerPlane)
{
SetLastError(0);
if (iLayerPlane == 0)
return wglCreateContext( hdc );
return(NULL);
}
WINGDIAPI BOOL GLAPIENTRY wglUseFontBitmapsW(HDC hdc,
DWORD first,
DWORD count,
DWORD listBase)
{
(void) hdc; (void) first; (void) count; (void) listBase;
return FALSE;
}
WINGDIAPI BOOL GLAPIENTRY wglUseFontOutlinesA(HDC hdc,
DWORD first,
DWORD count,
DWORD listBase,
FLOAT deviation,
FLOAT extrusion,
int format,
LPGLYPHMETRICSFLOAT lpgmf)
{
(void) hdc; (void) first; (void) count;
(void) listBase; (void) deviation; (void) extrusion; (void) format;
(void) lpgmf;
SetLastError(0);
return(FALSE);
}
WINGDIAPI BOOL GLAPIENTRY wglUseFontOutlinesW(HDC hdc,
DWORD first,
DWORD count,
DWORD listBase,
FLOAT deviation,
FLOAT extrusion,
int format,
LPGLYPHMETRICSFLOAT lpgmf)
{
(void) hdc; (void) first; (void) count;
(void) listBase; (void) deviation; (void) extrusion; (void) format;
(void) lpgmf;
SetLastError(0);
return(FALSE);
}
WINGDIAPI BOOL GLAPIENTRY wglDescribeLayerPlane(HDC hdc,
int iPixelFormat,
int iLayerPlane,
UINT nBytes,
LPLAYERPLANEDESCRIPTOR plpd)
{
(void) hdc; (void) iPixelFormat; (void) iLayerPlane;
(void) nBytes; (void) plpd;
SetLastError(0);
return(FALSE);
}
WINGDIAPI int GLAPIENTRY wglSetLayerPaletteEntries(HDC hdc,
int iLayerPlane,
int iStart,
int cEntries,
CONST COLORREF *pcr)
{
(void) hdc; (void) iLayerPlane; (void) iStart;
(void) cEntries; (void) pcr;
SetLastError(0);
return(0);
}
WINGDIAPI int GLAPIENTRY wglGetLayerPaletteEntries(HDC hdc,
int iLayerPlane,
int iStart,
int cEntries,
COLORREF *pcr)
{
(void) hdc; (void) iLayerPlane; (void) iStart; (void) cEntries; (void) pcr;
SetLastError(0);
return(0);
}
WINGDIAPI BOOL GLAPIENTRY wglRealizeLayerPalette(HDC hdc,
int iLayerPlane,
BOOL bRealize)
{
(void) hdc; (void) iLayerPlane; (void) bRealize;
SetLastError(0);
return(FALSE);
}
WINGDIAPI BOOL GLAPIENTRY wglSwapLayerBuffers(HDC hdc,
UINT fuPlanes)
{
(void) hdc; (void) fuPlanes;
SetLastError(0);
return(FALSE);
}
WINGDIAPI const char * GLAPIENTRY wglGetExtensionsStringARB(HDC hdc)
{
return "WGL_ARB_extensions_string";
}

791
src/mesa/drivers/windows/gdi/wmesa.c
View File

@@ -1,791 +0,0 @@
/*
* Windows (Win32/Win64) device driver for Mesa
*
*/
#include "wmesadef.h"
#include "colors.h"
#include "GL/wmesa.h"
#include <winuser.h>
#include "main/context.h"
#include "main/api_exec.h"
#include "main/extensions.h"
#include "main/framebuffer.h"
#include "main/renderbuffer.h"
#include "main/macros.h"
#include "main/version.h"
#include "main/vtxfmt.h"
#include "drivers/common/driverfuncs.h"
#include "drivers/common/meta.h"
#include "vbo/vbo.h"
#include "swrast/swrast.h"
#include "swrast/s_renderbuffer.h"
#include "swrast_setup/swrast_setup.h"
#include "tnl/tnl.h"
#include "tnl/t_context.h"
#include "tnl/t_pipeline.h"
/* linked list of our Framebuffers (windows) */
static WMesaFramebuffer FirstFramebuffer = NULL;
/**
* Create a new WMesaFramebuffer object which will correspond to the
* given HDC (Window handle).
*/
static WMesaFramebuffer
wmesa_new_framebuffer(HDC hdc, struct gl_config *visual)
{
WMesaFramebuffer pwfb
= malloc(sizeof(struct wmesa_framebuffer));
if (pwfb) {
_mesa_initialize_window_framebuffer(&pwfb->Base, visual);
pwfb->hDC = hdc;
/* insert at head of list */
pwfb->next = FirstFramebuffer;
FirstFramebuffer = pwfb;
}
return pwfb;
}
/**
* Given an hdc, free the corresponding WMesaFramebuffer
*/
static void
wmesa_free_framebuffer(HDC hdc)
{
WMesaFramebuffer pwfb, prev;
for (pwfb = FirstFramebuffer; pwfb; pwfb = pwfb->next) {
if (pwfb->hDC == hdc)
break;
prev = pwfb;
}
if (pwfb) {
struct gl_framebuffer *fb;
if (pwfb == FirstFramebuffer)
FirstFramebuffer = pwfb->next;
else
prev->next = pwfb->next;
fb = &pwfb->Base;
_mesa_reference_framebuffer(&fb, NULL);
}
}
/**
* Given an hdc, return the corresponding WMesaFramebuffer
*/
static WMesaFramebuffer
wmesa_lookup_framebuffer(HDC hdc)
{
WMesaFramebuffer pwfb;
for (pwfb = FirstFramebuffer; pwfb; pwfb = pwfb->next) {
if (pwfb->hDC == hdc)
return pwfb;
}
return NULL;
}
/**
* Given a struct gl_framebuffer, return the corresponding WMesaFramebuffer.
*/
static WMesaFramebuffer wmesa_framebuffer(struct gl_framebuffer *fb)
{
return (WMesaFramebuffer) fb;
}
/**
* Given a struct gl_context, return the corresponding WMesaContext.
*/
static WMesaContext wmesa_context(const struct gl_context *ctx)
{
return (WMesaContext) ctx;
}
/*
* Every driver should implement a GetString function in order to
* return a meaningful GL_RENDERER string.
*/
static const GLubyte *wmesa_get_string(struct gl_context *ctx, GLenum name)
{
return (name == GL_RENDERER) ?
(GLubyte *) "Mesa Windows GDI Driver" : NULL;
}
/*
* Determine the pixel format based on the pixel size.
*/
static void wmSetPixelFormat(WMesaFramebuffer pwfb, HDC hDC)
{
pwfb->cColorBits = GetDeviceCaps(hDC, BITSPIXEL);
/* Only 16 and 32 bit targets are supported now */
assert(pwfb->cColorBits == 0 ||
pwfb->cColorBits == 16 ||
pwfb->cColorBits == 24 ||
pwfb->cColorBits == 32);
switch(pwfb->cColorBits){
case 8:
pwfb->pixelformat = PF_INDEX8;
break;
case 16:
pwfb->pixelformat = PF_5R6G5B;
break;
case 24:
case 32:
pwfb->pixelformat = PF_8R8G8B;
break;
default:
pwfb->pixelformat = PF_BADFORMAT;
}
}
/**
* Create DIB for back buffer.
* We write into this memory with the span routines and then blit it
* to the window on a buffer swap.
*/
static BOOL wmCreateBackingStore(WMesaFramebuffer pwfb, long lxSize, long lySize)
{
LPBITMAPINFO pbmi = &(pwfb->bmi);
HDC hic;
pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pbmi->bmiHeader.biWidth = lxSize;
pbmi->bmiHeader.biHeight= -lySize;
pbmi->bmiHeader.biPlanes = 1;
pbmi->bmiHeader.biBitCount = GetDeviceCaps(pwfb->hDC, BITSPIXEL);
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;
pwfb->cColorBits = pbmi->bmiHeader.biBitCount;
pwfb->ScanWidth = (lxSize * (pwfb->cColorBits / 8) + 3) & ~3;
hic = CreateIC("display", NULL, NULL, NULL);
pwfb->dib_hDC = CreateCompatibleDC(hic);
pwfb->hbmDIB = CreateDIBSection(hic,
&pwfb->bmi,
DIB_RGB_COLORS,
(void **)&(pwfb->pbPixels),
0,
0);
pwfb->hOldBitmap = SelectObject(pwfb->dib_hDC, pwfb->hbmDIB);
DeleteDC(hic);
wmSetPixelFormat(pwfb, pwfb->hDC);
return TRUE;
}
static void wmDeleteBackingStore(WMesaFramebuffer pwfb)
{
if (pwfb->hbmDIB) {
SelectObject(pwfb->dib_hDC, pwfb->hOldBitmap);
DeleteDC(pwfb->dib_hDC);
DeleteObject(pwfb->hbmDIB);
}
}
/**
* Find the width and height of the window named by hdc.
*/
static void
get_window_size(HDC hdc, GLuint *width, GLuint *height)
{
if (WindowFromDC(hdc)) {
RECT rect;
GetClientRect(WindowFromDC(hdc), &rect);
*width = rect.right - rect.left;
*height = rect.bottom - rect.top;
}
else { /* Memory context */
/* From contributed code - use the size of the desktop
* for the size of a memory context (?) */
*width = GetDeviceCaps(hdc, HORZRES);
*height = GetDeviceCaps(hdc, VERTRES);
}
}
static void
wmesa_get_buffer_size(struct gl_framebuffer *buffer, GLuint *width, GLuint *height)
{
WMesaFramebuffer pwfb = wmesa_framebuffer(buffer);
get_window_size(pwfb->hDC, width, height);
}
static void wmesa_flush(struct gl_context *ctx)
{
WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->WinSysDrawBuffer);
if (ctx->Visual.doubleBufferMode == 1) {
BitBlt(pwfb->hDC, 0, 0, pwfb->Base.Width, pwfb->Base.Height,
pwfb->dib_hDC, 0, 0, SRCCOPY);
}
else {
/* Do nothing for single buffer */
}
}
/**********************************************************************/
/***** CLEAR Functions *****/
/**********************************************************************/
/*
* Clear the color/depth/stencil buffers.
*/
static void clear(struct gl_context *ctx, GLbitfield mask)
{
#define FLIP(Y) (ctx->DrawBuffer->Height - (Y) - 1)
const GLint x = ctx->DrawBuffer->_Xmin;
const GLint y = ctx->DrawBuffer->_Ymin;
const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
const GLint width = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
WMesaContext pwc = wmesa_context(ctx);
WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
int done = 0;
/* Let swrast do all the work if the masks are not set to
* clear all channels. */
if (!ctx->Color.ColorMask[0][0] ||
!ctx->Color.ColorMask[0][1] ||
!ctx->Color.ColorMask[0][2] ||
!ctx->Color.ColorMask[0][3]) {
_swrast_Clear(ctx, mask);
return;
}
if (mask & BUFFER_BITS_COLOR) {
/* setup the clearing color */
const union gl_color_union color = ctx->Color.ClearColor;
GLubyte col[3];
UNCLAMPED_FLOAT_TO_UBYTE(col[0], color.f[0]);
UNCLAMPED_FLOAT_TO_UBYTE(col[1], color.f[1]);
UNCLAMPED_FLOAT_TO_UBYTE(col[2], color.f[2]);
pwc->clearColorRef = RGB(col[0], col[1], col[2]);
DeleteObject(pwc->clearPen);
DeleteObject(pwc->clearBrush);
pwc->clearPen = CreatePen(PS_SOLID, 1, pwc->clearColorRef);
pwc->clearBrush = CreateSolidBrush(pwc->clearColorRef);
}
/* Back buffer */
if (mask & BUFFER_BIT_BACK_LEFT) {
int i, rowSize;
UINT bytesPerPixel = pwfb->cColorBits / 8;
LPBYTE lpb, clearRow;
LPWORD lpw;
BYTE bColor;
WORD wColor;
BYTE r, g, b;
DWORD dwColor;
LPDWORD lpdw;
/* Try for a fast clear - clearing entire buffer with a single
* byte value. */
if (width == ctx->DrawBuffer->Width &&
height == ctx->DrawBuffer->Height) { /* entire buffer */
/* Now check for an easy clear value */
switch (bytesPerPixel) {
case 1:
bColor = BGR8(GetRValue(pwc->clearColorRef),
GetGValue(pwc->clearColorRef),
GetBValue(pwc->clearColorRef));
memset(pwfb->pbPixels, bColor,
pwfb->ScanWidth * height);
done = 1;
break;
case 2:
wColor = BGR16(GetRValue(pwc->clearColorRef),
GetGValue(pwc->clearColorRef),
GetBValue(pwc->clearColorRef));
if (((wColor >> 8) & 0xff) == (wColor & 0xff)) {
memset(pwfb->pbPixels, wColor & 0xff,
pwfb->ScanWidth * height);
done = 1;
}
break;
case 3:
/* fall through */
case 4:
if (GetRValue(pwc->clearColorRef) ==
GetGValue(pwc->clearColorRef) &&
GetRValue(pwc->clearColorRef) ==
GetBValue(pwc->clearColorRef)) {
memset(pwfb->pbPixels,
GetRValue(pwc->clearColorRef),
pwfb->ScanWidth * height);
done = 1;
}
break;
default:
break;
}
} /* all */
if (!done) {
/* Need to clear a row at a time. Begin by setting the first
* row in the area to be cleared to the clear color. */
clearRow = pwfb->pbPixels +
pwfb->ScanWidth * FLIP(y) +
bytesPerPixel * x;
switch (bytesPerPixel) {
case 1:
lpb = clearRow;
bColor = BGR8(GetRValue(pwc->clearColorRef),
GetGValue(pwc->clearColorRef),
GetBValue(pwc->clearColorRef));
memset(lpb, bColor, width);
break;
case 2:
lpw = (LPWORD)clearRow;
wColor = BGR16(GetRValue(pwc->clearColorRef),
GetGValue(pwc->clearColorRef),
GetBValue(pwc->clearColorRef));
for (i=0; i<width; i++)
*lpw++ = wColor;
break;
case 3:
lpb = clearRow;
r = GetRValue(pwc->clearColorRef);
g = GetGValue(pwc->clearColorRef);
b = GetBValue(pwc->clearColorRef);
for (i=0; i<width; i++) {
*lpb++ = b;
*lpb++ = g;
*lpb++ = r;
}
break;
case 4:
lpdw = (LPDWORD)clearRow;
dwColor = BGR32(GetRValue(pwc->clearColorRef),
GetGValue(pwc->clearColorRef),
GetBValue(pwc->clearColorRef));
for (i=0; i<width; i++)
*lpdw++ = dwColor;
break;
default:
break;
} /* switch */
/* copy cleared row to other rows in buffer */
lpb = clearRow - pwfb->ScanWidth;
rowSize = width * bytesPerPixel;
for (i=1; i<height; i++) {
memcpy(lpb, clearRow, rowSize);
lpb -= pwfb->ScanWidth;
}
} /* not done */
mask &= ~BUFFER_BIT_BACK_LEFT;
} /* back buffer */
/* front buffer */
if (mask & BUFFER_BIT_FRONT_LEFT) {
HDC DC = pwc->hDC;
HPEN Old_Pen = SelectObject(DC, pwc->clearPen);
HBRUSH Old_Brush = SelectObject(DC, pwc->clearBrush);
Rectangle(DC,
x,
FLIP(y) + 1,
x + width + 1,
FLIP(y) - height + 1);
SelectObject(DC, Old_Pen);
SelectObject(DC, Old_Brush);
mask &= ~BUFFER_BIT_FRONT_LEFT;
} /* front buffer */
/* Call swrast if there is anything left to clear (like DEPTH) */
if (mask)
_swrast_Clear(ctx, mask);
#undef FLIP
}
/**********************************************************************/
/***** BUFFER Functions *****/
/**********************************************************************/
static void
wmesa_delete_renderbuffer(struct gl_context *ctx, struct gl_renderbuffer *rb)
{
_mesa_delete_renderbuffer(ctx, rb);
}
/**
* This is called by Mesa whenever it determines that the window size
* has changed. Do whatever's needed to cope with that.
*/
static GLboolean
wmesa_renderbuffer_storage(struct gl_context *ctx,
struct gl_renderbuffer *rb,
GLenum internalFormat,
GLuint width,
GLuint height)
{
rb->Width = width;
rb->Height = height;
return GL_TRUE;
}
/**
* Called by ctx->Driver.ResizeBuffers()
* Resize the front/back colorbuffers to match the latest window size.
*/
static void
wmesa_resize_buffers(struct gl_context *ctx, struct gl_framebuffer *buffer,
GLuint width, GLuint height)
{
WMesaFramebuffer pwfb = wmesa_framebuffer(buffer);
if (pwfb->Base.Width != width || pwfb->Base.Height != height) {
/* Realloc back buffer */
if (ctx->Visual.doubleBufferMode == 1) {
wmDeleteBackingStore(pwfb);
wmCreateBackingStore(pwfb, width, height);
}
}
_mesa_resize_framebuffer(ctx, buffer, width, height);
}
/**
* Called by glViewport.
* This is a good time for us to poll the current window size and adjust
* our renderbuffers to match the current window size.
* Remember, we have no opportunity to respond to conventional
* resize events since the driver has no event loop.
* Thus, we poll.
* MakeCurrent also ends up making a call here, so that ensures
* we get the viewport set correctly, even if the app does not call
* glViewport and relies on the defaults.
*/
static void wmesa_viewport(struct gl_context *ctx)
{
GLuint new_width, new_height;
wmesa_get_buffer_size(ctx->WinSysDrawBuffer, &new_width, &new_height);
/**
* Resize buffers if the window size changed.
*/
wmesa_resize_buffers(ctx, ctx->WinSysDrawBuffer, new_width, new_height);
ctx->NewState |= _NEW_BUFFERS; /* to update scissor / window bounds */
}
/**
* Called when the driver should update it's state, based on the new_state
* flags.
*/
static void wmesa_update_state(struct gl_context *ctx, GLuint new_state)
{
_swrast_InvalidateState(ctx, new_state);
_swsetup_InvalidateState(ctx, new_state);
_vbo_InvalidateState(ctx, new_state);
_tnl_InvalidateState(ctx, new_state);
/* TODO - This code is not complete yet because I
* don't know what to do for all state updates.
*/
if (new_state & _NEW_BUFFERS) {
}
}
/**********************************************************************/
/***** WMESA Functions *****/
/**********************************************************************/
WMesaContext WMesaCreateContext(HDC hDC,
HPALETTE* Pal,
GLboolean rgb_flag,
GLboolean db_flag,
GLboolean alpha_flag)
{
WMesaContext c;
struct dd_function_table functions;
GLint red_bits, green_bits, blue_bits, alpha_bits;
struct gl_context *ctx;
struct gl_config *visual;
(void) Pal;
/* Indexed mode not supported */
if (!rgb_flag)
return NULL;
/* Allocate wmesa context */
c = CALLOC_STRUCT(wmesa_context);
if (!c)
return NULL;
#if 0
/* I do not understand this contributed code */
/* Support memory and device contexts */
if(WindowFromDC(hDC) != NULL) {
c->hDC = GetDC(WindowFromDC(hDC)); /* huh ???? */
}
else {
c->hDC = hDC;
}
#else
c->hDC = hDC;
#endif
/* Get data for visual */
/* Dealing with this is actually a bit of overkill because Mesa will end
* up treating all color component size requests less than 8 by using
* a single byte per channel. In addition, the interface to the span
* routines passes colors as an entire byte per channel anyway, so there
* is nothing to be saved by telling the visual to be 16 bits if the device
* is 16 bits. That is, Mesa is going to compute colors down to 8 bits per
* channel anyway.
* But we go through the motions here anyway.
*/
switch (GetDeviceCaps(c->hDC, BITSPIXEL)) {
case 16:
red_bits = green_bits = blue_bits = 5;
alpha_bits = 0;
break;
default:
red_bits = green_bits = blue_bits = 8;
alpha_bits = 8;
break;
}
/* Create visual based on flags */
visual = _mesa_create_visual(db_flag, /* db_flag */
GL_FALSE, /* stereo */
red_bits, green_bits, blue_bits, /* color RGB */
alpha_flag ? alpha_bits : 0, /* color A */
DEFAULT_SOFTWARE_DEPTH_BITS, /* depth_bits */
8, /* stencil_bits */
16,16,16, /* accum RGB */
alpha_flag ? 16 : 0, /* accum A */
1); /* num samples */
if (!visual) {
free(c);
return NULL;
}
/* Set up driver functions */
_mesa_init_driver_functions(&functions);
functions.GetString = wmesa_get_string;
functions.UpdateState = wmesa_update_state;
functions.Flush = wmesa_flush;
functions.Clear = clear;
functions.ResizeBuffers = wmesa_resize_buffers;
functions.Viewport = wmesa_viewport;
/* initialize the Mesa context data */
ctx = &c->gl_ctx;
_mesa_initialize_context(ctx, API_OPENGL_COMPAT, visual,
NULL, &functions);
/* visual no longer needed - it was copied by _mesa_initialize_context() */
_mesa_destroy_visual(visual);
_mesa_enable_sw_extensions(ctx);
_mesa_meta_init(ctx);
/* Initialize the software rasterizer and helper modules. */
if (!_swrast_CreateContext(ctx) ||
!_vbo_CreateContext(ctx) ||
!_tnl_CreateContext(ctx) ||
!_swsetup_CreateContext(ctx)) {
_mesa_free_context_data(ctx);
free(c);
return NULL;
}
_swsetup_Wakeup(ctx);
TNL_CONTEXT(ctx)->Driver.RunPipeline = _tnl_run_pipeline;
_mesa_compute_version(ctx);
/* Exec table initialization requires the version to be computed */
_mesa_initialize_dispatch_tables(ctx);
_mesa_initialize_vbo_vtxfmt(ctx);
return c;
}
void WMesaDestroyContext( WMesaContext pwc )
{
struct gl_context *ctx = &pwc->gl_ctx;
WMesaFramebuffer pwfb;
GET_CURRENT_CONTEXT(cur_ctx);
if (cur_ctx == ctx) {
/* unbind current if deleting current context */
WMesaMakeCurrent(NULL, NULL);
}
/* clean up frame buffer resources */
pwfb = wmesa_lookup_framebuffer(pwc->hDC);
if (pwfb) {
if (ctx->Visual.doubleBufferMode == 1)
wmDeleteBackingStore(pwfb);
wmesa_free_framebuffer(pwc->hDC);
}
/* Release for device, not memory contexts */
if (WindowFromDC(pwc->hDC) != NULL)
{
ReleaseDC(WindowFromDC(pwc->hDC), pwc->hDC);
}
DeleteObject(pwc->clearPen);
DeleteObject(pwc->clearBrush);
_mesa_meta_free(ctx);
_swsetup_DestroyContext(ctx);
_tnl_DestroyContext(ctx);
_vbo_DestroyContext(ctx);
_swrast_DestroyContext(ctx);
_mesa_free_context_data(ctx);
free(pwc);
}
/**
* Create a new color renderbuffer.
*/
static struct gl_renderbuffer *
wmesa_new_renderbuffer(void)
{
struct gl_renderbuffer *rb = CALLOC_STRUCT(gl_renderbuffer);
if (!rb)
return NULL;
_mesa_init_renderbuffer(rb, (GLuint)0);
rb->_BaseFormat = GL_RGBA;
rb->InternalFormat = GL_RGBA;
rb->Delete = wmesa_delete_renderbuffer;
rb->AllocStorage = wmesa_renderbuffer_storage;
return rb;
}
void WMesaMakeCurrent(WMesaContext c, HDC hdc)
{
WMesaFramebuffer pwfb;
{
/* return if already current */
GET_CURRENT_CONTEXT(ctx);
WMesaContext pwc = wmesa_context(ctx);
if (pwc && c == pwc && pwc->hDC == hdc)
return;
}
pwfb = wmesa_lookup_framebuffer(hdc);
/* Lazy creation of framebuffers */
if (c && !pwfb && hdc) {
struct gl_renderbuffer *rb;
struct gl_config *visual = &c->gl_ctx.Visual;
GLuint width, height;
get_window_size(hdc, &width, &height);
c->clearPen = CreatePen(PS_SOLID, 1, 0);
c->clearBrush = CreateSolidBrush(0);
pwfb = wmesa_new_framebuffer(hdc, visual);
/* Create back buffer if double buffered */
if (visual->doubleBufferMode == 1) {
wmCreateBackingStore(pwfb, width, height);
}
/* make render buffers */
if (visual->doubleBufferMode == 1) {
rb = wmesa_new_renderbuffer();
_mesa_add_renderbuffer(&pwfb->Base, BUFFER_BACK_LEFT, rb);
}
rb = wmesa_new_renderbuffer();
_mesa_add_renderbuffer(&pwfb->Base, BUFFER_FRONT_LEFT, rb);
/* Let Mesa own the Depth, Stencil, and Accum buffers */
_swrast_add_soft_renderbuffers(&pwfb->Base,
GL_FALSE, /* color */
visual->depthBits > 0,
visual->stencilBits > 0,
visual->accumRedBits > 0,
visual->alphaBits >0,
GL_FALSE);
}
if (c && pwfb)
_mesa_make_current(&c->gl_ctx, &pwfb->Base, &pwfb->Base);
else
_mesa_make_current(NULL, NULL, NULL);
}
void WMesaSwapBuffers( HDC hdc )
{
GET_CURRENT_CONTEXT(ctx);
WMesaContext pwc = wmesa_context(ctx);
WMesaFramebuffer pwfb = wmesa_lookup_framebuffer(hdc);
if (!pwfb) {
_mesa_problem(NULL, "wmesa: swapbuffers on unknown hdc");
return;
}
/* If we're swapping the buffer associated with the current context
* we have to flush any pending rendering commands first.
*/
if (pwc->hDC == hdc) {
_mesa_notifySwapBuffers(ctx);
BitBlt(pwfb->hDC, 0, 0, pwfb->Base.Width, pwfb->Base.Height,
pwfb->dib_hDC, 0, 0, SRCCOPY);
}
else {
/* XXX for now only allow swapping current window */
_mesa_problem(NULL, "wmesa: can't swap non-current window");
}
}
void WMesaShareLists(WMesaContext ctx_to_share, WMesaContext ctx)
{
_mesa_share_state(&ctx->gl_ctx, &ctx_to_share->gl_ctx);
}

43
src/mesa/drivers/windows/gdi/wmesadef.h
View File

@@ -1,43 +0,0 @@
#ifndef WMESADEF_H
#define WMESADEF_H
#include <windows.h>
#include "main/context.h"
/**
* The Windows Mesa rendering context, derived from struct gl_context.
*/
struct wmesa_context {
struct gl_context gl_ctx; /* The core GL/Mesa context */
HDC hDC;
COLORREF clearColorRef;
HPEN clearPen;
HBRUSH clearBrush;
};
/**
* Windows framebuffer, derived from gl_framebuffer
*/
struct wmesa_framebuffer
{
struct gl_framebuffer Base;
HDC hDC;
int pixelformat;
GLuint ScanWidth;
int cColorBits;
/* back buffer DIB fields */
HDC dib_hDC;
BITMAPINFO bmi;
HBITMAP hbmDIB;
HBITMAP hOldBitmap;
PBYTE pbPixels;
struct wmesa_framebuffer *next;
};
typedef struct wmesa_framebuffer *WMesaFramebuffer;
#endif /* WMESADEF_H */