yquake2/yquake2remaster
0
0
Fork 0
mirror of https://github.com/yquake2/yquake2remaster.git synced 2025-02-16 17:11:03 +00:00
Code Issues Projects Releases Packages Wiki Activity

Combine qgl.c glwindow.h into one generic file

Browse source
This commit is contained in:
Yamagi Burmeister 2012-08-01 15:51:39 +02:00
parent e5f70fcf40
commit f89bb3265e
11 changed files with 374 additions and 5203 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
Makefile
View file

@ -580,6 +580,7 @@ endif
# Used by the OpenGL refresher # Used by the OpenGL refresher
OPENGL_OBJS_ = \ OPENGL_OBJS_ = \
src/backends/generic/qgl.o \
src/backends/sdl/input.o \ src/backends/sdl/input.o \
src/backends/sdl/refresh.o \ src/backends/sdl/refresh.o \
src/refresh/r_draw.o \ src/refresh/r_draw.o \
@ -604,12 +605,10 @@ OPENGL_OBJS_ = \
ifeq ($(OSTYPE), Windows) ifeq ($(OSTYPE), Windows)
OPENGL_OBJS_ += \ OPENGL_OBJS_ += \
src/backends/windows/mem.o \ src/backends/windows/mem.o
src/backends/windows/qgl.o
else else
OPENGL_OBJS_ += \ OPENGL_OBJS_ += \
src/backends/unix/hunk.o \ src/backends/unix/hunk.o
src/backends/unix/qgl.o
endif endif
# ---------- # ----------

12
src/backends/unix/header/glwindow.h → src/backends/generic/header/glwindow.h
View file

@ -24,8 +24,16 @@
* ======================================================================= * =======================================================================
*/ */
#ifndef UNIX_GLWINDOW_H #ifndef GEN_GLWINDOW_H
#define UNIX_GLWINDOW_H #define GEN_GLWINDOW_H
#include <stdio.h>
#ifdef _WIN32
#define LIBGL "opengl32.dll"
#else
#define LIBGL "libGL.so.1"
#endif
typedef struct typedef struct
{ {

5
src/refresh/header/qgl.h → src/backends/generic/header/qgl.h
View file

@ -494,6 +494,8 @@ extern void (APIENTRY *qglSelectTextureSGIS)(GLenum);
extern void (APIENTRY *qglActiveTextureARB)(GLenum); extern void (APIENTRY *qglActiveTextureARB)(GLenum);
extern void (APIENTRY *qglClientActiveTextureARB)(GLenum); extern void (APIENTRY *qglClientActiveTextureARB)(GLenum);
extern void *qwglGetProcAddress(char *symbol);
#ifdef _WIN32 #ifdef _WIN32
extern int (WINAPI *qwglChoosePixelFormat)(HDC, CONST PIXELFORMATDESCRIPTOR *); extern int (WINAPI *qwglChoosePixelFormat)(HDC, CONST PIXELFORMATDESCRIPTOR *);
@ -510,7 +512,6 @@ extern HGLRC (WINAPI *qwglCreateLayerContext)(HDC, int);
extern BOOL (WINAPI *qwglDeleteContext)(HGLRC); extern BOOL (WINAPI *qwglDeleteContext)(HGLRC);
extern HGLRC (WINAPI *qwglGetCurrentContext)(VOID); extern HGLRC (WINAPI *qwglGetCurrentContext)(VOID);
extern HDC (WINAPI *qwglGetCurrentDC)(VOID); extern HDC (WINAPI *qwglGetCurrentDC)(VOID);
extern PROC (WINAPI *qwglGetProcAddress)(LPCSTR);
extern BOOL (WINAPI *qwglMakeCurrent)(HDC, HGLRC); extern BOOL (WINAPI *qwglMakeCurrent)(HDC, HGLRC);
extern BOOL (WINAPI *qwglShareLists)(HGLRC, HGLRC); extern BOOL (WINAPI *qwglShareLists)(HGLRC, HGLRC);
extern BOOL (WINAPI *qwglUseFontBitmaps)(HDC, DWORD, DWORD, DWORD); extern BOOL (WINAPI *qwglUseFontBitmaps)(HDC, DWORD, DWORD, DWORD);
@ -536,8 +537,6 @@ extern BOOL (WINAPI *qwglSetDeviceGammaRampEXT)(const unsigned char *pRed,
#else #else
/* local function in dll */ /* local function in dll */
extern void *qwglGetProcAddress(char *symbol);
void Fake_glColorTableEXT(GLenum target, GLenum internalformat, GLsizei width, void Fake_glColorTableEXT(GLenum target, GLenum internalformat, GLsizei width,
GLenum format, GLenum type, const GLvoid *table); GLenum format, GLenum type, const GLvoid *table);

697
src/backends/unix/qgl.c → src/backends/generic/qgl.c
View file

@ -29,8 +29,6 @@
* ======================================================================= * =======================================================================
*/ */
#include <dlfcn.h>
#include "../../refresh/header/local.h" #include "../../refresh/header/local.h"
#include "header/glwindow.h" #include "header/glwindow.h"
@ -3267,7 +3265,7 @@ QGL_Shutdown(void)
{ {
if (glw_state.OpenGLLib) if (glw_state.OpenGLLib)
{ {
dlclose(glw_state.OpenGLLib); ri.Sys_FreeLibrary(glw_state.OpenGLLib);
glw_state.OpenGLLib = NULL; glw_state.OpenGLLib = NULL;
} }
@ -3611,14 +3609,12 @@ QGL_Shutdown(void)
qglViewport = NULL; qglViewport = NULL;
} }
#define GPA(a) dlsym(glw_state.OpenGLLib, a)
void * void *
qwglGetProcAddress(char *symbol) qwglGetProcAddress(char *symbol)
{ {
if (glw_state.OpenGLLib) if (glw_state.OpenGLLib)
{ {
return GPA(symbol); return ri.Sys_GetProcAddress(glw_state.OpenGLLib, symbol);
} }
return NULL; return NULL;
@ -3639,7 +3635,9 @@ QGL_Init(const char *dllname)
QGL_Shutdown(); QGL_Shutdown();
} }
if ((glw_state.OpenGLLib = dlopen(dllname, RTLD_LAZY)) == 0) ri.Sys_LoadLibrary(dllname, NULL, &glw_state.OpenGLLib);
if (glw_state.OpenGLLib == 0)
{ {
char fn[MAX_OSPATH]; char fn[MAX_OSPATH];
char *path; char *path;
@ -3648,21 +3646,22 @@ QGL_Init(const char *dllname)
path = ri.Cvar_Get("basedir", ".", CVAR_NOSET)->string; path = ri.Cvar_Get("basedir", ".", CVAR_NOSET)->string;
snprintf(fn, MAX_OSPATH, "%s/%s", path, dllname); snprintf(fn, MAX_OSPATH, "%s/%s", path, dllname);
ri.Sys_LoadLibrary(fn, NULL, &glw_state.OpenGLLib);
if ((glw_state.OpenGLLib = dlopen(fn, RTLD_LAZY)) == 0) if (glw_state.OpenGLLib == NULL)
{ {
ri.Con_Printf(PRINT_ALL, "%s\n", dlerror());
ri.Con_Printf(PRINT_ALL, "Trying hardcoded default libGL\n"); ri.Con_Printf(PRINT_ALL, "Trying hardcoded default libGL\n");
if ((glw_state.OpenGLLib = dlopen("libGL.so.1", RTLD_LAZY)) == 0) ri.Sys_LoadLibrary(LIBGL, NULL, &glw_state.OpenGLLib);
if (glw_state.OpenGLLib == NULL)
{ {
ri.Con_Printf(PRINT_ALL, "%s\n", dlerror());
return false; return false;
} }
else else
{ {
ri.Cvar_Set("gl_driver", "libGL.so.1"); ri.Cvar_Set("gl_driver", LIBGL);
Com_Printf("Using libGL.so.1 for OpenGL.\n"); Com_Printf("Using %s for OpenGL.\n", LIBGL);
} }
} }
else else
@ -3675,342 +3674,342 @@ QGL_Init(const char *dllname)
Com_Printf("Using %s for OpenGL.\n", dllname); Com_Printf("Using %s for OpenGL.\n", dllname);
} }
qglAccum = dllAccum = GPA("glAccum"); qglAccum = dllAccum = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glAccum");
qglAlphaFunc = dllAlphaFunc = GPA("glAlphaFunc"); qglAlphaFunc = dllAlphaFunc = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glAlphaFunc");
qglAreTexturesResident = dllAreTexturesResident = GPA("glAreTexturesResident"); qglAreTexturesResident = dllAreTexturesResident = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glAreTexturesResident");
qglArrayElement = dllArrayElement = GPA("glArrayElement"); qglArrayElement = dllArrayElement = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glArrayElement");
qglBegin = dllBegin = GPA("glBegin"); qglBegin = dllBegin = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glBegin");
qglBindTexture = dllBindTexture = GPA("glBindTexture"); qglBindTexture = dllBindTexture = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glBindTexture");
qglBitmap = dllBitmap = GPA("glBitmap"); qglBitmap = dllBitmap = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glBitmap");
qglBlendFunc = dllBlendFunc = GPA("glBlendFunc"); qglBlendFunc = dllBlendFunc = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glBlendFunc");
qglCallList = dllCallList = GPA("glCallList"); qglCallList = dllCallList = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glCallList");
qglCallLists = dllCallLists = GPA("glCallLists"); qglCallLists = dllCallLists = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glCallLists");
qglClear = dllClear = GPA("glClear"); qglClear = dllClear = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glClear");
qglClearAccum = dllClearAccum = GPA("glClearAccum"); qglClearAccum = dllClearAccum = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glClearAccum");
qglClearColor = dllClearColor = GPA("glClearColor"); qglClearColor = dllClearColor = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glClearColor");
qglClearDepth = dllClearDepth = GPA("glClearDepth"); qglClearDepth = dllClearDepth = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glClearDepth");
qglClearIndex = dllClearIndex = GPA("glClearIndex"); qglClearIndex = dllClearIndex = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glClearIndex");
qglClearStencil = dllClearStencil = GPA("glClearStencil"); qglClearStencil = dllClearStencil = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glClearStencil");
qglClipPlane = dllClipPlane = GPA("glClipPlane"); qglClipPlane = dllClipPlane = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glClipPlane");
qglColor3b = dllColor3b = GPA("glColor3b"); qglColor3b = dllColor3b = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor3b");
qglColor3bv = dllColor3bv = GPA("glColor3bv"); qglColor3bv = dllColor3bv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor3bv");
qglColor3d = dllColor3d = GPA("glColor3d"); qglColor3d = dllColor3d = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor3d");
qglColor3dv = dllColor3dv = GPA("glColor3dv"); qglColor3dv = dllColor3dv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor3dv");
qglColor3f = dllColor3f = GPA("glColor3f"); qglColor3f = dllColor3f = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor3f");
qglColor3fv = dllColor3fv = GPA("glColor3fv"); qglColor3fv = dllColor3fv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor3fv");
qglColor3i = dllColor3i = GPA("glColor3i"); qglColor3i = dllColor3i = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor3i");
qglColor3iv = dllColor3iv = GPA("glColor3iv"); qglColor3iv = dllColor3iv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor3iv");
qglColor3s = dllColor3s = GPA("glColor3s"); qglColor3s = dllColor3s = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor3s");
qglColor3sv = dllColor3sv = GPA("glColor3sv"); qglColor3sv = dllColor3sv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor3sv");
qglColor3ub = dllColor3ub = GPA("glColor3ub"); qglColor3ub = dllColor3ub = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor3ub");
qglColor3ubv = dllColor3ubv = GPA("glColor3ubv"); qglColor3ubv = dllColor3ubv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor3ubv");
qglColor3ui = dllColor3ui = GPA("glColor3ui"); qglColor3ui = dllColor3ui = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor3ui");
qglColor3uiv = dllColor3uiv = GPA("glColor3uiv"); qglColor3uiv = dllColor3uiv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor3uiv");
qglColor3us = dllColor3us = GPA("glColor3us"); qglColor3us = dllColor3us = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor3us");
qglColor3usv = dllColor3usv = GPA("glColor3usv"); qglColor3usv = dllColor3usv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor3usv");
qglColor4b = dllColor4b = GPA("glColor4b"); qglColor4b = dllColor4b = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor4b");
qglColor4bv = dllColor4bv = GPA("glColor4bv"); qglColor4bv = dllColor4bv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor4bv");
qglColor4d = dllColor4d = GPA("glColor4d"); qglColor4d = dllColor4d = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor4d");
qglColor4dv = dllColor4dv = GPA("glColor4dv"); qglColor4dv = dllColor4dv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor4dv");
qglColor4f = dllColor4f = GPA("glColor4f"); qglColor4f = dllColor4f = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor4f");
qglColor4fv = dllColor4fv = GPA("glColor4fv"); qglColor4fv = dllColor4fv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor4fv");
qglColor4i = dllColor4i = GPA("glColor4i"); qglColor4i = dllColor4i = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor4i");
qglColor4iv = dllColor4iv = GPA("glColor4iv"); qglColor4iv = dllColor4iv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor4iv");
qglColor4s = dllColor4s = GPA("glColor4s"); qglColor4s = dllColor4s = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor4s");
qglColor4sv = dllColor4sv = GPA("glColor4sv"); qglColor4sv = dllColor4sv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor4sv");
qglColor4ub = dllColor4ub = GPA("glColor4ub"); qglColor4ub = dllColor4ub = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor4ub");
qglColor4ubv = dllColor4ubv = GPA("glColor4ubv"); qglColor4ubv = dllColor4ubv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor4ubv");
qglColor4ui = dllColor4ui = GPA("glColor4ui"); qglColor4ui = dllColor4ui = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor4ui");
qglColor4uiv = dllColor4uiv = GPA("glColor4uiv"); qglColor4uiv = dllColor4uiv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor4uiv");
qglColor4us = dllColor4us = GPA("glColor4us"); qglColor4us = dllColor4us = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor4us");
qglColor4usv = dllColor4usv = GPA("glColor4usv"); qglColor4usv = dllColor4usv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColor4usv");
qglColorMask = dllColorMask = GPA("glColorMask"); qglColorMask = dllColorMask = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColorMask");
qglColorMaterial = dllColorMaterial = GPA("glColorMaterial"); qglColorMaterial = dllColorMaterial = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColorMaterial");
qglColorPointer = dllColorPointer = GPA("glColorPointer"); qglColorPointer = dllColorPointer = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glColorPointer");
qglCopyPixels = dllCopyPixels = GPA("glCopyPixels"); qglCopyPixels = dllCopyPixels = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glCopyPixels");
qglCopyTexImage1D = dllCopyTexImage1D = GPA("glCopyTexImage1D"); qglCopyTexImage1D = dllCopyTexImage1D = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glCopyTexImage1D");
qglCopyTexImage2D = dllCopyTexImage2D = GPA("glCopyTexImage2D"); qglCopyTexImage2D = dllCopyTexImage2D = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glCopyTexImage2D");
qglCopyTexSubImage1D = dllCopyTexSubImage1D = GPA("glCopyTexSubImage1D"); qglCopyTexSubImage1D = dllCopyTexSubImage1D = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glCopyTexSubImage1D");
qglCopyTexSubImage2D = dllCopyTexSubImage2D = GPA("glCopyTexSubImage2D"); qglCopyTexSubImage2D = dllCopyTexSubImage2D = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glCopyTexSubImage2D");
qglCullFace = dllCullFace = GPA("glCullFace"); qglCullFace = dllCullFace = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glCullFace");
qglDeleteLists = dllDeleteLists = GPA("glDeleteLists"); qglDeleteLists = dllDeleteLists = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glDeleteLists");
qglDeleteTextures = dllDeleteTextures = GPA("glDeleteTextures"); qglDeleteTextures = dllDeleteTextures = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glDeleteTextures");
qglDepthFunc = dllDepthFunc = GPA("glDepthFunc"); qglDepthFunc = dllDepthFunc = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glDepthFunc");
qglDepthMask = dllDepthMask = GPA("glDepthMask"); qglDepthMask = dllDepthMask = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glDepthMask");
qglDepthRange = dllDepthRange = GPA("glDepthRange"); qglDepthRange = dllDepthRange = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glDepthRange");
qglDisable = dllDisable = GPA("glDisable"); qglDisable = dllDisable = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glDisable");
qglDisableClientState = dllDisableClientState = GPA("glDisableClientState"); qglDisableClientState = dllDisableClientState = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glDisableClientState");
qglDrawArrays = dllDrawArrays = GPA("glDrawArrays"); qglDrawArrays = dllDrawArrays = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glDrawArrays");
qglDrawBuffer = dllDrawBuffer = GPA("glDrawBuffer"); qglDrawBuffer = dllDrawBuffer = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glDrawBuffer");
qglDrawElements = dllDrawElements = GPA("glDrawElements"); qglDrawElements = dllDrawElements = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glDrawElements");
qglDrawPixels = dllDrawPixels = GPA("glDrawPixels"); qglDrawPixels = dllDrawPixels = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glDrawPixels");
qglEdgeFlag = dllEdgeFlag = GPA("glEdgeFlag"); qglEdgeFlag = dllEdgeFlag = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glEdgeFlag");
qglEdgeFlagPointer = dllEdgeFlagPointer = GPA("glEdgeFlagPointer"); qglEdgeFlagPointer = dllEdgeFlagPointer = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glEdgeFlagPointer");
qglEdgeFlagv = dllEdgeFlagv = GPA("glEdgeFlagv"); qglEdgeFlagv = dllEdgeFlagv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glEdgeFlagv");
qglEnable = dllEnable = GPA("glEnable"); qglEnable = dllEnable = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glEnable");
qglEnableClientState = dllEnableClientState = GPA("glEnableClientState"); qglEnableClientState = dllEnableClientState = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glEnableClientState");
qglEnd = dllEnd = GPA("glEnd"); qglEnd = dllEnd = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glEnd");
qglEndList = dllEndList = GPA("glEndList"); qglEndList = dllEndList = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glEndList");
qglEvalCoord1d = dllEvalCoord1d = GPA("glEvalCoord1d"); qglEvalCoord1d = dllEvalCoord1d = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glEvalCoord1d");
qglEvalCoord1dv = dllEvalCoord1dv = GPA("glEvalCoord1dv"); qglEvalCoord1dv = dllEvalCoord1dv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glEvalCoord1dv");
qglEvalCoord1f = dllEvalCoord1f = GPA("glEvalCoord1f"); qglEvalCoord1f = dllEvalCoord1f = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glEvalCoord1f");
qglEvalCoord1fv = dllEvalCoord1fv = GPA("glEvalCoord1fv"); qglEvalCoord1fv = dllEvalCoord1fv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glEvalCoord1fv");
qglEvalCoord2d = dllEvalCoord2d = GPA("glEvalCoord2d"); qglEvalCoord2d = dllEvalCoord2d = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glEvalCoord2d");
qglEvalCoord2dv = dllEvalCoord2dv = GPA("glEvalCoord2dv"); qglEvalCoord2dv = dllEvalCoord2dv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glEvalCoord2dv");
qglEvalCoord2f = dllEvalCoord2f = GPA("glEvalCoord2f"); qglEvalCoord2f = dllEvalCoord2f = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glEvalCoord2f");
qglEvalCoord2fv = dllEvalCoord2fv = GPA("glEvalCoord2fv"); qglEvalCoord2fv = dllEvalCoord2fv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glEvalCoord2fv");
qglEvalMesh1 = dllEvalMesh1 = GPA("glEvalMesh1"); qglEvalMesh1 = dllEvalMesh1 = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glEvalMesh1");
qglEvalMesh2 = dllEvalMesh2 = GPA("glEvalMesh2"); qglEvalMesh2 = dllEvalMesh2 = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glEvalMesh2");
qglEvalPoint1 = dllEvalPoint1 = GPA("glEvalPoint1"); qglEvalPoint1 = dllEvalPoint1 = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glEvalPoint1");
qglEvalPoint2 = dllEvalPoint2 = GPA("glEvalPoint2"); qglEvalPoint2 = dllEvalPoint2 = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glEvalPoint2");
qglFeedbackBuffer = dllFeedbackBuffer = GPA("glFeedbackBuffer"); qglFeedbackBuffer = dllFeedbackBuffer = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glFeedbackBuffer");
qglFinish = dllFinish = GPA("glFinish"); qglFinish = dllFinish = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glFinish");
qglFlush = dllFlush = GPA("glFlush"); qglFlush = dllFlush = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glFlush");
qglFogf = dllFogf = GPA("glFogf"); qglFogf = dllFogf = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glFogf");
qglFogfv = dllFogfv = GPA("glFogfv"); qglFogfv = dllFogfv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glFogfv");
qglFogi = dllFogi = GPA("glFogi"); qglFogi = dllFogi = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glFogi");
qglFogiv = dllFogiv = GPA("glFogiv"); qglFogiv = dllFogiv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glFogiv");
qglFrontFace = dllFrontFace = GPA("glFrontFace"); qglFrontFace = dllFrontFace = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glFrontFace");
qglFrustum = dllFrustum = GPA("glFrustum"); qglFrustum = dllFrustum = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glFrustum");
qglGenLists = dllGenLists = GPA("glGenLists"); qglGenLists = dllGenLists = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGenLists");
qglGenTextures = dllGenTextures = GPA("glGenTextures"); qglGenTextures = dllGenTextures = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGenTextures");
qglGetBooleanv = dllGetBooleanv = GPA("glGetBooleanv"); qglGetBooleanv = dllGetBooleanv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetBooleanv");
qglGetClipPlane = dllGetClipPlane = GPA("glGetClipPlane"); qglGetClipPlane = dllGetClipPlane = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetClipPlane");
qglGetDoublev = dllGetDoublev = GPA("glGetDoublev"); qglGetDoublev = dllGetDoublev = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetDoublev");
qglGetError = dllGetError = GPA("glGetError"); qglGetError = dllGetError = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetError");
qglGetFloatv = dllGetFloatv = GPA("glGetFloatv"); qglGetFloatv = dllGetFloatv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetFloatv");
qglGetIntegerv = dllGetIntegerv = GPA("glGetIntegerv"); qglGetIntegerv = dllGetIntegerv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetIntegerv");
qglGetLightfv = dllGetLightfv = GPA("glGetLightfv"); qglGetLightfv = dllGetLightfv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetLightfv");
qglGetLightiv = dllGetLightiv = GPA("glGetLightiv"); qglGetLightiv = dllGetLightiv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetLightiv");
qglGetMapdv = dllGetMapdv = GPA("glGetMapdv"); qglGetMapdv = dllGetMapdv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetMapdv");
qglGetMapfv = dllGetMapfv = GPA("glGetMapfv"); qglGetMapfv = dllGetMapfv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetMapfv");
qglGetMapiv = dllGetMapiv = GPA("glGetMapiv"); qglGetMapiv = dllGetMapiv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetMapiv");
qglGetMaterialfv = dllGetMaterialfv = GPA("glGetMaterialfv"); qglGetMaterialfv = dllGetMaterialfv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetMaterialfv");
qglGetMaterialiv = dllGetMaterialiv = GPA("glGetMaterialiv"); qglGetMaterialiv = dllGetMaterialiv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetMaterialiv");
qglGetPixelMapfv = dllGetPixelMapfv = GPA("glGetPixelMapfv"); qglGetPixelMapfv = dllGetPixelMapfv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetPixelMapfv");
qglGetPixelMapuiv = dllGetPixelMapuiv = GPA("glGetPixelMapuiv"); qglGetPixelMapuiv = dllGetPixelMapuiv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetPixelMapuiv");
qglGetPixelMapusv = dllGetPixelMapusv = GPA("glGetPixelMapusv"); qglGetPixelMapusv = dllGetPixelMapusv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetPixelMapusv");
qglGetPointerv = dllGetPointerv = GPA("glGetPointerv"); qglGetPointerv = dllGetPointerv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetPointerv");
qglGetPolygonStipple = dllGetPolygonStipple = GPA("glGetPolygonStipple"); qglGetPolygonStipple = dllGetPolygonStipple = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetPolygonStipple");
qglGetString = dllGetString = GPA("glGetString"); qglGetString = dllGetString = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetString");
qglGetTexEnvfv = dllGetTexEnvfv = GPA("glGetTexEnvfv"); qglGetTexEnvfv = dllGetTexEnvfv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetTexEnvfv");
qglGetTexEnviv = dllGetTexEnviv = GPA("glGetTexEnviv"); qglGetTexEnviv = dllGetTexEnviv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetTexEnviv");
qglGetTexGendv = dllGetTexGendv = GPA("glGetTexGendv"); qglGetTexGendv = dllGetTexGendv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetTexGendv");
qglGetTexGenfv = dllGetTexGenfv = GPA("glGetTexGenfv"); qglGetTexGenfv = dllGetTexGenfv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetTexGenfv");
qglGetTexGeniv = dllGetTexGeniv = GPA("glGetTexGeniv"); qglGetTexGeniv = dllGetTexGeniv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetTexGeniv");
qglGetTexImage = dllGetTexImage = GPA("glGetTexImage"); qglGetTexImage = dllGetTexImage = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetTexImage");
qglGetTexLevelParameterfv = dllGetTexLevelParameterfv = GPA("glGetLevelParameterfv"); qglGetTexLevelParameterfv = dllGetTexLevelParameterfv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetLevelParameterfv");
qglGetTexLevelParameteriv = dllGetTexLevelParameteriv = GPA("glGetLevelParameteriv"); qglGetTexLevelParameteriv = dllGetTexLevelParameteriv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetLevelParameteriv");
qglGetTexParameterfv = dllGetTexParameterfv = GPA("glGetTexParameterfv"); qglGetTexParameterfv = dllGetTexParameterfv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetTexParameterfv");
qglGetTexParameteriv = dllGetTexParameteriv = GPA("glGetTexParameteriv"); qglGetTexParameteriv = dllGetTexParameteriv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glGetTexParameteriv");
qglHint = dllHint = GPA("glHint"); qglHint = dllHint = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glHint");
qglIndexMask = dllIndexMask = GPA("glIndexMask"); qglIndexMask = dllIndexMask = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glIndexMask");
qglIndexPointer = dllIndexPointer = GPA("glIndexPointer"); qglIndexPointer = dllIndexPointer = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glIndexPointer");
qglIndexd = dllIndexd = GPA("glIndexd"); qglIndexd = dllIndexd = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glIndexd");
qglIndexdv = dllIndexdv = GPA("glIndexdv"); qglIndexdv = dllIndexdv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glIndexdv");
qglIndexf = dllIndexf = GPA("glIndexf"); qglIndexf = dllIndexf = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glIndexf");
qglIndexfv = dllIndexfv = GPA("glIndexfv"); qglIndexfv = dllIndexfv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glIndexfv");
qglIndexi = dllIndexi = GPA("glIndexi"); qglIndexi = dllIndexi = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glIndexi");
qglIndexiv = dllIndexiv = GPA("glIndexiv"); qglIndexiv = dllIndexiv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glIndexiv");
qglIndexs = dllIndexs = GPA("glIndexs"); qglIndexs = dllIndexs = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glIndexs");
qglIndexsv = dllIndexsv = GPA("glIndexsv"); qglIndexsv = dllIndexsv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glIndexsv");
qglIndexub = dllIndexub = GPA("glIndexub"); qglIndexub = dllIndexub = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glIndexub");
qglIndexubv = dllIndexubv = GPA("glIndexubv"); qglIndexubv = dllIndexubv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glIndexubv");
qglInitNames = dllInitNames = GPA("glInitNames"); qglInitNames = dllInitNames = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glInitNames");
qglInterleavedArrays = dllInterleavedArrays = GPA("glInterleavedArrays"); qglInterleavedArrays = dllInterleavedArrays = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glInterleavedArrays");
qglIsEnabled = dllIsEnabled = GPA("glIsEnabled"); qglIsEnabled = dllIsEnabled = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glIsEnabled");
qglIsList = dllIsList = GPA("glIsList"); qglIsList = dllIsList = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glIsList");
qglIsTexture = dllIsTexture = GPA("glIsTexture"); qglIsTexture = dllIsTexture = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glIsTexture");
qglLightModelf = dllLightModelf = GPA("glLightModelf"); qglLightModelf = dllLightModelf = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glLightModelf");
qglLightModelfv = dllLightModelfv = GPA("glLightModelfv"); qglLightModelfv = dllLightModelfv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glLightModelfv");
qglLightModeli = dllLightModeli = GPA("glLightModeli"); qglLightModeli = dllLightModeli = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glLightModeli");
qglLightModeliv = dllLightModeliv = GPA("glLightModeliv"); qglLightModeliv = dllLightModeliv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glLightModeliv");
qglLightf = dllLightf = GPA("glLightf"); qglLightf = dllLightf = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glLightf");
qglLightfv = dllLightfv = GPA("glLightfv"); qglLightfv = dllLightfv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glLightfv");
qglLighti = dllLighti = GPA("glLighti"); qglLighti = dllLighti = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glLighti");
qglLightiv = dllLightiv = GPA("glLightiv"); qglLightiv = dllLightiv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glLightiv");
qglLineStipple = dllLineStipple = GPA("glLineStipple"); qglLineStipple = dllLineStipple = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glLineStipple");
qglLineWidth = dllLineWidth = GPA("glLineWidth"); qglLineWidth = dllLineWidth = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glLineWidth");
qglListBase = dllListBase = GPA("glListBase"); qglListBase = dllListBase = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glListBase");
qglLoadIdentity = dllLoadIdentity = GPA("glLoadIdentity"); qglLoadIdentity = dllLoadIdentity = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glLoadIdentity");
qglLoadMatrixd = dllLoadMatrixd = GPA("glLoadMatrixd"); qglLoadMatrixd = dllLoadMatrixd = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glLoadMatrixd");
qglLoadMatrixf = dllLoadMatrixf = GPA("glLoadMatrixf"); qglLoadMatrixf = dllLoadMatrixf = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glLoadMatrixf");
qglLoadName = dllLoadName = GPA("glLoadName"); qglLoadName = dllLoadName = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glLoadName");
qglLogicOp = dllLogicOp = GPA("glLogicOp"); qglLogicOp = dllLogicOp = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glLogicOp");
qglMap1d = dllMap1d = GPA("glMap1d"); qglMap1d = dllMap1d = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glMap1d");
qglMap1f = dllMap1f = GPA("glMap1f"); qglMap1f = dllMap1f = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glMap1f");
qglMap2d = dllMap2d = GPA("glMap2d"); qglMap2d = dllMap2d = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glMap2d");
qglMap2f = dllMap2f = GPA("glMap2f"); qglMap2f = dllMap2f = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glMap2f");
qglMapGrid1d = dllMapGrid1d = GPA("glMapGrid1d"); qglMapGrid1d = dllMapGrid1d = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glMapGrid1d");
qglMapGrid1f = dllMapGrid1f = GPA("glMapGrid1f"); qglMapGrid1f = dllMapGrid1f = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glMapGrid1f");
qglMapGrid2d = dllMapGrid2d = GPA("glMapGrid2d"); qglMapGrid2d = dllMapGrid2d = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glMapGrid2d");
qglMapGrid2f = dllMapGrid2f = GPA("glMapGrid2f"); qglMapGrid2f = dllMapGrid2f = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glMapGrid2f");
qglMaterialf = dllMaterialf = GPA("glMaterialf"); qglMaterialf = dllMaterialf = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glMaterialf");
qglMaterialfv = dllMaterialfv = GPA("glMaterialfv"); qglMaterialfv = dllMaterialfv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glMaterialfv");
qglMateriali = dllMateriali = GPA("glMateriali"); qglMateriali = dllMateriali = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glMateriali");
qglMaterialiv = dllMaterialiv = GPA("glMaterialiv"); qglMaterialiv = dllMaterialiv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glMaterialiv");
qglMatrixMode = dllMatrixMode = GPA("glMatrixMode"); qglMatrixMode = dllMatrixMode = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glMatrixMode");
qglMultMatrixd = dllMultMatrixd = GPA("glMultMatrixd"); qglMultMatrixd = dllMultMatrixd = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glMultMatrixd");
qglMultMatrixf = dllMultMatrixf = GPA("glMultMatrixf"); qglMultMatrixf = dllMultMatrixf = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glMultMatrixf");
qglNewList = dllNewList = GPA("glNewList"); qglNewList = dllNewList = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glNewList");
qglNormal3b = dllNormal3b = GPA("glNormal3b"); qglNormal3b = dllNormal3b = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glNormal3b");
qglNormal3bv = dllNormal3bv = GPA("glNormal3bv"); qglNormal3bv = dllNormal3bv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glNormal3bv");
qglNormal3d = dllNormal3d = GPA("glNormal3d"); qglNormal3d = dllNormal3d = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glNormal3d");
qglNormal3dv = dllNormal3dv = GPA("glNormal3dv"); qglNormal3dv = dllNormal3dv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glNormal3dv");
qglNormal3f = dllNormal3f = GPA("glNormal3f"); qglNormal3f = dllNormal3f = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glNormal3f");
qglNormal3fv = dllNormal3fv = GPA("glNormal3fv"); qglNormal3fv = dllNormal3fv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glNormal3fv");
qglNormal3i = dllNormal3i = GPA("glNormal3i"); qglNormal3i = dllNormal3i = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glNormal3i");
qglNormal3iv = dllNormal3iv = GPA("glNormal3iv"); qglNormal3iv = dllNormal3iv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glNormal3iv");
qglNormal3s = dllNormal3s = GPA("glNormal3s"); qglNormal3s = dllNormal3s = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glNormal3s");
qglNormal3sv = dllNormal3sv = GPA("glNormal3sv"); qglNormal3sv = dllNormal3sv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glNormal3sv");
qglNormalPointer = dllNormalPointer = GPA("glNormalPointer"); qglNormalPointer = dllNormalPointer = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glNormalPointer");
qglOrtho = dllOrtho = GPA("glOrtho"); qglOrtho = dllOrtho = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glOrtho");
qglPassThrough = dllPassThrough = GPA("glPassThrough"); qglPassThrough = dllPassThrough = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glPassThrough");
qglPixelMapfv = dllPixelMapfv = GPA("glPixelMapfv"); qglPixelMapfv = dllPixelMapfv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glPixelMapfv");
qglPixelMapuiv = dllPixelMapuiv = GPA("glPixelMapuiv"); qglPixelMapuiv = dllPixelMapuiv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glPixelMapuiv");
qglPixelMapusv = dllPixelMapusv = GPA("glPixelMapusv"); qglPixelMapusv = dllPixelMapusv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glPixelMapusv");
qglPixelStoref = dllPixelStoref = GPA("glPixelStoref"); qglPixelStoref = dllPixelStoref = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glPixelStoref");
qglPixelStorei = dllPixelStorei = GPA("glPixelStorei"); qglPixelStorei = dllPixelStorei = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glPixelStorei");
qglPixelTransferf = dllPixelTransferf = GPA("glPixelTransferf"); qglPixelTransferf = dllPixelTransferf = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glPixelTransferf");
qglPixelTransferi = dllPixelTransferi = GPA("glPixelTransferi"); qglPixelTransferi = dllPixelTransferi = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glPixelTransferi");
qglPixelZoom = dllPixelZoom = GPA("glPixelZoom"); qglPixelZoom = dllPixelZoom = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glPixelZoom");
qglPointSize = dllPointSize = GPA("glPointSize"); qglPointSize = dllPointSize = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glPointSize");
qglPolygonMode = dllPolygonMode = GPA("glPolygonMode"); qglPolygonMode = dllPolygonMode = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glPolygonMode");
qglPolygonOffset = dllPolygonOffset = GPA("glPolygonOffset"); qglPolygonOffset = dllPolygonOffset = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glPolygonOffset");
qglPolygonStipple = dllPolygonStipple = GPA("glPolygonStipple"); qglPolygonStipple = dllPolygonStipple = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glPolygonStipple");
qglPopAttrib = dllPopAttrib = GPA("glPopAttrib"); qglPopAttrib = dllPopAttrib = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glPopAttrib");
qglPopClientAttrib = dllPopClientAttrib = GPA("glPopClientAttrib"); qglPopClientAttrib = dllPopClientAttrib = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glPopClientAttrib");
qglPopMatrix = dllPopMatrix = GPA("glPopMatrix"); qglPopMatrix = dllPopMatrix = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glPopMatrix");
qglPopName = dllPopName = GPA("glPopName"); qglPopName = dllPopName = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glPopName");
qglPrioritizeTextures = dllPrioritizeTextures = GPA("glPrioritizeTextures"); qglPrioritizeTextures = dllPrioritizeTextures = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glPrioritizeTextures");
qglPushAttrib = dllPushAttrib = GPA("glPushAttrib"); qglPushAttrib = dllPushAttrib = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glPushAttrib");
qglPushClientAttrib = dllPushClientAttrib = GPA("glPushClientAttrib"); qglPushClientAttrib = dllPushClientAttrib = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glPushClientAttrib");
qglPushMatrix = dllPushMatrix = GPA("glPushMatrix"); qglPushMatrix = dllPushMatrix = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glPushMatrix");
qglPushName = dllPushName = GPA("glPushName"); qglPushName = dllPushName = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glPushName");
qglRasterPos2d = dllRasterPos2d = GPA("glRasterPos2d"); qglRasterPos2d = dllRasterPos2d = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos2d");
qglRasterPos2dv = dllRasterPos2dv = GPA("glRasterPos2dv"); qglRasterPos2dv = dllRasterPos2dv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos2dv");
qglRasterPos2f = dllRasterPos2f = GPA("glRasterPos2f"); qglRasterPos2f = dllRasterPos2f = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos2f");
qglRasterPos2fv = dllRasterPos2fv = GPA("glRasterPos2fv"); qglRasterPos2fv = dllRasterPos2fv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos2fv");
qglRasterPos2i = dllRasterPos2i = GPA("glRasterPos2i"); qglRasterPos2i = dllRasterPos2i = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos2i");
qglRasterPos2iv = dllRasterPos2iv = GPA("glRasterPos2iv"); qglRasterPos2iv = dllRasterPos2iv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos2iv");
qglRasterPos2s = dllRasterPos2s = GPA("glRasterPos2s"); qglRasterPos2s = dllRasterPos2s = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos2s");
qglRasterPos2sv = dllRasterPos2sv = GPA("glRasterPos2sv"); qglRasterPos2sv = dllRasterPos2sv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos2sv");
qglRasterPos3d = dllRasterPos3d = GPA("glRasterPos3d"); qglRasterPos3d = dllRasterPos3d = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos3d");
qglRasterPos3dv = dllRasterPos3dv = GPA("glRasterPos3dv"); qglRasterPos3dv = dllRasterPos3dv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos3dv");
qglRasterPos3f = dllRasterPos3f = GPA("glRasterPos3f"); qglRasterPos3f = dllRasterPos3f = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos3f");
qglRasterPos3fv = dllRasterPos3fv = GPA("glRasterPos3fv"); qglRasterPos3fv = dllRasterPos3fv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos3fv");
qglRasterPos3i = dllRasterPos3i = GPA("glRasterPos3i"); qglRasterPos3i = dllRasterPos3i = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos3i");
qglRasterPos3iv = dllRasterPos3iv = GPA("glRasterPos3iv"); qglRasterPos3iv = dllRasterPos3iv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos3iv");
qglRasterPos3s = dllRasterPos3s = GPA("glRasterPos3s"); qglRasterPos3s = dllRasterPos3s = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos3s");
qglRasterPos3sv = dllRasterPos3sv = GPA("glRasterPos3sv"); qglRasterPos3sv = dllRasterPos3sv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos3sv");
qglRasterPos4d = dllRasterPos4d = GPA("glRasterPos4d"); qglRasterPos4d = dllRasterPos4d = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos4d");
qglRasterPos4dv = dllRasterPos4dv = GPA("glRasterPos4dv"); qglRasterPos4dv = dllRasterPos4dv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos4dv");
qglRasterPos4f = dllRasterPos4f = GPA("glRasterPos4f"); qglRasterPos4f = dllRasterPos4f = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos4f");
qglRasterPos4fv = dllRasterPos4fv = GPA("glRasterPos4fv"); qglRasterPos4fv = dllRasterPos4fv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos4fv");
qglRasterPos4i = dllRasterPos4i = GPA("glRasterPos4i"); qglRasterPos4i = dllRasterPos4i = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos4i");
qglRasterPos4iv = dllRasterPos4iv = GPA("glRasterPos4iv"); qglRasterPos4iv = dllRasterPos4iv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos4iv");
qglRasterPos4s = dllRasterPos4s = GPA("glRasterPos4s"); qglRasterPos4s = dllRasterPos4s = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos4s");
qglRasterPos4sv = dllRasterPos4sv = GPA("glRasterPos4sv"); qglRasterPos4sv = dllRasterPos4sv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRasterPos4sv");
qglReadBuffer = dllReadBuffer = GPA("glReadBuffer"); qglReadBuffer = dllReadBuffer = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glReadBuffer");
qglReadPixels = dllReadPixels = GPA("glReadPixels"); qglReadPixels = dllReadPixels = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glReadPixels");
qglRectd = dllRectd = GPA("glRectd"); qglRectd = dllRectd = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRectd");
qglRectdv = dllRectdv = GPA("glRectdv"); qglRectdv = dllRectdv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRectdv");
qglRectf = dllRectf = GPA("glRectf"); qglRectf = dllRectf = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRectf");
qglRectfv = dllRectfv = GPA("glRectfv"); qglRectfv = dllRectfv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRectfv");
qglRecti = dllRecti = GPA("glRecti"); qglRecti = dllRecti = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRecti");
qglRectiv = dllRectiv = GPA("glRectiv"); qglRectiv = dllRectiv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRectiv");
qglRects = dllRects = GPA("glRects"); qglRects = dllRects = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRects");
qglRectsv = dllRectsv = GPA("glRectsv"); qglRectsv = dllRectsv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRectsv");
qglRenderMode = dllRenderMode = GPA("glRenderMode"); qglRenderMode = dllRenderMode = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRenderMode");
qglRotated = dllRotated = GPA("glRotated"); qglRotated = dllRotated = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRotated");
qglRotatef = dllRotatef = GPA("glRotatef"); qglRotatef = dllRotatef = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glRotatef");
qglScaled = dllScaled = GPA("glScaled"); qglScaled = dllScaled = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glScaled");
qglScalef = dllScalef = GPA("glScalef"); qglScalef = dllScalef = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glScalef");
qglScissor = dllScissor = GPA("glScissor"); qglScissor = dllScissor = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glScissor");
qglSelectBuffer = dllSelectBuffer = GPA("glSelectBuffer"); qglSelectBuffer = dllSelectBuffer = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glSelectBuffer");
qglShadeModel = dllShadeModel = GPA("glShadeModel"); qglShadeModel = dllShadeModel = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glShadeModel");
qglStencilFunc = dllStencilFunc = GPA("glStencilFunc"); qglStencilFunc = dllStencilFunc = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glStencilFunc");
qglStencilMask = dllStencilMask = GPA("glStencilMask"); qglStencilMask = dllStencilMask = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glStencilMask");
qglStencilOp = dllStencilOp = GPA("glStencilOp"); qglStencilOp = dllStencilOp = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glStencilOp");
qglTexCoord1d = dllTexCoord1d = GPA("glTexCoord1d"); qglTexCoord1d = dllTexCoord1d = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord1d");
qglTexCoord1dv = dllTexCoord1dv = GPA("glTexCoord1dv"); qglTexCoord1dv = dllTexCoord1dv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord1dv");
qglTexCoord1f = dllTexCoord1f = GPA("glTexCoord1f"); qglTexCoord1f = dllTexCoord1f = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord1f");
qglTexCoord1fv = dllTexCoord1fv = GPA("glTexCoord1fv"); qglTexCoord1fv = dllTexCoord1fv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord1fv");
qglTexCoord1i = dllTexCoord1i = GPA("glTexCoord1i"); qglTexCoord1i = dllTexCoord1i = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord1i");
qglTexCoord1iv = dllTexCoord1iv = GPA("glTexCoord1iv"); qglTexCoord1iv = dllTexCoord1iv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord1iv");
qglTexCoord1s = dllTexCoord1s = GPA("glTexCoord1s"); qglTexCoord1s = dllTexCoord1s = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord1s");
qglTexCoord1sv = dllTexCoord1sv = GPA("glTexCoord1sv"); qglTexCoord1sv = dllTexCoord1sv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord1sv");
qglTexCoord2d = dllTexCoord2d = GPA("glTexCoord2d"); qglTexCoord2d = dllTexCoord2d = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord2d");
qglTexCoord2dv = dllTexCoord2dv = GPA("glTexCoord2dv"); qglTexCoord2dv = dllTexCoord2dv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord2dv");
qglTexCoord2f = dllTexCoord2f = GPA("glTexCoord2f"); qglTexCoord2f = dllTexCoord2f = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord2f");
qglTexCoord2fv = dllTexCoord2fv = GPA("glTexCoord2fv"); qglTexCoord2fv = dllTexCoord2fv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord2fv");
qglTexCoord2i = dllTexCoord2i = GPA("glTexCoord2i"); qglTexCoord2i = dllTexCoord2i = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord2i");
qglTexCoord2iv = dllTexCoord2iv = GPA("glTexCoord2iv"); qglTexCoord2iv = dllTexCoord2iv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord2iv");
qglTexCoord2s = dllTexCoord2s = GPA("glTexCoord2s"); qglTexCoord2s = dllTexCoord2s = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord2s");
qglTexCoord2sv = dllTexCoord2sv = GPA("glTexCoord2sv"); qglTexCoord2sv = dllTexCoord2sv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord2sv");
qglTexCoord3d = dllTexCoord3d = GPA("glTexCoord3d"); qglTexCoord3d = dllTexCoord3d = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord3d");
qglTexCoord3dv = dllTexCoord3dv = GPA("glTexCoord3dv"); qglTexCoord3dv = dllTexCoord3dv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord3dv");
qglTexCoord3f = dllTexCoord3f = GPA("glTexCoord3f"); qglTexCoord3f = dllTexCoord3f = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord3f");
qglTexCoord3fv = dllTexCoord3fv = GPA("glTexCoord3fv"); qglTexCoord3fv = dllTexCoord3fv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord3fv");
qglTexCoord3i = dllTexCoord3i = GPA("glTexCoord3i"); qglTexCoord3i = dllTexCoord3i = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord3i");
qglTexCoord3iv = dllTexCoord3iv = GPA("glTexCoord3iv"); qglTexCoord3iv = dllTexCoord3iv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord3iv");
qglTexCoord3s = dllTexCoord3s = GPA("glTexCoord3s"); qglTexCoord3s = dllTexCoord3s = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord3s");
qglTexCoord3sv = dllTexCoord3sv = GPA("glTexCoord3sv"); qglTexCoord3sv = dllTexCoord3sv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord3sv");
qglTexCoord4d = dllTexCoord4d = GPA("glTexCoord4d"); qglTexCoord4d = dllTexCoord4d = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord4d");
qglTexCoord4dv = dllTexCoord4dv = GPA("glTexCoord4dv"); qglTexCoord4dv = dllTexCoord4dv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord4dv");
qglTexCoord4f = dllTexCoord4f = GPA("glTexCoord4f"); qglTexCoord4f = dllTexCoord4f = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord4f");
qglTexCoord4fv = dllTexCoord4fv = GPA("glTexCoord4fv"); qglTexCoord4fv = dllTexCoord4fv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord4fv");
qglTexCoord4i = dllTexCoord4i = GPA("glTexCoord4i"); qglTexCoord4i = dllTexCoord4i = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord4i");
qglTexCoord4iv = dllTexCoord4iv = GPA("glTexCoord4iv"); qglTexCoord4iv = dllTexCoord4iv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord4iv");
qglTexCoord4s = dllTexCoord4s = GPA("glTexCoord4s"); qglTexCoord4s = dllTexCoord4s = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord4s");
qglTexCoord4sv = dllTexCoord4sv = GPA("glTexCoord4sv"); qglTexCoord4sv = dllTexCoord4sv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoord4sv");
qglTexCoordPointer = dllTexCoordPointer = GPA("glTexCoordPointer"); qglTexCoordPointer = dllTexCoordPointer = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexCoordPointer");
qglTexEnvf = dllTexEnvf = GPA("glTexEnvf"); qglTexEnvf = dllTexEnvf = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexEnvf");
qglTexEnvfv = dllTexEnvfv = GPA("glTexEnvfv"); qglTexEnvfv = dllTexEnvfv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexEnvfv");
qglTexEnvi = dllTexEnvi = GPA("glTexEnvi"); qglTexEnvi = dllTexEnvi = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexEnvi");
qglTexEnviv = dllTexEnviv = GPA("glTexEnviv"); qglTexEnviv = dllTexEnviv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexEnviv");
qglTexGend = dllTexGend = GPA("glTexGend"); qglTexGend = dllTexGend = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexGend");
qglTexGendv = dllTexGendv = GPA("glTexGendv"); qglTexGendv = dllTexGendv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexGendv");
qglTexGenf = dllTexGenf = GPA("glTexGenf"); qglTexGenf = dllTexGenf = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexGenf");
qglTexGenfv = dllTexGenfv = GPA("glTexGenfv"); qglTexGenfv = dllTexGenfv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexGenfv");
qglTexGeni = dllTexGeni = GPA("glTexGeni"); qglTexGeni = dllTexGeni = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexGeni");
qglTexGeniv = dllTexGeniv = GPA("glTexGeniv"); qglTexGeniv = dllTexGeniv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexGeniv");
qglTexImage1D = dllTexImage1D = GPA("glTexImage1D"); qglTexImage1D = dllTexImage1D = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexImage1D");
qglTexImage2D = dllTexImage2D = GPA("glTexImage2D"); qglTexImage2D = dllTexImage2D = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexImage2D");
qglTexParameterf = dllTexParameterf = GPA("glTexParameterf"); qglTexParameterf = dllTexParameterf = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexParameterf");
qglTexParameterfv = dllTexParameterfv = GPA("glTexParameterfv"); qglTexParameterfv = dllTexParameterfv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexParameterfv");
qglTexParameteri = dllTexParameteri = GPA("glTexParameteri"); qglTexParameteri = dllTexParameteri = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexParameteri");
qglTexParameteriv = dllTexParameteriv = GPA("glTexParameteriv"); qglTexParameteriv = dllTexParameteriv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexParameteriv");
qglTexSubImage1D = dllTexSubImage1D = GPA("glTexSubImage1D"); qglTexSubImage1D = dllTexSubImage1D = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexSubImage1D");
qglTexSubImage2D = dllTexSubImage2D = GPA("glTexSubImage2D"); qglTexSubImage2D = dllTexSubImage2D = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTexSubImage2D");
qglTranslated = dllTranslated = GPA("glTranslated"); qglTranslated = dllTranslated = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTranslated");
qglTranslatef = dllTranslatef = GPA("glTranslatef"); qglTranslatef = dllTranslatef = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glTranslatef");
qglVertex2d = dllVertex2d = GPA("glVertex2d"); qglVertex2d = dllVertex2d = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex2d");
qglVertex2dv = dllVertex2dv = GPA("glVertex2dv"); qglVertex2dv = dllVertex2dv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex2dv");
qglVertex2f = dllVertex2f = GPA("glVertex2f"); qglVertex2f = dllVertex2f = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex2f");
qglVertex2fv = dllVertex2fv = GPA("glVertex2fv"); qglVertex2fv = dllVertex2fv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex2fv");
qglVertex2i = dllVertex2i = GPA("glVertex2i"); qglVertex2i = dllVertex2i = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex2i");
qglVertex2iv = dllVertex2iv = GPA("glVertex2iv"); qglVertex2iv = dllVertex2iv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex2iv");
qglVertex2s = dllVertex2s = GPA("glVertex2s"); qglVertex2s = dllVertex2s = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex2s");
qglVertex2sv = dllVertex2sv = GPA("glVertex2sv"); qglVertex2sv = dllVertex2sv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex2sv");
qglVertex3d = dllVertex3d = GPA("glVertex3d"); qglVertex3d = dllVertex3d = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex3d");
qglVertex3dv = dllVertex3dv = GPA("glVertex3dv"); qglVertex3dv = dllVertex3dv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex3dv");
qglVertex3f = dllVertex3f = GPA("glVertex3f"); qglVertex3f = dllVertex3f = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex3f");
qglVertex3fv = dllVertex3fv = GPA("glVertex3fv"); qglVertex3fv = dllVertex3fv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex3fv");
qglVertex3i = dllVertex3i = GPA("glVertex3i"); qglVertex3i = dllVertex3i = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex3i");
qglVertex3iv = dllVertex3iv = GPA("glVertex3iv"); qglVertex3iv = dllVertex3iv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex3iv");
qglVertex3s = dllVertex3s = GPA("glVertex3s"); qglVertex3s = dllVertex3s = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex3s");
qglVertex3sv = dllVertex3sv = GPA("glVertex3sv"); qglVertex3sv = dllVertex3sv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex3sv");
qglVertex4d = dllVertex4d = GPA("glVertex4d"); qglVertex4d = dllVertex4d = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex4d");
qglVertex4dv = dllVertex4dv = GPA("glVertex4dv"); qglVertex4dv = dllVertex4dv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex4dv");
qglVertex4f = dllVertex4f = GPA("glVertex4f"); qglVertex4f = dllVertex4f = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex4f");
qglVertex4fv = dllVertex4fv = GPA("glVertex4fv"); qglVertex4fv = dllVertex4fv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex4fv");
qglVertex4i = dllVertex4i = GPA("glVertex4i"); qglVertex4i = dllVertex4i = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex4i");
qglVertex4iv = dllVertex4iv = GPA("glVertex4iv"); qglVertex4iv = dllVertex4iv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex4iv");
qglVertex4s = dllVertex4s = GPA("glVertex4s"); qglVertex4s = dllVertex4s = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex4s");
qglVertex4sv = dllVertex4sv = GPA("glVertex4sv"); qglVertex4sv = dllVertex4sv = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertex4sv");
qglVertexPointer = dllVertexPointer = GPA("glVertexPointer"); qglVertexPointer = dllVertexPointer = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glVertexPointer");
qglViewport = dllViewport = GPA("glViewport"); qglViewport = dllViewport = ri.Sys_GetProcAddress(glw_state.OpenGLLib, "glViewport");
qglLockArraysEXT = 0; qglLockArraysEXT = 0;
qglUnlockArraysEXT = 0; qglUnlockArraysEXT = 0;

3
src/backends/sdl/refresh.c
View file

@ -26,14 +26,13 @@
*/ */
#include "../../refresh/header/local.h" #include "../../refresh/header/local.h"
#include "../generic/header/glwindow.h"
#include <GL/gl.h> #include <GL/gl.h>
#ifdef _WIN32 #ifdef _WIN32
#include <SDL/SDL.h> #include <SDL/SDL.h>
#include "../windows/header/glwindow.h"
#else #else
#include <SDL.h> #include <SDL.h>
#include "../unix/header/glwindow.h"
#endif #endif
/* The window icon */ /* The window icon */

3
src/backends/unix/vid.c
View file

@ -262,6 +262,9 @@ VID_LoadRefresh(char *name)
ri.Con_Printf = VID_Printf; ri.Con_Printf = VID_Printf;
ri.Sys_Error = VID_Error; ri.Sys_Error = VID_Error;
ri.Sys_Mkdir = Sys_Mkdir; ri.Sys_Mkdir = Sys_Mkdir;
ri.Sys_LoadLibrary = Sys_LoadLibrary;
ri.Sys_FreeLibrary = Sys_FreeLibrary;
ri.Sys_GetProcAddress = Sys_GetProcAddress;
ri.FS_LoadFile = FS_LoadFile; ri.FS_LoadFile = FS_LoadFile;
ri.FS_FreeFile = FS_FreeFile; ri.FS_FreeFile = FS_FreeFile;
ri.FS_Gamedir = FS_Gamedir; ri.FS_Gamedir = FS_Gamedir;

52
src/backends/windows/header/glwindow.h
View file

@ -1,52 +0,0 @@
/*
* Copyright (C) 1997-2001 Id Software, Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*
* =======================================================================
*
* This file holds the main struct for the OpenGL context
*
* =======================================================================
*/
#ifndef WIN_GLW_WIN_H__
#define WIN_GLW_WIN_H__
#include <windows.h>
typedef struct
{
HINSTANCE hInstance;
void *wndproc;
HDC hDC; /* handle to device context */
HWND hWnd; /* handle to window */
HGLRC hGLRC; /* handle to GL rendering context */
HINSTANCE hinstOpenGL; /* HINSTANCE for the OpenGL library */
qboolean minidriver;
qboolean allowdisplaydepthchange;
qboolean mcd_accelerated;
FILE *log_fp;
} glwstate_t;
extern glwstate_t glw_state;
#endif

4769
src/backends/windows/qgl.c
View file

File diff suppressed because it is too large Load diff

24
src/backends/windows/vid.c
View file

@ -185,27 +185,6 @@ VID_GetModeInfo(int *width, int *height, int mode)
return true; return true;
} }
void
VID_UpdateWindowPosAndSize(int x, int y)
{
RECT r;
int style;
int w, h;
r.left = 0;
r.top = 0;
r.right = viddef.width;
r.bottom = viddef.height;
style = GetWindowLong(cl_hwnd, GWL_STYLE);
AdjustWindowRect(&r, style, FALSE);
w = r.right - r.left;
h = r.bottom - r.top;
MoveWindow(cl_hwnd, vid_xpos->value, vid_ypos->value, w, h, TRUE);
}
void void
VID_NewWindow(int width, int height) VID_NewWindow(int width, int height)
{ {
@ -291,6 +270,9 @@ VID_LoadRefresh(char *name)
ri.Con_Printf = VID_Printf; ri.Con_Printf = VID_Printf;
ri.Sys_Error = VID_Error; ri.Sys_Error = VID_Error;
ri.Sys_Mkdir = Sys_Mkdir; ri.Sys_Mkdir = Sys_Mkdir;
ri.Sys_LoadLibrary = Sys_LoadLibrary;
ri.Sys_FreeLibrary = Sys_FreeLibrary;
ri.Sys_GetProcAddress = Sys_GetProcAddress;
ri.FS_LoadFile = FS_LoadFile; ri.FS_LoadFile = FS_LoadFile;
ri.FS_FreeFile = FS_FreeFile; ri.FS_FreeFile = FS_FreeFile;
ri.FS_Gamedir = FS_Gamedir; ri.FS_Gamedir = FS_Gamedir;

3
src/client/header/ref.h
View file

@ -176,6 +176,9 @@ typedef struct {
typedef struct { typedef struct {
void (*Sys_Error)(int err_level, char *str, ...); void (*Sys_Error)(int err_level, char *str, ...);
void (*Sys_Mkdir)(char *path); void (*Sys_Mkdir)(char *path);
void (*Sys_FreeLibrary)(void *handle);
void *(*Sys_LoadLibrary)(const char *path, const char *sym, void **handle);
void *(*Sys_GetProcAddress)(void *handle, const char *sym);
void (*Cmd_AddCommand)(char *name, void(*cmd)(void)); void (*Cmd_AddCommand)(char *name, void(*cmd)(void));
void (*Cmd_RemoveCommand)(char *name); void (*Cmd_RemoveCommand)(char *name);

2
src/refresh/header/local.h
View file

@ -33,7 +33,7 @@
#include <GL/gl.h> #include <GL/gl.h>
#include "../../client/header/ref.h" #include "../../client/header/ref.h"
#include "qgl.h" #include "../../backends/generic/header/qgl.h"
#ifndef GL_COLOR_INDEX8_EXT #ifndef GL_COLOR_INDEX8_EXT
#define GL_COLOR_INDEX8_EXT GL_COLOR_INDEX #define GL_COLOR_INDEX8_EXT GL_COLOR_INDEX