-/* $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 <windows.h>
-#include <gl/gl.h>
+#include <winreg.h>
+
+#include <string.h>
+//#include <GL/gl.h>
#include "opengl32.h"
#define EXPORT __declspec(dllexport)
+#define NAKED __attribute__((naked))
+
+#ifdef DEBUG_OPENGL32
+# define DBGPRINT( fmt, args... ) DbgPrint( "OpenGL32.DLL: "fmt, args )
+#else
+# define DBGPRINT( ... ) do {} while (0)
+#endif
-const char* OPENGL32_funcnames[GLIDX_COUNT] =
+/* 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? */
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.
/* 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;
+}
+
-/* $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
*/
#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,
GLIDX_COUNT
};
+/* function name table */
extern const char* OPENGL32_funcnames[GLIDX_COUNT];
-typedef
-void
-WINAPI
-(*PGLACCUM) (
- GLenum op,
- GLfloat value );
-
-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
+/* FIXME: what type of argument does this take? */
+typedef DWORD (CALLBACK * SetContextCallBack) (void *);
+
+/* OpenGL ICD data */
+typedef struct tagGLDRIVERDATA
+{
+ HMODULE handle; /* DLL handle */
+ UINT refcount; /* number of references to this ICD */
+ WCHAR driver_name[256]; /* name of display driver */
+
+ 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
{
- PGLACCUM glAccum;
- PGLADDSWAPHINTRECTWIN glAddSwapHintRectWIN;
- PGLARRAYELEMENT glArrayElement;
- PGLBEGIN glBegin;
- PGLBINDTEXTURE glBindTexture;
+ GLDRIVERDATA *icd; /* driver used for this context */
+ INT iFormat; /* current pixel format index - ? */
+ HDC hdc; /* DC handle */
+ DWORD threadid; /* thread holding this context */
- PGLEND glEnd;
-} GLFUNCLIST;
+ 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
--- /dev/null
+/*
+ * 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 <windows.h>
+#include <winreg.h>
+
+#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 )
+{
+}
+