| /contrib/sdk/sources/Mesa/src/mesa/drivers/windows/gdi/SConscript |
|---|
| 0,0 → 1,38 |
| Import('*') |
| env = env.Clone() |
| env.Prepend(CPPPATH = [ |
| '#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 = [ |
| glapi, |
| mesa, |
| glsl, |
| 'gdi32', |
| 'user32', |
| 'kernel32', |
| ]) |
| sources = [ |
| 'mesa.def', |
| 'wgl.c', |
| 'wmesa.c', |
| ] |
| mesagdi = env.SharedLibrary( |
| target = 'opengl32', |
| source = sources, |
| ) |
| env.Alias('mesagdi', mesagdi) |
| /contrib/sdk/sources/Mesa/src/mesa/drivers/windows/gdi/colors.h |
|---|
| 0,0 → 1,29 |
| /* 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))) |
| /contrib/sdk/sources/Mesa/src/mesa/drivers/windows/gdi/mesa.def |
|---|
| 0,0 → 1,840 |
| ; DO NOT EDIT - This file generated automatically by mesadef.py script |
| ;DESCRIPTION 'Mesa (OpenGL work-alike) for Win32' |
| VERSION 6.5 |
| ; |
| ; 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 |
| glNewList |
| glEndList |
| glCallList |
| glCallLists |
| glDeleteLists |
| glGenLists |
| glListBase |
| glBegin |
| glBitmap |
| 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 |
| glEdgeFlag |
| glEdgeFlagv |
| glEnd |
| glIndexd |
| glIndexdv |
| glIndexf |
| glIndexfv |
| glIndexi |
| glIndexiv |
| glIndexs |
| glIndexsv |
| glNormal3b |
| glNormal3bv |
| glNormal3d |
| glNormal3dv |
| glNormal3f |
| glNormal3fv |
| glNormal3i |
| glNormal3iv |
| glNormal3s |
| glNormal3sv |
| glRasterPos2d |
| glRasterPos2dv |
| glRasterPos2f |
| glRasterPos2fv |
| glRasterPos2i |
| glRasterPos2iv |
| glRasterPos2s |
| glRasterPos2sv |
| glRasterPos3d |
| glRasterPos3dv |
| glRasterPos3f |
| glRasterPos3fv |
| glRasterPos3i |
| glRasterPos3iv |
| glRasterPos3s |
| glRasterPos3sv |
| glRasterPos4d |
| glRasterPos4dv |
| glRasterPos4f |
| glRasterPos4fv |
| glRasterPos4i |
| glRasterPos4iv |
| glRasterPos4s |
| glRasterPos4sv |
| glRectd |
| glRectdv |
| glRectf |
| glRectfv |
| glRecti |
| glRectiv |
| glRects |
| glRectsv |
| 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 |
| glVertex2d |
| glVertex2dv |
| glVertex2f |
| glVertex2fv |
| glVertex2i |
| glVertex2iv |
| glVertex2s |
| glVertex2sv |
| glVertex3d |
| glVertex3dv |
| glVertex3f |
| glVertex3fv |
| glVertex3i |
| glVertex3iv |
| glVertex3s |
| glVertex3sv |
| glVertex4d |
| glVertex4dv |
| glVertex4f |
| glVertex4fv |
| glVertex4i |
| glVertex4iv |
| glVertex4s |
| glVertex4sv |
| glClipPlane |
| glColorMaterial |
| glCullFace |
| glFogf |
| glFogfv |
| glFogi |
| glFogiv |
| glFrontFace |
| glHint |
| glLightf |
| glLightfv |
| glLighti |
| glLightiv |
| glLightModelf |
| glLightModelfv |
| glLightModeli |
| glLightModeliv |
| glLineStipple |
| glLineWidth |
| glMaterialf |
| glMaterialfv |
| glMateriali |
| glMaterialiv |
| glPointSize |
| glPolygonMode |
| glPolygonStipple |
| glScissor |
| glShadeModel |
| glTexParameterf |
| glTexParameterfv |
| glTexParameteri |
| glTexParameteriv |
| glTexImage1D |
| glTexImage2D |
| glTexEnvf |
| glTexEnvfv |
| glTexEnvi |
| glTexEnviv |
| glTexGend |
| glTexGendv |
| glTexGenf |
| glTexGenfv |
| glTexGeni |
| glTexGeniv |
| glFeedbackBuffer |
| glSelectBuffer |
| glRenderMode |
| glInitNames |
| glLoadName |
| glPassThrough |
| glPopName |
| glPushName |
| glDrawBuffer |
| glClear |
| glClearAccum |
| glClearIndex |
| glClearColor |
| glClearStencil |
| glClearDepth |
| glStencilMask |
| glColorMask |
| glDepthMask |
| glIndexMask |
| glAccum |
| glDisable |
| glEnable |
| glFinish |
| glFlush |
| glPopAttrib |
| glPushAttrib |
| glMap1d |
| glMap1f |
| glMap2d |
| glMap2f |
| glMapGrid1d |
| glMapGrid1f |
| glMapGrid2d |
| glMapGrid2f |
| glEvalCoord1d |
| glEvalCoord1dv |
| glEvalCoord1f |
| glEvalCoord1fv |
| glEvalCoord2d |
| glEvalCoord2dv |
| glEvalCoord2f |
| glEvalCoord2fv |
| glEvalMesh1 |
| glEvalPoint1 |
| glEvalMesh2 |
| glEvalPoint2 |
| glAlphaFunc |
| glBlendFunc |
| glLogicOp |
| glStencilFunc |
| glStencilOp |
| glDepthFunc |
| glPixelZoom |
| glPixelTransferf |
| glPixelTransferi |
| glPixelStoref |
| glPixelStorei |
| glPixelMapfv |
| glPixelMapuiv |
| glPixelMapusv |
| glReadBuffer |
| glCopyPixels |
| glReadPixels |
| glDrawPixels |
| glGetBooleanv |
| glGetClipPlane |
| glGetDoublev |
| glGetError |
| glGetFloatv |
| glGetIntegerv |
| glGetLightfv |
| glGetLightiv |
| glGetMapdv |
| glGetMapfv |
| glGetMapiv |
| glGetMaterialfv |
| glGetMaterialiv |
| glGetPixelMapfv |
| glGetPixelMapuiv |
| glGetPixelMapusv |
| glGetPolygonStipple |
| glGetString |
| glGetTexEnvfv |
| glGetTexEnviv |
| glGetTexGendv |
| glGetTexGenfv |
| glGetTexGeniv |
| glGetTexImage |
| glGetTexParameterfv |
| glGetTexParameteriv |
| glGetTexLevelParameterfv |
| glGetTexLevelParameteriv |
| glIsEnabled |
| glIsList |
| glDepthRange |
| glFrustum |
| glLoadIdentity |
| glLoadMatrixf |
| glLoadMatrixd |
| glMatrixMode |
| glMultMatrixf |
| glMultMatrixd |
| glOrtho |
| glPopMatrix |
| glPushMatrix |
| glRotated |
| glRotatef |
| glScaled |
| glScalef |
| glTranslated |
| glTranslatef |
| glViewport |
| glArrayElement |
| glColorPointer |
| glDisableClientState |
| glDrawArrays |
| glDrawElements |
| glEdgeFlagPointer |
| glEnableClientState |
| glGetPointerv |
| glIndexPointer |
| glInterleavedArrays |
| glNormalPointer |
| glTexCoordPointer |
| glVertexPointer |
| glPolygonOffset |
| glCopyTexImage1D |
| glCopyTexImage2D |
| glCopyTexSubImage1D |
| glCopyTexSubImage2D |
| glTexSubImage1D |
| glTexSubImage2D |
| glAreTexturesResident |
| glBindTexture |
| glDeleteTextures |
| glGenTextures |
| glIsTexture |
| glPrioritizeTextures |
| glIndexub |
| glIndexubv |
| glPopClientAttrib |
| glPushClientAttrib |
| glBlendColor |
| glBlendEquation |
| glDrawRangeElements |
| glColorTable |
| glColorTableParameterfv |
| glColorTableParameteriv |
| glCopyColorTable |
| glGetColorTable |
| glGetColorTableParameterfv |
| glGetColorTableParameteriv |
| glColorSubTable |
| glCopyColorSubTable |
| glConvolutionFilter1D |
| glConvolutionFilter2D |
| glConvolutionParameterf |
| glConvolutionParameterfv |
| glConvolutionParameteri |
| glConvolutionParameteriv |
| glCopyConvolutionFilter1D |
| glCopyConvolutionFilter2D |
| glGetConvolutionFilter |
| glGetConvolutionParameterfv |
| glGetConvolutionParameteriv |
| glGetSeparableFilter |
| glSeparableFilter2D |
| glGetHistogram |
| glGetHistogramParameterfv |
| glGetHistogramParameteriv |
| glGetMinmax |
| glGetMinmaxParameterfv |
| glGetMinmaxParameteriv |
| glHistogram |
| glMinmax |
| glResetHistogram |
| glResetMinmax |
| glTexImage3D |
| glTexSubImage3D |
| glCopyTexSubImage3D |
| glActiveTextureARB |
| glClientActiveTextureARB |
| glMultiTexCoord1dARB |
| glMultiTexCoord1dvARB |
| glMultiTexCoord1fARB |
| glMultiTexCoord1fvARB |
| glMultiTexCoord1iARB |
| glMultiTexCoord1ivARB |
| glMultiTexCoord1sARB |
| glMultiTexCoord1svARB |
| glMultiTexCoord2dARB |
| glMultiTexCoord2dvARB |
| glMultiTexCoord2fARB |
| glMultiTexCoord2fvARB |
| glMultiTexCoord2iARB |
| glMultiTexCoord2ivARB |
| glMultiTexCoord2sARB |
| glMultiTexCoord2svARB |
| glMultiTexCoord3dARB |
| glMultiTexCoord3dvARB |
| glMultiTexCoord3fARB |
| glMultiTexCoord3fvARB |
| glMultiTexCoord3iARB |
| glMultiTexCoord3ivARB |
| glMultiTexCoord3sARB |
| glMultiTexCoord3svARB |
| glMultiTexCoord4dARB |
| glMultiTexCoord4dvARB |
| glMultiTexCoord4fARB |
| glMultiTexCoord4fvARB |
| glMultiTexCoord4iARB |
| glMultiTexCoord4ivARB |
| glMultiTexCoord4sARB |
| glMultiTexCoord4svARB |
| glLoadTransposeMatrixfARB |
| glLoadTransposeMatrixdARB |
| glMultTransposeMatrixfARB |
| glMultTransposeMatrixdARB |
| glSampleCoverageARB |
| glCompressedTexImage3DARB |
| glCompressedTexImage2DARB |
| glCompressedTexImage1DARB |
| glCompressedTexSubImage3DARB |
| glCompressedTexSubImage2DARB |
| glCompressedTexSubImage1DARB |
| glGetCompressedTexImageARB |
| glActiveTexture |
| glClientActiveTexture |
| glMultiTexCoord1d |
| glMultiTexCoord1dv |
| glMultiTexCoord1f |
| glMultiTexCoord1fv |
| glMultiTexCoord1i |
| glMultiTexCoord1iv |
| glMultiTexCoord1s |
| glMultiTexCoord1sv |
| glMultiTexCoord2d |
| glMultiTexCoord2dv |
| glMultiTexCoord2f |
| glMultiTexCoord2fv |
| glMultiTexCoord2i |
| glMultiTexCoord2iv |
| glMultiTexCoord2s |
| glMultiTexCoord2sv |
| glMultiTexCoord3d |
| glMultiTexCoord3dv |
| glMultiTexCoord3f |
| glMultiTexCoord3fv |
| glMultiTexCoord3i |
| glMultiTexCoord3iv |
| glMultiTexCoord3s |
| glMultiTexCoord3sv |
| glMultiTexCoord4d |
| glMultiTexCoord4dv |
| glMultiTexCoord4f |
| glMultiTexCoord4fv |
| glMultiTexCoord4i |
| glMultiTexCoord4iv |
| glMultiTexCoord4s |
| glMultiTexCoord4sv |
| glLoadTransposeMatrixf |
| glLoadTransposeMatrixd |
| glMultTransposeMatrixf |
| glMultTransposeMatrixd |
| glSampleCoverage |
| glCompressedTexImage3D |
| glCompressedTexImage2D |
| glCompressedTexImage1D |
| glCompressedTexSubImage3D |
| glCompressedTexSubImage2D |
| glCompressedTexSubImage1D |
| glGetCompressedTexImage |
| glBlendColorEXT |
| glPolygonOffsetEXT |
| glTexImage3DEXT |
| glTexSubImage3DEXT |
| glTexSubImage1DEXT |
| glTexSubImage2DEXT |
| glCopyTexImage1DEXT |
| glCopyTexImage2DEXT |
| glCopyTexSubImage1DEXT |
| glCopyTexSubImage2DEXT |
| glCopyTexSubImage3DEXT |
| glAreTexturesResidentEXT |
| glBindTextureEXT |
| glDeleteTexturesEXT |
| glGenTexturesEXT |
| glIsTextureEXT |
| glPrioritizeTexturesEXT |
| glArrayElementEXT |
| glColorPointerEXT |
| glDrawArraysEXT |
| glEdgeFlagPointerEXT |
| glGetPointervEXT |
| glIndexPointerEXT |
| glNormalPointerEXT |
| glTexCoordPointerEXT |
| glVertexPointerEXT |
| glBlendEquationEXT |
| glPointParameterfEXT |
| glPointParameterfvEXT |
| glPointParameterfARB |
| glPointParameterfvARB |
| glColorTableEXT |
| glGetColorTableEXT |
| glGetColorTableParameterivEXT |
| glGetColorTableParameterfvEXT |
| glLockArraysEXT |
| glUnlockArraysEXT |
| glDrawRangeElementsEXT |
| glSecondaryColor3bEXT |
| glSecondaryColor3bvEXT |
| glSecondaryColor3dEXT |
| glSecondaryColor3dvEXT |
| glSecondaryColor3fEXT |
| glSecondaryColor3fvEXT |
| glSecondaryColor3iEXT |
| glSecondaryColor3ivEXT |
| glSecondaryColor3sEXT |
| glSecondaryColor3svEXT |
| glSecondaryColor3ubEXT |
| glSecondaryColor3ubvEXT |
| glSecondaryColor3uiEXT |
| glSecondaryColor3uivEXT |
| glSecondaryColor3usEXT |
| glSecondaryColor3usvEXT |
| glSecondaryColorPointerEXT |
| glMultiDrawArraysEXT |
| glMultiDrawElementsEXT |
| glFogCoordfEXT |
| glFogCoordfvEXT |
| glFogCoorddEXT |
| glFogCoorddvEXT |
| glFogCoordPointerEXT |
| glBlendFuncSeparateEXT |
| glWindowPos2dMESA |
| glWindowPos2dvMESA |
| glWindowPos2fMESA |
| glWindowPos2fvMESA |
| glWindowPos2iMESA |
| glWindowPos2ivMESA |
| glWindowPos2sMESA |
| glWindowPos2svMESA |
| glWindowPos3dMESA |
| glWindowPos3dvMESA |
| glWindowPos3fMESA |
| glWindowPos3fvMESA |
| glWindowPos3iMESA |
| glWindowPos3ivMESA |
| glWindowPos3sMESA |
| glWindowPos3svMESA |
| glWindowPos4dMESA |
| glWindowPos4dvMESA |
| glWindowPos4fMESA |
| glWindowPos4fvMESA |
| glWindowPos4iMESA |
| glWindowPos4ivMESA |
| glWindowPos4sMESA |
| glWindowPos4svMESA |
| glWindowPos2dARB |
| glWindowPos2fARB |
| glWindowPos2iARB |
| glWindowPos2sARB |
| glWindowPos2dvARB |
| glWindowPos2fvARB |
| glWindowPos2ivARB |
| glWindowPos2svARB |
| glWindowPos3dARB |
| glWindowPos3fARB |
| glWindowPos3iARB |
| glWindowPos3sARB |
| glWindowPos3dvARB |
| glWindowPos3fvARB |
| glWindowPos3ivARB |
| glWindowPos3svARB |
| glAreProgramsResidentNV |
| glBindProgramNV |
| glDeleteProgramsNV |
| glExecuteProgramNV |
| glGenProgramsNV |
| glGetProgramParameterdvNV |
| glGetProgramParameterfvNV |
| glGetProgramivNV |
| glGetProgramStringNV |
| glGetTrackMatrixivNV |
| glGetVertexAttribdvNV |
| glGetVertexAttribfvNV |
| glGetVertexAttribivNV |
| glGetVertexAttribPointervNV |
| glIsProgramNV |
| glLoadProgramNV |
| glProgramParameter4dNV |
| glProgramParameter4dvNV |
| glProgramParameter4fNV |
| glProgramParameter4fvNV |
| glProgramParameters4dvNV |
| glProgramParameters4fvNV |
| glRequestResidentProgramsNV |
| glTrackMatrixNV |
| glVertexAttribPointerNV |
| glVertexAttrib1dNV |
| glVertexAttrib1dvNV |
| glVertexAttrib1fNV |
| glVertexAttrib1fvNV |
| glVertexAttrib1sNV |
| glVertexAttrib1svNV |
| glVertexAttrib2dNV |
| glVertexAttrib2dvNV |
| glVertexAttrib2fNV |
| glVertexAttrib2fvNV |
| glVertexAttrib2sNV |
| glVertexAttrib2svNV |
| glVertexAttrib3dNV |
| glVertexAttrib3dvNV |
| glVertexAttrib3fNV |
| glVertexAttrib3fvNV |
| glVertexAttrib3sNV |
| glVertexAttrib3svNV |
| glVertexAttrib4dNV |
| glVertexAttrib4dvNV |
| glVertexAttrib4fNV |
| glVertexAttrib4fvNV |
| glVertexAttrib4sNV |
| glVertexAttrib4svNV |
| glVertexAttrib4ubNV |
| glVertexAttrib4ubvNV |
| glVertexAttribs1dvNV |
| glVertexAttribs1fvNV |
| glVertexAttribs1svNV |
| glVertexAttribs2dvNV |
| glVertexAttribs2fvNV |
| glVertexAttribs2svNV |
| glVertexAttribs3dvNV |
| glVertexAttribs3fvNV |
| glVertexAttribs3svNV |
| glVertexAttribs4dvNV |
| glVertexAttribs4fvNV |
| glVertexAttribs4svNV |
| glVertexAttribs4ubvNV |
| glPointParameteriNV |
| glPointParameterivNV |
| glFogCoordf |
| glFogCoordfv |
| glFogCoordd |
| glFogCoorddv |
| glFogCoordPointer |
| glMultiDrawArrays |
| glMultiDrawElements |
| glPointParameterf |
| glPointParameterfv |
| glPointParameteri |
| glPointParameteriv |
| glSecondaryColor3b |
| glSecondaryColor3bv |
| glSecondaryColor3d |
| glSecondaryColor3dv |
| glSecondaryColor3f |
| glSecondaryColor3fv |
| glSecondaryColor3i |
| glSecondaryColor3iv |
| glSecondaryColor3s |
| glSecondaryColor3sv |
| glSecondaryColor3ub |
| glSecondaryColor3ubv |
| glSecondaryColor3ui |
| glSecondaryColor3uiv |
| glSecondaryColor3us |
| glSecondaryColor3usv |
| glSecondaryColorPointer |
| glWindowPos2d |
| glWindowPos2dv |
| glWindowPos2f |
| glWindowPos2fv |
| glWindowPos2i |
| glWindowPos2iv |
| glWindowPos2s |
| glWindowPos2sv |
| glWindowPos3d |
| glWindowPos3dv |
| glWindowPos3f |
| glWindowPos3fv |
| glWindowPos3i |
| glWindowPos3iv |
| glWindowPos3s |
| glWindowPos3sv |
| glVertexAttrib1sARB |
| glVertexAttrib1fARB |
| glVertexAttrib1dARB |
| glVertexAttrib2sARB |
| glVertexAttrib2fARB |
| glVertexAttrib2dARB |
| glVertexAttrib3sARB |
| glVertexAttrib3fARB |
| glVertexAttrib3dARB |
| glVertexAttrib4sARB |
| glVertexAttrib4fARB |
| glVertexAttrib4dARB |
| glVertexAttrib4NubARB |
| glVertexAttrib1svARB |
| glVertexAttrib1fvARB |
| glVertexAttrib1dvARB |
| glVertexAttrib2svARB |
| glVertexAttrib2fvARB |
| glVertexAttrib2dvARB |
| glVertexAttrib3svARB |
| glVertexAttrib3fvARB |
| glVertexAttrib3dvARB |
| glVertexAttrib4bvARB |
| glVertexAttrib4svARB |
| glVertexAttrib4ivARB |
| glVertexAttrib4ubvARB |
| glVertexAttrib4usvARB |
| glVertexAttrib4uivARB |
| glVertexAttrib4fvARB |
| glVertexAttrib4dvARB |
| glVertexAttrib4NbvARB |
| glVertexAttrib4NsvARB |
| glVertexAttrib4NivARB |
| glVertexAttrib4NubvARB |
| glVertexAttrib4NusvARB |
| glVertexAttrib4NuivARB |
| glVertexAttribPointerARB |
| glEnableVertexAttribArrayARB |
| glDisableVertexAttribArrayARB |
| glProgramStringARB |
| glBindProgramARB |
| glDeleteProgramsARB |
| glGenProgramsARB |
| glIsProgramARB |
| glProgramEnvParameter4dARB |
| glProgramEnvParameter4dvARB |
| glProgramEnvParameter4fARB |
| glProgramEnvParameter4fvARB |
| glProgramLocalParameter4dARB |
| glProgramLocalParameter4dvARB |
| glProgramLocalParameter4fARB |
| glProgramLocalParameter4fvARB |
| glGetProgramEnvParameterdvARB |
| glGetProgramEnvParameterfvARB |
| glGetProgramLocalParameterdvARB |
| glGetProgramLocalParameterfvARB |
| glGetProgramivARB |
| glGetProgramStringARB |
| glGetVertexAttribdvARB |
| glGetVertexAttribfvARB |
| glGetVertexAttribivARB |
| glGetVertexAttribPointervARB |
| glProgramNamedParameter4fNV |
| glProgramNamedParameter4dNV |
| glProgramNamedParameter4fvNV |
| glProgramNamedParameter4dvNV |
| glGetProgramNamedParameterfvNV |
| glGetProgramNamedParameterdvNV |
| glBindBufferARB |
| glBufferDataARB |
| glBufferSubDataARB |
| glDeleteBuffersARB |
| glGenBuffersARB |
| glGetBufferParameterivARB |
| glGetBufferPointervARB |
| glGetBufferSubDataARB |
| glIsBufferARB |
| glMapBufferARB |
| glUnmapBufferARB |
| glGenQueriesARB |
| glDeleteQueriesARB |
| glIsQueryARB |
| glBeginQueryARB |
| glEndQueryARB |
| glGetQueryivARB |
| glGetQueryObjectivARB |
| glGetQueryObjectuivARB |
| glBindBuffer |
| glBufferData |
| glBufferSubData |
| glDeleteBuffers |
| glGenBuffers |
| glGetBufferParameteriv |
| glGetBufferPointerv |
| glGetBufferSubData |
| glIsBuffer |
| glMapBuffer |
| glUnmapBuffer |
| glGenQueries |
| glDeleteQueries |
| glIsQuery |
| glBeginQuery |
| glEndQuery |
| glGetQueryiv |
| glGetQueryObjectiv |
| glGetQueryObjectuiv |
| ; |
| ; WGL API |
| wglChoosePixelFormat |
| wglCopyContext |
| wglCreateContext |
| wglCreateLayerContext |
| wglDeleteContext |
| wglDescribeLayerPlane |
| wglDescribePixelFormat |
| wglGetCurrentContext |
| wglGetCurrentDC |
| wglGetLayerPaletteEntries |
| wglGetPixelFormat |
| wglGetProcAddress |
| wglMakeCurrent |
| wglRealizeLayerPalette |
| wglSetLayerPaletteEntries |
| wglSetPixelFormat |
| wglShareLists |
| wglSwapBuffers |
| wglSwapLayerBuffers |
| wglUseFontBitmapsA |
| wglUseFontBitmapsW |
| wglUseFontOutlinesA |
| wglUseFontOutlinesW |
| wglGetExtensionsStringARB |
| /contrib/sdk/sources/Mesa/src/mesa/drivers/windows/gdi/wgl.c |
|---|
| 0,0 → 1,689 |
| /* |
| * 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"; |
| } |
| /contrib/sdk/sources/Mesa/src/mesa/drivers/windows/gdi/wmesa.c |
|---|
| 0,0 → 1,793 |
| /* |
| * 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, |
| GLint x, GLint y, |
| GLsizei width, GLsizei height) |
| { |
| 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); |
| } |
| /contrib/sdk/sources/Mesa/src/mesa/drivers/windows/gdi/wmesadef.h |
|---|
| 0,0 → 1,43 |
| #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 */ |