From e0cc57149b43bdd65f97c320f29522a17232e03e Mon Sep 17 00:00:00 2001 From: Royce Mitchell III Date: Mon, 2 Feb 2004 05:36:37 +0000 Subject: [PATCH] bunch more groundwork for ICD support - patch by blight svn path=/trunk/; revision=7986 --- reactos/lib/opengl32/Makefile | 3 +- reactos/lib/opengl32/opengl32.c | 317 +++++++++++++++++++++- reactos/lib/opengl32/opengl32.h | 455 ++++++++++++++++++++++++++++---- reactos/lib/opengl32/wgl.c | 187 +++++++++++++ 4 files changed, 898 insertions(+), 64 deletions(-) create mode 100644 reactos/lib/opengl32/wgl.c diff --git a/reactos/lib/opengl32/Makefile b/reactos/lib/opengl32/Makefile index 8debfef80b0..c5ffe3ac5bc 100644 --- a/reactos/lib/opengl32/Makefile +++ b/reactos/lib/opengl32/Makefile @@ -17,7 +17,8 @@ TARGET_LFLAGS = TARGET_SDKLIBS = opengl32.a TARGET_OBJECTS = \ - opengl32.o stubs.o + opengl32.o \ + wgl.o DEP_OBJECTS = $(TARGET_OBJECTS) diff --git a/reactos/lib/opengl32/opengl32.c b/reactos/lib/opengl32/opengl32.c index b56cb2d2e6a..93266197a8b 100644 --- a/reactos/lib/opengl32/opengl32.c +++ b/reactos/lib/opengl32/opengl32.c @@ -1,28 +1,50 @@ -/* $Id: opengl32.c,v 1.3 2004/02/01 17:18:47 royce Exp $ +/* $Id: opengl32.c,v 1.4 2004/02/02 05:36:37 royce Exp $ * * COPYRIGHT: See COPYING in the top level directory * PROJECT: ReactOS kernel * FILE: lib/opengl32/opengl32.c * PURPOSE: OpenGL32 lib - * PROGRAMMER: Anich Gregor (blight) + * PROGRAMMER: Anich Gregor (blight), Royce Mitchell III * UPDATE HISTORY: * Feb 1, 2004: Created */ #define WIN32_LEAN_AND_MEAN #include -#include +#include + +#include +//#include #include "opengl32.h" #define EXPORT __declspec(dllexport) +#define NAKED __attribute__((naked)) -const char* OPENGL32_funcnames[GLIDX_COUNT] = +#ifdef DEBUG_OPENGL32 +# define DBGPRINT( fmt, args... ) DbgPrint( "OpenGL32.DLL: "fmt, args ) +#else +# define DBGPRINT( ... ) do {} while (0) +#endif + +/* function prototypes */ +static void OPENGL32_AppendICD( GLDRIVERDATA *icd ); +static void OPENGL32_RemoveICD( GLDRIVERDATA *icd ); +static GLDRIVERDATA *OPENGL32_LoadDriverW( LPCWSTR regKey ); +static DWORD OPENGL32_InitializeDriver( GLDRIVERDATA *icd ); +static BOOL OPENGL32_UnloadDriver( GLDRIVERDATA *icd ); + +/* global vars */ +const char* OPENGL32_funcnames[GLIDX_COUNT] + __attribute__((section("shared"), shared)) = { #define X(X) #X, GLFUNCS_MACRO #undef X }; +GLPROCESSDATA OPENGL32_processdata; + + static void OPENGL32_ThreadDetach() { /* FIXME - do we need to release some HDC or something? */ @@ -31,24 +53,24 @@ static void OPENGL32_ThreadDetach() LocalFree((HLOCAL) lpvData ); } + BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD Reason, LPVOID Reserved) { GLTHREADDATA* lpData = NULL; - printf("OpenGL32.DLL DllMain called!\n"); + DBGPRINT( "DllMain called!\n" ); switch ( Reason ) { - /* The DLL is loading due to process + /* The DLL is loading due to process * initialization or a call to LoadLibrary. */ case DLL_PROCESS_ATTACH: OPENGL32_tls = TlsAlloc(); if ( 0xFFFFFFFF == OPENGL32_tls ) return FALSE; - OPENGL32_processdata.funclist_count = 1; - OPENGL32_processdata.list = malloc ( sizeof(GLFUNCLIST*) * OPENGL32_processdata.funclist_count ); - OPENGL32_processdata.list[0] = malloc ( sizeof(GLFUNCLIST) ); - memset ( OPENGL32_processdata.list[0], 0, sizeof(GLFUNCLIST) ); + + memset( &OPENGL32_processdata, 0, sizeof (OPENGL32_processdata) ); + /* FIXME - load mesa32 into first funclist */ /* FIXME - get list of ICDs from registry */ // No break: Initialize the index for first thread. @@ -75,9 +97,284 @@ BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD Reason, LPVOID Reserved) /* DLL unload due to process termination or FreeLibrary. */ case DLL_PROCESS_DETACH: OPENGL32_ThreadDetach(); + /* FIXME: free resources */ TlsFree(OPENGL32_tls); break; } return TRUE; } + +/* FUNCTION: Append ICD to linked list. + * ARGUMENTS: [IN] icd: GLDRIVERDATA to append to list + * TODO: protect from race conditions + */ +static void OPENGL32_AppendICD( GLDRIVERDATA *icd ) +{ + if (!OPENGL32_processdata.driver_list) + OPENGL32_processdata.driver_list = icd; + else + { + GLDRIVERDATA *p = OPENGL32_processdata.driver_list; + while (p->next) + p = p->next; + p->next = icd; + } +} + + +/* FUNCTION: Remove ICD from linked list. + * ARGUMENTS: [IN] icd: GLDRIVERDATA to remove from list + * TODO: protect from race conditions + */ +static void OPENGL32_RemoveICD( GLDRIVERDATA *icd ) +{ + if (icd == OPENGL32_processdata.driver_list) + OPENGL32_processdata.driver_list = icd->next; + else + { + GLDRIVERDATA *p = OPENGL32_processdata.driver_list; + while (p) + { + if (p->next == icd) + { + p->next = icd->next; + return; + } + p = p->next; + } + DBGPRINT( "RemoveICD: ICD 0x%08x not found in list!\n" ); + } +} + + +static BOOL OPENGL32_LoadDrivers() +{ +} + +/* FUNCTION: Load an ICD. + * ARGUMENTS: [IN] driver: Name of display driver. + * RETURNS: error code; ERROR_SUCCESS on success + * + * TODO: call SetLastError() where appropriate + */ +static GLDRIVERDATA *OPENGL32_LoadDriverW( LPCWSTR driver ) +{ + HKEY hKey; + WCHAR subKey[1024] = L"SOFTWARE\\Microsoft\\Windows NT\\" + "CurrentVersion\\OpenGLDrivers\\"); + LONG ret; + DWORD type, size; + + DWORD version, driverVersion, flags; /* registry values */ + WCHAR dll[256]; + GLDRIVERDATA *icd; + + DBGPRINT( "Loading driver %ws...\n", driver ); + + /* open registry key */ + wcsncat( subKey, driver, 1024 ); + ret = RegOpenKeyExW( HKEY_LOCAL_MACHINE, subKey, 0, KEY_READ, &hKey ); + if (ret != ERROR_SUCCESS) + { + DBGPRINT( "Error: Couldn't open registry key '%ws'\n", subKey ); + return 0; + } + + /* query values */ + size = sizeof (dll); + ret = RegQueryValueExW( hKey, L"Dll", 0, &type, dll, &size ); + if (ret != ERROR_SUCCESS || type != REG_SZ) + { + DBGPRINT( "Error: Couldn't query Dll value or not a string\n" ); + RegCloseKey( hKey ); + return 0; + } + + size = sizeof (DWORD); + ret = RegQueryValueExW( hKey, L"Version", 0, &type, &version, &size ); + if (ret != ERROR_SUCCESS || type != REG_DWORD) + { + DBGPRINT( "Warning: Couldn't query Version value or not a DWORD\n" ); + version = 0; + } + + size = sizeof (DWORD); + ret = RegQueryValueExW( hKey, L"DriverVersion", 0, &type, + &driverVersion, &size ); + if (ret != ERROR_SUCCESS || type != REG_DWORD) + { + DBGPRINT( "Warning: Couldn't query DriverVersion value or not a DWORD\n" ); + driverVersion = 0; + } + + size = sizeof (DWORD); + ret = RegQueryValueExW( hKey, L"Flags", 0, &type, &flags, &size ); + if (ret != ERROR_SUCCESS || type != REG_DWORD) + { + DBGPRINT( "Warning: Couldn't query Flags value or not a DWORD\n" ); + flags = 0; + } + + /* close key */ + RegCloseKey( hKey ); + + DBGPRINT( "Dll = %ws\n", dll ); + DBGPRINT( "Version = 0x%08x\n", version ); + DBGPRINT( "DriverVersion = 0x%08x\n", driverVersion ); + DBGPRINT( "Flags = 0x%08x\n", flags ); + + /* allocate driver data */ + icd = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof (GLDRIVERDATA) ); + if (!icd) + { + DBGPRINT( "Error: Couldnt allocate GLDRIVERDATA!\n" ); + return 0; + } + wcsncpy( icd->driver_name, driver, 256 ); + wcsncpy( icd->dll, dll, 256 ); + icd->version = version; + icd->driver_version = driverVersion; + icd->flags = flags; + + /* load ICD */ + ret = OPENGL32_InitializeDriver( icd ); + if (ret != ERROR_SUCCESS) + { + if (!HeapFree( GetProcessHeap(), 0, icd )) + DBGPRINT( "Error: HeapFree() returned false, error code = %d\n", + GetLastError() ); + DBGPRINT( "Error: Couldnt initialize ICD!\n" ); + return 0; + } + + /* append ICD to list */ + OPENGL32_AppendICD( icd ); + DBGPRINT( "ICD loaded.\n" ); + + return icd; +} + + +/* FUNCTION: Initialize a driver (Load DLL, DrvXXX and glXXX procs) + * ARGUMENTS: [IN] icd: ICD to initialize with the dll, version, driverVersion + * and flags already filled. + * RETURNS: error code; ERROR_SUCCESS on success + */ +#define LOAD_DRV_PROC( icd, proc, required ) \ + icd->proc = GetProcAddress( icd->handle, #proc ); \ + if (required && !icd->proc) { \ + DBGPRINT( "Error: GetProcAddress(\"%s\") failed!", #proc ); \ + return GetLastError(); \ + } + +static DWORD OPENGL32_InitializeDriver( GLDRIVERDATA *icd ) +{ + UINT i; + + /* load dll */ + icd->handle = LoadLibraryW( dll ); + if (!icd->handle) + { + DBGPRINT( "Error: Couldn't load DLL! (%d)\n", GetLastError() ); + return GetLastError(); + } + + /* load DrvXXX procs */ + LOAD_DRV_PROC(icd, DrvCopyContext, TRUE); + LOAD_DRV_PROC(icd, DrvCreateContext, TRUE); + LOAD_DRV_PROC(icd, DrvCreateLayerContext, TRUE); + LOAD_DRV_PROC(icd, DrvDeleteContext, TRUE); + LOAD_DRV_PROC(icd, DrvDescribeLayerPlane, TRUE); + LOAD_DRV_PROC(icd, DrvDescribePixelFormat, TRUE); + LOAD_DRV_PROC(icd, DrvGetLayerPaletteEntries, TRUE); + LOAD_DRV_PROC(icd, DrvGetProcAddress, TRUE); + LOAD_DRV_PROC(icd, DrvReleaseContext, TRUE); + LOAD_DRV_PROC(icd, DrvRealizeLayerPalette, TRUE); + LOAD_DRV_PROC(icd, DrvSetContext, TRUE); + LOAD_DRV_PROC(icd, DrvSetLayerPaletteEntries, TRUE); + LOAD_DRV_PROC(icd, DrvSetPixelFormat, TRUE); + LOAD_DRV_PROC(icd, DrvShareLists, TRUE); + LOAD_DRV_PROC(icd, DrvSwapBuffers, TRUE); + LOAD_DRV_PROC(icd, DrvSwapLayerBuffers, TRUE); + LOAD_DRV_PROC(icd, DrvValidateVersion, TRUE); + + /* now load the glXXX functions */ + for (i = 0; i < GLIDX_COUNT; i++) + { + icd->func_list[i] = icd->DrvGetProcAddress( OPENGL32_funcnames[i] ); +#ifdef DEBUG_OPENGL32_ICD_EXPORTS + if ( icd->func_list[i] ) + { + DBGPRINT( "Found function %s in ICD.\n", OPENGL32_funcnames[i] ); + } +#endif + } + + return ERROR_SUCCESS; +} + + +/* FUNCTION: Unload loaded ICD. + * RETURNS: TRUE on success, FALSE otherwise. + */ +static BOOL OPENGL32_UnloadDriver( GLDRIVERDATA *icd ) +{ + BOOL allOk = TRUE; + + DBGPRINT( "Unloading driver %ws...\n", icd->driver_name ); + if (icd->refcount) + DBGPRINT( "Warning: ICD refcount = %d (should be 0)\n", icd->refcount ); + + /* unload dll */ + if (!FreeLibrary( icd->handle )) + { + allOk = FALSE; + DBGPRINT( "Warning: FreeLibrary on ICD %ws failed!\n", icd->dll ); + } + + /* free resources */ + OPENGL32_RemoveICD( icd ); + HeapFree( GetProcessHeap(), 0, icd ); + + return allOk; +} + + +/* FUNCTION: Load ICD (shared ICD data) + * RETURNS: GLDRIVERDATA pointer on success, NULL otherwise. + */ +GLDRIVERDATA *OPENGL32_LoadICDW( LPCWSTR driver ) +{ + GLDRIVERDATA *icd; + + /* look if ICD is already loaded */ + for (icd = OPENGL32_processdata.driver_list; icd; icd = icd->next) + { + if (!_wcsicmp( driver, icd->driver_name )) /* found */ + { + icd->refcount++; + return icd; + } + } + + /* not found - try to load */ + icd = OPENGL32_LoadDriverW( driver ); + if (icd) + icd->refcount = 1; + return icd; +} + + +/* FUNCTION: Unload ICD (shared ICD data) + * RETURNS: TRUE on success, FALSE otherwise. + */ +BOOL OPENGL32_UnloadICD( GLDRIVERDATA *icd ) +{ + icd->refcount--; + if (icd->refcount == 0) + return OPENGL32_UnloadDriver( icd ); + + return TRUE; +} + diff --git a/reactos/lib/opengl32/opengl32.h b/reactos/lib/opengl32/opengl32.h index 0f3be5bd5fb..b855f158453 100644 --- a/reactos/lib/opengl32/opengl32.h +++ b/reactos/lib/opengl32/opengl32.h @@ -1,10 +1,10 @@ -/* $Id: opengl32.h,v 1.3 2004/02/01 17:18:48 royce Exp $ +/* $Id: opengl32.h,v 1.4 2004/02/02 05:36:37 royce Exp $ * * COPYRIGHT: See COPYING in the top level directory * PROJECT: ReactOS kernel * FILE: lib/opengl32/opengl32.h * PURPOSE: OpenGL32 lib - * PROGRAMMER: Royce Mitchell III + * PROGRAMMER: Royce Mitchell III, Anich Gregor (blight) * UPDATE HISTORY: * Feb 1, 2004: Created */ @@ -12,13 +12,353 @@ #ifndef OPENGL32_PRIVATE_H #define OPENGL32_PRIVATE_H +/* debug flags */ +#define DEBUG_OPENGL32 +#define DEBUG_OPENGL32_ICD_EXPORTS /* dumps the list of supported glXXX + functions when an ICD is loaded. */ + +/* gl function list */ #define GLFUNCS_MACRO \ X(glAccum) \ X(glAddSwapHintRectWIN) \ + X(glAlphaFunc) \ + X(glAreTexturesResident) \ X(glArrayElement) \ X(glBegin) \ - X(glBindTexture) + X(glBindTexture) \ + X(glBitmap) \ + X(glBlendFunc) \ + X(glCallList) \ + X(glCallLists) \ + X(glClear) \ + X(glClearAccum) \ + X(glClearColor) \ + X(glClearDepth) \ + X(glClearIndex) \ + X(glClearStencil) \ + X(glClipPlane) \ + X(glColor3b) \ + X(glColor3bv) \ + X(glColor3d) \ + X(glColor3dv) \ + X(glColor3f) \ + X(glColor3fv) \ + X(glColor3i) \ + X(glColor3iv) \ + X(glColor3s) \ + X(glColor3sv) \ + X(glColor3ub) \ + X(glColor3ubv) \ + X(glColor3ui) \ + X(glColor3uiv) \ + X(glColor3us) \ + X(glColor3usv) \ + X(glColor4b) \ + X(glColor4bv) \ + X(glColor4d) \ + X(glColor4dv) \ + X(glColor4f) \ + X(glColor4fv) \ + X(glColor4i) \ + X(glColor4iv) \ + X(glColor4s) \ + X(glColor4sv) \ + X(glColor4ub) \ + X(glColor4ubv) \ + X(glColor4ui) \ + X(glColor4uiv) \ + X(glColor4us) \ + X(glColor4usv) \ + X(glColorMask) \ + X(glColorMaterial) \ + X(glColorPointer) \ + X(glCopyPixels) \ + X(glCopyTexImage1D) \ + X(glCopyTexImage2D) \ + X(glCopyTexSubImage1D) \ + X(glCopyTexSubImage2D) \ + X(glCullFace) \ + X(glDebugEntry) \ + X(glDeleteLists) \ + X(glDeleteTextures) \ + X(glDepthFunc) \ + X(glDepthMask) \ + X(glDepthRange) \ + X(glDisable) \ + X(glDisableClientState) \ + X(glDrawArrays) \ + X(glDrawBuffer) \ + X(glDrawElements) \ + X(glDrawPixels) \ + X(glEdgeFlag) \ + X(glEdgeFlagPointer) \ + X(glEdgeFlagv) \ + X(glEnable) \ + X(glEnableClientState) \ + X(glEnd) \ + X(glEndList) \ + X(glEvalCoord1d) \ + X(glEvalCoord1dv) \ + X(glEvalCoord1f) \ + X(glEvalCoord1fv) \ + X(glEvalCoord2d) \ + X(glEvalCoord2dv) \ + X(glEvalCoord2f) \ + X(glEvalCoord2fv) \ + X(glEvalMesh1) \ + X(glEvalMesh2) \ + X(glEvalPoint1) \ + X(glEvalPoint2) \ + X(glFeedbackBuffer) \ + X(glFinish) \ + X(glFlush) \ + X(glFogf) \ + X(glFogfv) \ + X(glFogi) \ + X(glFogiv) \ + X(glFrontFace) \ + X(glFrustum) \ + X(glGenLists) \ + X(glGenTextures) \ + X(glGetBooleanv) \ + X(glGetClipPlane) \ + X(glGetDoublev) \ + X(glGetError) \ + X(glGetFloatv) \ + X(glGetIntegerv) \ + X(glGetLightfv) \ + X(glGetLightiv) \ + X(glGetMapdv) \ + X(glGetMapfv) \ + X(glGetMapiv) \ + X(glGetMaterialfv) \ + X(glGetMaterialiv) \ + X(glGetPixelMapfv) \ + X(glGetPixelMapuiv) \ + X(glGetPixelMapusv) \ + X(glGetPointerv) \ + X(glGetPolygonStipple) \ + X(glGetString) \ + X(glGetTexEnvfv) \ + X(glGetTexEnviv) \ + X(glGetTexGendv) \ + X(glGetTexGenfv) \ + X(glGetTexGeniv) \ + X(glGetTexImage) \ + X(glGetTexLevelParameterfv) \ + X(glGetTexLevelParameteriv) \ + X(glGetTexParameterfv) \ + X(glGetTexParameteriv) \ + X(glHint) \ + X(glIndexd) \ + X(glIndexdv) \ + X(glIndexf) \ + X(glIndexfv) \ + X(glIndexi) \ + X(glIndexiv) \ + X(glIndexMask) \ + X(glIndexPointer) \ + X(glIndexs) \ + X(glIndexsv) \ + X(glIndexub) \ + X(glIndexubv) \ + X(glInitNames) \ + X(glInterleavedArrays) \ + X(glIsEnabled) \ + X(glIsList) \ + X(glIsTexture) \ + X(glLightf) \ + X(glLightfv) \ + X(glLighti) \ + X(glLightiv) \ + X(glLightModelf) \ + X(glLightModelfv) \ + X(glLightModeli) \ + X(glLightModeliv) \ + X(glLineStipple) \ + X(glLineWidth) \ + X(glListBase) \ + X(glLoadIdentity) \ + X(glLoadMatrixd) \ + X(glLoadMatrixf) \ + X(glLoadName) \ + X(glLogicOp) \ + X(glMap1d) \ + X(glMap1f) \ + X(glMap2d) \ + X(glMap2f) \ + X(glMapGrid1d) \ + X(glMapGrid1f) \ + X(glMapGrid2d) \ + X(glMapGrid2f) \ + X(glMaterialf) \ + X(glMaterialfv) \ + X(glMateriali) \ + X(glMaterialiv) \ + X(glMatrixMode) \ + X(glMultMatrixd) \ + X(glMultMatrixf) \ + X(glNewList) \ + X(glNormal3b) \ + X(glNormal3bv) \ + X(glNormal3d) \ + X(glNormal3dv) \ + X(glNormal3f) \ + X(glNormal3fv) \ + X(glNormal3i) \ + X(glNormal3iv) \ + X(glNormal3s) \ + X(glNormal3sv) \ + X(glNormalPointer) \ + X(glOrtho) \ + X(glPassThrough) \ + X(glPixelMapfv) \ + X(glPixelMapuiv) \ + X(glPixelMapusv) \ + X(glPixelStoref) \ + X(glPixelStorei) \ + X(glPixelTransferf) \ + X(glPixelTransferi) \ + X(glPixelZoom) \ + X(glPointSize) \ + X(glPolygonMode) \ + X(glPolygonOffset) \ + X(glPolygonStipple) \ + X(glPopAttrib) \ + X(glPopClientAttrib) \ + X(glPopMatrix) \ + X(glPopName) \ + X(glPrioritizeTextures) \ + X(glPushAttrib) \ + X(glPushClientAttrib) \ + X(glPushMatrix) \ + X(glPushName) \ + X(glRasterPos2d) \ + X(glRasterPos2dv) \ + X(glRasterPos2f) \ + X(glRasterPos2fv) \ + X(glRasterPos2i) \ + X(glRasterPos2iv) \ + X(glRasterPos2s) \ + X(glRasterPos2sv) \ + X(glRasterPos3d) \ + X(glRasterPos3dv) \ + X(glRasterPos3f) \ + X(glRasterPos3fv) \ + X(glRasterPos3i) \ + X(glRasterPos3iv) \ + X(glRasterPos3s) \ + X(glRasterPos3sv) \ + X(glRasterPos4d) \ + X(glRasterPos4dv) \ + X(glRasterPos4f) \ + X(glRasterPos4fv) \ + X(glRasterPos4i) \ + X(glRasterPos4iv) \ + X(glRasterPos4s) \ + X(glRasterPos4sv) \ + X(glReadBuffer) \ + X(glReadPixels) \ + X(glRectd) \ + X(glRectdv) \ + X(glRectf) \ + X(glRectfv) \ + X(glRecti) \ + X(glRectiv) \ + X(glRects) \ + X(glRectsv) \ + X(glRenderMode) \ + X(glRotated) \ + X(glRotatef) \ + X(glScaled) \ + X(glScalef) \ + X(glScissor) \ + X(glSelectBuffer) \ + X(glShadeModel) \ + X(glStencilFunc) \ + X(glStencilMask) \ + X(glStencilOp) \ + X(glTexCoord1d) \ + X(glTexCoord1dv) \ + X(glTexCoord1f) \ + X(glTexCoord1fv) \ + X(glTexCoord1i) \ + X(glTexCoord1iv) \ + X(glTexCoord1s) \ + X(glTexCoord1sv) \ + X(glTexCoord2d) \ + X(glTexCoord2dv) \ + X(glTexCoord2f) \ + X(glTexCoord2fv) \ + X(glTexCoord2i) \ + X(glTexCoord2iv) \ + X(glTexCoord2s) \ + X(glTexCoord2sv) \ + X(glTexCoord3d) \ + X(glTexCoord3dv) \ + X(glTexCoord3f) \ + X(glTexCoord3fv) \ + X(glTexCoord3i) \ + X(glTexCoord3iv) \ + X(glTexCoord3s) \ + X(glTexCoord3sv) \ + X(glTexCoord4d) \ + X(glTexCoord4dv) \ + X(glTexCoord4f) \ + X(glTexCoord4fv) \ + X(glTexCoord4i) \ + X(glTexCoord4iv) \ + X(glTexCoord4s) \ + X(glTexCoord4sv) \ + X(glTexCoordPointer) \ + X(glTexEnvf) \ + X(glTexEnvfv) \ + X(glTexEnvi) \ + X(glTexEnviv) \ + X(glTexGend) \ + X(glTexGendv) \ + X(glTexGenf) \ + X(glTexGenfv) \ + X(glTexGeni) \ + X(glTexGeniv) \ + X(glTexImage1D) \ + X(glTexImage2D) \ + X(glTexParameterf) \ + X(glTexParameterfv) \ + X(glTexParameteri) \ + X(glTexParameteriv) \ + X(glTexSubImage1D) \ + X(glTexSubImage2D) \ + X(glTranslated) \ + X(glTranslatef) \ + X(glVertex2d) \ + X(glVertex2dv) \ + X(glVertex2f) \ + X(glVertex2fv) \ + X(glVertex2i) \ + X(glVertex2iv) \ + X(glVertex2s) \ + X(glVertex2sv) \ + X(glVertex3d) \ + X(glVertex3dv) \ + X(glVertex3f) \ + X(glVertex3fv) \ + X(glVertex3i) \ + X(glVertex3iv) \ + X(glVertex3s) \ + X(glVertex3sv) \ + X(glVertex4d) \ + X(glVertex4dv) \ + X(glVertex4f) \ + X(glVertex4fv) \ + X(glVertex4i) \ + X(glVertex4iv) \ + X(glVertex4s) \ + X(glVertex4sv) \ + X(glVertexPointer) \ + X(glViewport) +/* table indices for funcnames and function pointers */ enum glfunc_indices { GLIDX_INVALID = -1, @@ -28,70 +368,79 @@ enum glfunc_indices GLIDX_COUNT }; +/* function name table */ extern const char* OPENGL32_funcnames[GLIDX_COUNT]; -typedef -void -WINAPI -(*PGLACCUM) ( - GLenum op, - GLfloat value ); +/* FIXME: what type of argument does this take? */ +typedef DWORD (CALLBACK * SetContextCallBack) (void *); -typedef -void -WINAPI -(*PGLADDSWAPHINTRECTWIN) ( - GLint x, - GLint y, - GLsizei width, - GLsizei height ); - -typedef -void -WINAPI -(*PGLARRAYELEMENT) ( GLint index ); - -typedef -void -WINAPI -(*PGLBEGIN) ( GLenum mode ); - -typedef -void -WINAPI -(*PGLBINDTEXTURE) ( GLenum target, GLuint texture ) - - -typedef -void -WINAPI -(*PGLEND) ( void ); - -typedef struct tagGLFUNCLIST +/* OpenGL ICD data */ +typedef struct tagGLDRIVERDATA { - PGLACCUM glAccum; - PGLADDSWAPHINTRECTWIN glAddSwapHintRectWIN; - PGLARRAYELEMENT glArrayElement; - PGLBEGIN glBegin; - PGLBINDTEXTURE glBindTexture; + HMODULE handle; /* DLL handle */ + UINT refcount; /* number of references to this ICD */ + WCHAR driver_name[256]; /* name of display driver */ - PGLEND glEnd; -} GLFUNCLIST; + WCHAR dll[256]; /* Dll value from registry */ + DWORD version; /* Version value from registry */ + DWORD driver_version; /* DriverVersion value from registry */ + DWORD flags; /* Flags value from registry */ + BOOL (*DrvCopyContext)( HGLRC, HGLRC, UINT ); + HGLRC (*DrvCreateContext)( HDC ); + HGLRC (*DrvCreateLayerContext)( HDC, int ); + BOOL (*DrvDeleteContext)( HGLRC ); + BOOL (*DrvDescribeLayerPlane)( HDC, int, int, UINT, LPLAYERPLANEDESCRIPTOR ); + int (*DrvDescribePixelFormat)( IN HDC, IN int, IN UINT, OUT LPPIXELFORMATDESCRIPTOR ); + int (*DrvGetLayerPaletteEntries)( HDC, int, int, int, COLORREF * ) + FARPROC (*DrvGetProcAddress)( LPCSTR lpProcName ); + void (*DrvReleaseContext)(); + BOOL (*DrvRealizeLayerPalette)( HDC, int, BOOL ) + int (*DrvSetContext)( HDC hdc, HGLRC hglrc, SetContextCallBack callback ) + int (*DrvSetLayerPaletteEntries)( HDC, int, int, int, CONST COLORREF * ) + BOOL (*DrvSetPixelFormat)( IN HDC, IN int, IN CONST PIXELFORMATDESCRIPTOR * ) + BOOL (*DrvShareLists)( HGLRC, HGLRC ) + BOOL (*DrvSwapBuffers)( HDC ) + BOOL (*DrvSwapLayerBuffers)( HDC, UINT ) + void (*DrvValidateVersion)(); + + PVOID func_list[GLIDX_COUNT]; /* glXXX functions supported by ICD */ + + struct tagGLDRIVERDATA *next; /* next ICD -- linked list */ +} GLDRIVERDATA; + +/* OpenGL context */ +typedef struct tagGLRC +{ + GLDRIVERDATA *icd; /* driver used for this context */ + INT iFormat; /* current pixel format index - ? */ + HDC hdc; /* DC handle */ + DWORD threadid; /* thread holding this context */ + + HGLRC hglrc; /* GLRC from DrvCreateContext */ + PVOID func_list[GLIDX_COUNT]; /* glXXX function pointers */ + + struct tagGLRC *next; /* linked list */ +} GLRC; + +/* Process data */ typedef struct tagGLPROCESSDATA { - int funclist_count; - GLFUNCLIST* lists; // array of GLFUNCLIST pointers + GLDRIVERDATA *driver_list; /* list of loaded drivers */ + GLRC *glrc_list; /* list of GL rendering contexts */ } GLPROCESSDATA; +/* TLS data */ typedef struct tagGLTHREADDATA { - HDC hdc; // current HDC - GLFUNCLIST* list; // *current* func list - /* FIXME - what else do we need here? */ -}; GLTHREADDATA; + GLRC *hglrc; /* current GL rendering context */ +} GLTHREADDATA; extern DWORD OPENGL32_tls; extern GLPROCESSDATA OPENGL32_processdata; +/* function prototypes */ +GLDRIVERDATA *OPENGL32_LoadICDW( LPCWSTR driver ); +BOOL OPENGL32_UnloadICD( GLDRIVERDATA *icd ); + #endif//OPENGL32_PRIVATE_H diff --git a/reactos/lib/opengl32/wgl.c b/reactos/lib/opengl32/wgl.c new file mode 100644 index 00000000000..2684e15be8b --- /dev/null +++ b/reactos/lib/opengl32/wgl.c @@ -0,0 +1,187 @@ +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS kernel + * FILE: lib/opengl32/wgl.c + * PURPOSE: OpenGL32 lib, wglXXX functions + * PROGRAMMER: Anich Gregor (blight) + * UPDATE HISTORY: + * Feb 2, 2004: Created + */ + +#define WIN32_LEAN_AND_MEAN +#include +#include + +#include "opengl32.h" + + +BOOL wglCopyContext( HGLRC src, HGLRC dst, UINT mask ) +{ +} + + +HGLRC wglCreateContext( HDC hdc ) +{ + return wglCreateLayerContext( hdc, 0 ); +} + + +HGLRC wglCreateLayerContext( HDC hdc, int layer ) +{ + HKEY hKey; + WCHAR subKey[1024] = L"SOFTWARE\\Microsoft\\Windows NT\\" + "CurrentVersion\\OpenGLDrivers"); + LONG ret; + WCHAR driver[256]; + DWORD size; + DWORD dw; + FILETIME time; + + GLDRIVERDATA *icd; + GLRC *hglrc, *drvHglrc = NULL; + + if (GetObjectType( hdc ) != OBJ_DC) + { + DBGPRINT( "Wrong object type" ); + return NULL; + } + + /* find out which icd to load */ + ret = RegOpenKeyExW( HKEY_LOCAL_MACHINE, subKey, 0, KEY_READ, &hKey ); + if (ret != ERROR_SUCCESS) + { + DBGPRINT( "Error: Couldn't open registry key '%ws'\n", subKey ); + return FALSE; + } + + /* allocate our GLRC */ + hglrc = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof (GLRC) ); + if (!hglrc) + return NULL; + + for (dw = 0; ; dw++) + { + size = 256; + ret = RegEnumKeyExW( hKey, dw, driver, &size, NULL, NULL, NULL, &time ); + if (ret != ERROR_SUCCESS ) + break; + + icd = OPENGL32_LoadICDW( driver ); + if (!icd) + continue; + + drvHglrc = icd->DrvCreateLayerContext( hdc, layer ); + if (!drvHglrc) + { + DBGPRINT( "Info: DrvCreateLayerContext (driver = %ws) failed: %d\n", + icd->driver_name, GetLastError() ); + OPENGL32_UnloadICD( icd ); + continue; + } + + /* the ICD was loaded successfully and we got a HGLRC -- success! */ + break; + } + RegCloseKey( hKey ); + + if (!drvHglrc) + { + /* FIXME: fallback to mesa */ + HeapFree( GetProcessHeap(), 0, hglrc ); + return NULL; + } + + /* we have our GLRC in hglrc and the ICDs in drvHglrc */ + hglrc->hglrc = drcHglrc; + hglrc->iFormat = -1; /* what is this used for? */ + hglrc->icd = icd; + hglrc->threadid = 0xFFFFFFFF; /* TODO: make sure this is the "invalid" value */ + memcpy( hglrc->func_list, icd->func_list, sizeof (PVOID) * GLIDX_COUNT ); + + /* FIXME: fill NULL-pointers in hglrc->func_list with mesa functions */ + + /* FIXME: append hglrc to process-local list of contexts */ +} + + +BOOL wglDeleteContext( HGLRC hglrc ) +{ +} + + +BOOL wglDescribeLayerPlane( HDC hdc, int iPixelFormat, int iLayerPlane, + UINT nBytes, LPLAYERPLANEDESCRIPTOR plpd ) +{ +} + + +HGLRC wglGetCurrentContext() +{ +} + + +HDC wglGetCurrentDC() +{ +} + + +int wglGetLayerPaletteEntries( HDC hdc, int iLayerPlane, int iStart, + int cEntries, CONST COLORREF *pcr ) +{ +} + + +PROC wglGetProcAddress( LPCSTR proc ) +{ +} + + +BOOL wglMakeCurrent( HDC hdc, HGLRC hglrc ) +{ +} + + +BOOL wglRealizeLayerPalette( HDC hdc, int iLayerPlane, BOOL bRealize ) +{ +} + + +int wglSetLayerPaletteEntries( HDC hdc, int iLayerPlane, int iStart, + int cEntries, CONST COLORREF *pcr ) +{ +} + + +BOOL wglShareLists( HGLRC hglrc1, HGLRC hglrc2 ) +{ +} + + +BOOL wglSwapLayerBuffers( HDC hdc, UINT fuPlanes ) +{ +} + + +BOOL wglUseFontBitmapsA( HDC hdc, DWORD first, DWORD count, DWORD listBase ) +{ +} + + +BOOL wglUseFontBitmapsW( HDC hdc, DWORD first, DWORD count, DWORD listBase ) +{ +} + + +BOOL wglUseFontOutlinesA( HDC hdc, DWORD first, DWORD count, DWORD listBase, + FLOAT deviation, FLOAT extrusion, int format, + LPGLYPHMETRICSFLOAT lpgmf ) +{ +} + + +BOOL wglUseFontOutlinesW( HDC hdc, DWORD first, DWORD count, DWORD listBase, + FLOAT deviation, FLOAT extrusion, int format, + LPGLYPHMETRICSFLOAT lpgmf ) +{ +} +