zdoom/raze-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/raze-gles.git synced 2024-12-26 19:50:45 +00:00
Code Issues Projects Releases Packages Wiki Activity
raze-gles/polymer/eduke32/build/src/glbuild.c
helixhorned 28bbde2377 Fix 'realloc' routine of GL texture name (id) debugging code. 
git-svn-id: https://svn.eduke32.com/eduke32@2618 1a8010ca-5511-0410-912e-c29ae57300e0
2012-04-29 20:54:37 +00:00

1118 lines
45 KiB
C
Raw Blame History

#include "compat.h"
#include "glbuild.h"
#include "baselayer.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#if defined USE_OPENGL
#ifdef RENDERTYPESDL
#include "sdl_inc.h"
#endif
void (APIENTRY *bglClearColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
void (APIENTRY *bglClear)(GLbitfield mask);
void (APIENTRY *bglColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
void (APIENTRY *bglAlphaFunc)(GLenum func, GLclampf ref);
void (APIENTRY *bglBlendFunc)(GLenum sfactor, GLenum dfactor);
void (APIENTRY *bglCullFace)(GLenum mode);
void (APIENTRY *bglFrontFace)(GLenum mode);
void (APIENTRY *bglPolygonOffset)(GLfloat factor, GLfloat units);
void (APIENTRY *bglPolygonMode)(GLenum face, GLenum mode);
void (APIENTRY *bglEnable)(GLenum cap);
void (APIENTRY *bglDisable)(GLenum cap);
void (APIENTRY *bglGetDoublev)(GLenum pname, GLdouble *params);
void (APIENTRY *bglGetFloatv)(GLenum pname, GLfloat *params);
void (APIENTRY *bglGetIntegerv)(GLenum pname, GLint *params);
void (APIENTRY *bglPushAttrib)(GLbitfield mask);
void (APIENTRY *bglPopAttrib)(void);
GLenum(APIENTRY *bglGetError)(void);
const GLubyte *(APIENTRY *bglGetString)(GLenum name);
void (APIENTRY *bglHint)(GLenum target, GLenum mode);
void (APIENTRY *bglDrawBuffer)(GLenum mode);
void (APIENTRY *bglReadBuffer)(GLenum mode);
void (APIENTRY *bglScissor)(GLint x, GLint y, GLsizei width, GLsizei height);
void (APIENTRY *bglClipPlane)(GLenum plane, const GLdouble *equation);
// Depth
void (APIENTRY *bglDepthFunc)(GLenum func);
void (APIENTRY *bglDepthMask)(GLboolean flag);
void (APIENTRY *bglDepthRange)(GLclampd near_val, GLclampd far_val);
// Matrix
void (APIENTRY *bglMatrixMode)(GLenum mode);
void (APIENTRY *bglOrtho)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val);
void (APIENTRY *bglFrustum)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val);
void (APIENTRY *bglViewport)(GLint x, GLint y, GLsizei width, GLsizei height);
void (APIENTRY *bglPushMatrix)(void);
void (APIENTRY *bglPopMatrix)(void);
void (APIENTRY *bglLoadIdentity)(void);
void (APIENTRY *bglLoadMatrixf)(const GLfloat *m);
void (APIENTRY *bglLoadMatrixd)(const GLdouble *m);
void (APIENTRY *bglMultMatrixf)(const GLfloat *m);
void (APIENTRY *bglMultMatrixd)(const GLdouble *m);
void (APIENTRY *bglRotatef)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
void (APIENTRY *bglScalef)(GLfloat x, GLfloat y, GLfloat z);
void (APIENTRY *bglTranslatef)(GLfloat x, GLfloat y, GLfloat z);
// Drawing
void (APIENTRY *bglBegin)(GLenum mode);
void (APIENTRY *bglEnd)(void);
void (APIENTRY *bglVertex2f)(GLfloat x, GLfloat y);
void (APIENTRY *bglVertex2i)(GLint x, GLint y);
void (APIENTRY *bglVertex3f)(GLfloat x, GLfloat y, GLfloat z);
void (APIENTRY *bglVertex3d)(GLdouble x, GLdouble y, GLdouble z);
void (APIENTRY *bglVertex3fv)(const GLfloat *v);
void (APIENTRY *bglVertex3dv)(const GLdouble *v);
void (APIENTRY *bglColor4f)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
void (APIENTRY *bglColor4ub)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
void (APIENTRY *bglTexCoord2d)(GLdouble s, GLdouble t);
void (APIENTRY *bglTexCoord2f)(GLfloat s, GLfloat t);
void (APIENTRY *bglTexCoord2i)(GLint s, GLint t);
void (APIENTRY *bglNormal3f)(GLfloat x, GLfloat y, GLfloat z);
// Lighting
void (APIENTRY *bglShadeModel)(GLenum mode);
void (APIENTRY *bglLightfv)(GLenum light, GLenum pname, const GLfloat *params);
// Raster funcs
void (APIENTRY *bglReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
void (APIENTRY *bglRasterPos4i)(GLint x, GLint y, GLint z, GLint w);
void (APIENTRY *bglDrawPixels)(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
void (APIENTRY *bglPixelStorei)(GLenum pname, GLint param);
// Texture mapping
void (APIENTRY *bglTexEnvf)(GLenum target, GLenum pname, GLfloat param);
void (APIENTRY *bglGenTextures)(GLsizei n, GLuint *textures); // 1.1
void (APIENTRY *bglDeleteTextures)(GLsizei n, const GLuint *textures); // 1.1
void (APIENTRY *bglBindTexture)(GLenum target, GLuint texture); // 1.1
void (APIENTRY *bglTexImage2D)(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
void (APIENTRY *bglTexImage3D)(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
void (APIENTRY *bglCopyTexImage2D)(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
void (APIENTRY *bglCopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
void (APIENTRY *bglTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels); // 1.1
void (APIENTRY *bglTexParameterf)(GLenum target, GLenum pname, GLfloat param);
void (APIENTRY *bglTexParameteri)(GLenum target, GLenum pname, GLint param);
void (APIENTRY *bglGetTexParameteriv)(GLenum target, GLenum pname, GLint *params);
void (APIENTRY *bglGetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint *params);
void (APIENTRY *bglCompressedTexImage2DARB)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *);
void (APIENTRY *bglGetCompressedTexImageARB)(GLenum, GLint, GLvoid *);
void (APIENTRY *bglTexGenfv)(GLenum coord, GLenum pname, const GLfloat *params);
// Fog
void (APIENTRY *bglFogf)(GLenum pname, GLfloat param);
void (APIENTRY *bglFogi)(GLenum pname, GLint param);
void (APIENTRY *bglFogfv)(GLenum pname, const GLfloat *params);
// Display Lists
void (APIENTRY *bglNewList)(GLuint list, GLenum mode);
void (APIENTRY *bglEndList)(void);
void (APIENTRY *bglCallList)(GLuint list);
void (APIENTRY *bglDeleteLists)(GLuint list, GLsizei range);
// Vertex Arrays
void (APIENTRY *bglEnableClientState)(GLenum cap);
void (APIENTRY *bglDisableClientState)(GLenum cap);
void (APIENTRY *bglVertexPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
void (APIENTRY *bglNormalPointer)(GLenum type, GLsizei stride, const GLvoid *pointer);
void (APIENTRY *bglTexCoordPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
void (APIENTRY *bglDrawArrays)(GLenum mode, GLint first, GLsizei count);
void (APIENTRY *bglDrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
// Stencil Buffer
void (APIENTRY *bglClearStencil)(GLint s);
void (APIENTRY *bglStencilOp)(GLenum fail, GLenum zfail, GLenum zpass);
void (APIENTRY *bglStencilFunc)(GLenum func, GLint ref, GLuint mask);
// GPU Programs
void (APIENTRY *bglGenProgramsARB)(GLsizei, GLuint *);
void (APIENTRY *bglBindProgramARB)(GLenum, GLuint);
void (APIENTRY *bglProgramStringARB)(GLenum, GLenum, GLsizei, const GLvoid *);
void (APIENTRY *bglDeleteProgramsARB)(GLsizei n, const GLuint *programs);
// Multitexturing
void (APIENTRY *bglActiveTextureARB)(GLenum texture);
void (APIENTRY *bglClientActiveTextureARB)(GLenum texture);
void (APIENTRY *bglMultiTexCoord2dARB)(GLenum target, GLdouble s, GLdouble t);
void (APIENTRY *bglMultiTexCoord2fARB)(GLenum target, GLfloat s, GLfloat t);
// Frame Buffer Objects
void (APIENTRY *bglGenFramebuffersEXT)(GLsizei n, GLuint *framebuffers);
void (APIENTRY *bglBindFramebufferEXT)(GLenum target, GLuint framebuffer);
void (APIENTRY *bglFramebufferTexture2DEXT)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
GLenum(APIENTRY *bglCheckFramebufferStatusEXT)(GLenum target);
void (APIENTRY *bglDeleteFramebuffersEXT)(GLsizei n, const GLuint *framebuffers);
// Vertex Buffer Objects
void (APIENTRY *bglGenBuffersARB)(GLsizei n, GLuint *buffers);
void (APIENTRY *bglBindBufferARB)(GLenum target, GLuint buffer);
void (APIENTRY *bglDeleteBuffersARB)(GLsizei n, const GLuint *buffers);
void (APIENTRY *bglBufferDataARB)(GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage);
void (APIENTRY *bglBufferSubDataARB)(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data);
void *(APIENTRY *bglMapBufferARB)(GLenum target, GLenum access);
GLboolean(APIENTRY *bglUnmapBufferARB)(GLenum target);
// Occlusion queries
void (APIENTRY *bglGenQueriesARB)(GLsizei n, GLuint *ids);
void (APIENTRY *bglDeleteQueriesARB)(GLsizei n, const GLuint *ids);
GLboolean(APIENTRY *bglIsQueryARB)(GLuint id);
void (APIENTRY *bglBeginQueryARB)(GLenum target, GLuint id);
void (APIENTRY *bglEndQueryARB)(GLenum target);
void (APIENTRY *bglGetQueryivARB)(GLenum target, GLenum pname, GLint *params);
void (APIENTRY *bglGetQueryObjectivARB)(GLuint id, GLenum pname, GLint *params);
void (APIENTRY *bglGetQueryObjectuivARB)(GLuint id, GLenum pname, GLuint *params);
// Shader Objects
void (APIENTRY *bglDeleteObjectARB)(GLhandleARB);
GLhandleARB(APIENTRY *bglGetHandleARB)(GLenum);
void (APIENTRY *bglDetachObjectARB)(GLhandleARB, GLhandleARB);
GLhandleARB(APIENTRY *bglCreateShaderObjectARB)(GLenum);
void (APIENTRY *bglShaderSourceARB)(GLhandleARB, GLsizei, const GLcharARB* *, const GLint *);
void (APIENTRY *bglCompileShaderARB)(GLhandleARB);
GLhandleARB(APIENTRY *bglCreateProgramObjectARB)(void);
void (APIENTRY *bglAttachObjectARB)(GLhandleARB, GLhandleARB);
void (APIENTRY *bglLinkProgramARB)(GLhandleARB);
void (APIENTRY *bglUseProgramObjectARB)(GLhandleARB);
void (APIENTRY *bglValidateProgramARB)(GLhandleARB);
void (APIENTRY *bglUniform1fARB)(GLint, GLfloat);
void (APIENTRY *bglUniform2fARB)(GLint, GLfloat, GLfloat);
void (APIENTRY *bglUniform3fARB)(GLint, GLfloat, GLfloat, GLfloat);
void (APIENTRY *bglUniform4fARB)(GLint, GLfloat, GLfloat, GLfloat, GLfloat);
void (APIENTRY *bglUniform1iARB)(GLint, GLint);
void (APIENTRY *bglUniform2iARB)(GLint, GLint, GLint);
void (APIENTRY *bglUniform3iARB)(GLint, GLint, GLint, GLint);
void (APIENTRY *bglUniform4iARB)(GLint, GLint, GLint, GLint, GLint);
void (APIENTRY *bglUniform1fvARB)(GLint, GLsizei, const GLfloat *);
void (APIENTRY *bglUniform2fvARB)(GLint, GLsizei, const GLfloat *);
void (APIENTRY *bglUniform3fvARB)(GLint, GLsizei, const GLfloat *);
void (APIENTRY *bglUniform4fvARB)(GLint, GLsizei, const GLfloat *);
void (APIENTRY *bglUniform1ivARB)(GLint, GLsizei, const GLint *);
void (APIENTRY *bglUniform2ivARB)(GLint, GLsizei, const GLint *);
void (APIENTRY *bglUniform3ivARB)(GLint, GLsizei, const GLint *);
void (APIENTRY *bglUniform4ivARB)(GLint, GLsizei, const GLint *);
void (APIENTRY *bglUniformMatrix2fvARB)(GLint, GLsizei, GLboolean, const GLfloat *);
void (APIENTRY *bglUniformMatrix3fvARB)(GLint, GLsizei, GLboolean, const GLfloat *);
void (APIENTRY *bglUniformMatrix4fvARB)(GLint, GLsizei, GLboolean, const GLfloat *);
void (APIENTRY *bglGetObjectParameterfvARB)(GLhandleARB, GLenum, GLfloat *);
void (APIENTRY *bglGetObjectParameterivARB)(GLhandleARB, GLenum, GLint *);
void (APIENTRY *bglGetInfoLogARB)(GLhandleARB, GLsizei, GLsizei *, GLcharARB *);
void (APIENTRY *bglGetAttachedObjectsARB)(GLhandleARB, GLsizei, GLsizei *, GLhandleARB *);
GLint(APIENTRY *bglGetUniformLocationARB)(GLhandleARB, const GLcharARB *);
void (APIENTRY *bglGetActiveUniformARB)(GLhandleARB, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLcharARB *);
void (APIENTRY *bglGetUniformfvARB)(GLhandleARB, GLint, GLfloat *);
void (APIENTRY *bglGetUniformivARB)(GLhandleARB, GLint, GLint *);
void (APIENTRY *bglGetShaderSourceARB)(GLhandleARB, GLsizei, GLsizei *, GLcharARB *);
// Vertex Shaders
void (APIENTRY *bglVertexAttrib1dARB)(GLuint, GLdouble);
void (APIENTRY *bglVertexAttrib1dvARB)(GLuint, const GLdouble *);
void (APIENTRY *bglVertexAttrib1fARB)(GLuint, GLfloat);
void (APIENTRY *bglVertexAttrib1fvARB)(GLuint, const GLfloat *);
void (APIENTRY *bglVertexAttrib1sARB)(GLuint, GLshort);
void (APIENTRY *bglVertexAttrib1svARB)(GLuint, const GLshort *);
void (APIENTRY *bglVertexAttrib2dARB)(GLuint, GLdouble, GLdouble);
void (APIENTRY *bglVertexAttrib2dvARB)(GLuint, const GLdouble *);
void (APIENTRY *bglVertexAttrib2fARB)(GLuint, GLfloat, GLfloat);
void (APIENTRY *bglVertexAttrib2fvARB)(GLuint, const GLfloat *);
void (APIENTRY *bglVertexAttrib2sARB)(GLuint, GLshort, GLshort);
void (APIENTRY *bglVertexAttrib2svARB)(GLuint, const GLshort *);
void (APIENTRY *bglVertexAttrib3dARB)(GLuint, GLdouble, GLdouble, GLdouble);
void (APIENTRY *bglVertexAttrib3dvARB)(GLuint, const GLdouble *);
void (APIENTRY *bglVertexAttrib3fARB)(GLuint, GLfloat, GLfloat, GLfloat);
void (APIENTRY *bglVertexAttrib3fvARB)(GLuint, const GLfloat *);
void (APIENTRY *bglVertexAttrib3sARB)(GLuint, GLshort, GLshort, GLshort);
void (APIENTRY *bglVertexAttrib3svARB)(GLuint, const GLshort *);
void (APIENTRY *bglVertexAttrib4NbvARB)(GLuint, const GLbyte *);
void (APIENTRY *bglVertexAttrib4NivARB)(GLuint, const GLint *);
void (APIENTRY *bglVertexAttrib4NsvARB)(GLuint, const GLshort *);
void (APIENTRY *bglVertexAttrib4NubARB)(GLuint, GLubyte, GLubyte, GLubyte, GLubyte);
void (APIENTRY *bglVertexAttrib4NubvARB)(GLuint, const GLubyte *);
void (APIENTRY *bglVertexAttrib4NuivARB)(GLuint, const GLuint *);
void (APIENTRY *bglVertexAttrib4NusvARB)(GLuint, const GLushort *);
void (APIENTRY *bglVertexAttrib4bvARB)(GLuint, const GLbyte *);
void (APIENTRY *bglVertexAttrib4dARB)(GLuint, GLdouble, GLdouble, GLdouble, GLdouble);
void (APIENTRY *bglVertexAttrib4dvARB)(GLuint, const GLdouble *);
void (APIENTRY *bglVertexAttrib4fARB)(GLuint, GLfloat, GLfloat, GLfloat, GLfloat);
void (APIENTRY *bglVertexAttrib4fvARB)(GLuint, const GLfloat *);
void (APIENTRY *bglVertexAttrib4ivARB)(GLuint, const GLint *);
void (APIENTRY *bglVertexAttrib4sARB)(GLuint, GLshort, GLshort, GLshort, GLshort);
void (APIENTRY *bglVertexAttrib4svARB)(GLuint, const GLshort *);
void (APIENTRY *bglVertexAttrib4ubvARB)(GLuint, const GLubyte *);
void (APIENTRY *bglVertexAttrib4uivARB)(GLuint, const GLuint *);
void (APIENTRY *bglVertexAttrib4usvARB)(GLuint, const GLushort *);
void (APIENTRY *bglVertexAttribPointerARB)(GLuint, GLint, GLenum, GLboolean, GLsizei, const GLvoid *);
void (APIENTRY *bglEnableVertexAttribArrayARB)(GLuint);
void (APIENTRY *bglDisableVertexAttribArrayARB)(GLuint);
void (APIENTRY *bglGetVertexAttribdvARB)(GLuint, GLenum, GLdouble *);
void (APIENTRY *bglGetVertexAttribfvARB)(GLuint, GLenum, GLfloat *);
void (APIENTRY *bglGetVertexAttribivARB)(GLuint, GLenum, GLint *);
void (APIENTRY *bglGetVertexAttribPointervARB)(GLuint, GLenum, GLvoid* *);
void (APIENTRY *bglBindAttribLocationARB)(GLhandleARB, GLuint, const GLcharARB *);
void (APIENTRY *bglGetActiveAttribARB)(GLhandleARB, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLcharARB *);
GLint(APIENTRY *bglGetAttribLocationARB)(GLhandleARB, const GLcharARB *);
// Debug Output
#ifndef __APPLE__
void (APIENTRY * bglDebugMessageControlARB)(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled);
void (APIENTRY * bglDebugMessageCallbackARB)(GLDEBUGPROCARB callback, const GLvoid *userParam);
#endif
// GLU
void (APIENTRY *bgluTessBeginContour)(GLUtesselator *tess);
void (APIENTRY *bgluTessBeginPolygon)(GLUtesselator *tess, GLvoid *data);
void (APIENTRY *bgluTessCallback)(GLUtesselator *tess, GLenum which, void (PR_CALLBACK CallBackFunc)());
void (APIENTRY *bgluTessEndContour)(GLUtesselator *tess);
void (APIENTRY *bgluTessEndPolygon)(GLUtesselator *tess);
void (APIENTRY *bgluTessNormal)(GLUtesselator *tess, GLdouble valueX, GLdouble valueY, GLdouble valueZ);
void (APIENTRY *bgluTessProperty)(GLUtesselator *tess, GLenum which, GLdouble data);
void (APIENTRY *bgluTessVertex)(GLUtesselator *tess, GLdouble *location, GLvoid *data);
GLUtesselator *(APIENTRY *bgluNewTess)(void);
void (APIENTRY * bgluDeleteTess)(GLUtesselator *tess);
void (APIENTRY *bgluPerspective)(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar);
const GLubyte *(APIENTRY *bgluErrorString)(GLenum error);
GLint(APIENTRY *bgluProject)(GLdouble objX, GLdouble objY, GLdouble objZ, const GLdouble *model, const GLdouble *proj, const GLint *view, GLdouble *winX, GLdouble *winY, GLdouble *winZ);
GLint(APIENTRY *bgluUnProject)(GLdouble winX, GLdouble winY, GLdouble winZ, const GLdouble *model, const GLdouble *proj, const GLint *view, GLdouble *objX, GLdouble *objY, GLdouble *objZ);
#ifdef RENDERTYPEWIN
// Windows
HGLRC(WINAPI *bwglCreateContext)(HDC);
BOOL (WINAPI *bwglDeleteContext)(HGLRC);
PROC(WINAPI *bwglGetProcAddress)(LPCSTR);
BOOL (WINAPI *bwglMakeCurrent)(HDC,HGLRC);
BOOL (WINAPI *bwglSwapBuffers)(HDC);
int32_t (WINAPI *bwglChoosePixelFormat)(HDC,CONST PIXELFORMATDESCRIPTOR *);
int32_t (WINAPI *bwglDescribePixelFormat)(HDC,int32_t,UINT,LPPIXELFORMATDESCRIPTOR);
int32_t (WINAPI *bwglGetPixelFormat)(HDC);
BOOL (WINAPI *bwglSetPixelFormat)(HDC,int32_t,const PIXELFORMATDESCRIPTOR *);
BOOL (WINAPI *bwglSwapIntervalEXT)(int32_t);
HGLRC (WINAPI * bwglCreateContextAttribsARB)(HDC hDC, HGLRC hShareContext, const int *attribList);
static HANDLE hGLDLL, hGLUDLL;
#else
#include <dlfcn.h>
static void *gluhandle = NULL;
#endif
char *gldriver = NULL, *glulibrary = NULL;
static void *getproc_(const char *s, int32_t *err, int32_t fatal, int32_t extension)
{
void *t;
#if defined RENDERTYPESDL
UNREFERENCED_PARAMETER(extension);
t = (void *)SDL_GL_GetProcAddress(s);
#elif defined _WIN32
if (extension) t = (void *)bwglGetProcAddress(s);
else t = (void *)GetProcAddress(hGLDLL,s);
#else
#error Need a dynamic loader for this platform...
#endif
if (!t && fatal)
{
initprintf("Failed to find %s in %s\n", s, gldriver);
*err = 1;
}
return t;
}
#define GETPROC(s) getproc_(s,&err,1,0)
#define GETPROCSOFT(s) getproc_(s,&err,0,0)
#define GETPROCEXT(s) getproc_(s,&err,1,1)
#define GETPROCEXTSOFT(s) getproc_(s,&err,0,1)
int32_t loadgldriver(const char *driver)
{
int32_t err=0;
#ifdef RENDERTYPEWIN
if (hGLDLL) return 0;
#endif
if (!driver)
{
#ifdef _WIN32
driver = "opengl32.dll";
#elif defined __APPLE__
driver = "/System/Library/Frameworks/OpenGL.framework/OpenGL";
#else
driver = "libGL.so.1";
#endif
}
#if defined RENDERTYPESDL
if (SDL_GL_LoadLibrary(driver)) goto fail;
#elif defined _WIN32
hGLDLL = LoadLibrary(driver);
if (!hGLDLL) goto fail;
#endif
gldriver = Bstrdup(driver);
#ifdef RENDERTYPEWIN
bwglCreateContext = GETPROC("wglCreateContext");
bwglDeleteContext = GETPROC("wglDeleteContext");
bwglGetProcAddress = GETPROC("wglGetProcAddress");
bwglMakeCurrent = GETPROC("wglMakeCurrent");
bwglSwapBuffers = GETPROC("wglSwapBuffers");
bwglChoosePixelFormat = GETPROC("wglChoosePixelFormat");
bwglDescribePixelFormat = GETPROC("wglDescribePixelFormat");
bwglGetPixelFormat = GETPROC("wglGetPixelFormat");
bwglSetPixelFormat = GETPROC("wglSetPixelFormat");
#endif
bglClearColor = GETPROC("glClearColor");
bglClear = GETPROC("glClear");
bglColorMask = GETPROC("glColorMask");
bglAlphaFunc = GETPROC("glAlphaFunc");
bglBlendFunc = GETPROC("glBlendFunc");
bglCullFace = GETPROC("glCullFace");
bglFrontFace = GETPROC("glFrontFace");
bglPolygonOffset = GETPROC("glPolygonOffset");
bglPolygonMode = GETPROC("glPolygonMode");
bglEnable = GETPROC("glEnable");
bglDisable = GETPROC("glDisable");
bglGetDoublev = GETPROC("glGetDoublev");
bglGetFloatv = GETPROC("glGetFloatv");
bglGetIntegerv = GETPROC("glGetIntegerv");
bglPushAttrib = GETPROC("glPushAttrib");
bglPopAttrib = GETPROC("glPopAttrib");
bglGetError = GETPROC("glGetError");
bglGetString = GETPROC("glGetString");
bglHint = GETPROC("glHint");
bglDrawBuffer = GETPROC("glDrawBuffer");
bglReadBuffer = GETPROC("glDrawBuffer");
bglScissor = GETPROC("glScissor");
bglClipPlane = GETPROC("glClipPlane");
// Depth
bglDepthFunc = GETPROC("glDepthFunc");
bglDepthMask = GETPROC("glDepthMask");
bglDepthRange = GETPROC("glDepthRange");
// Matrix
bglMatrixMode = GETPROC("glMatrixMode");
bglOrtho = GETPROC("glOrtho");
bglFrustum = GETPROC("glFrustum");
bglViewport = GETPROC("glViewport");
bglPushMatrix = GETPROC("glPushMatrix");
bglPopMatrix = GETPROC("glPopMatrix");
bglLoadIdentity = GETPROC("glLoadIdentity");
bglLoadMatrixf = GETPROC("glLoadMatrixf");
bglLoadMatrixd = GETPROC("glLoadMatrixd");
bglMultMatrixf = GETPROC("glMultMatrixf");
bglMultMatrixd = GETPROC("glMultMatrixd");
bglRotatef = GETPROC("glRotatef");
bglScalef = GETPROC("glScalef");
bglTranslatef = GETPROC("glTranslatef");
// Drawing
bglBegin = GETPROC("glBegin");
bglEnd = GETPROC("glEnd");
bglVertex2f = GETPROC("glVertex2f");
bglVertex2i = GETPROC("glVertex2i");
bglVertex3f = GETPROC("glVertex3f");
bglVertex3d = GETPROC("glVertex3d");
bglVertex3fv = GETPROC("glVertex3fv");
bglVertex3dv = GETPROC("glVertex3dv");
bglColor4f = GETPROC("glColor4f");
bglColor4ub = GETPROC("glColor4ub");
bglTexCoord2d = GETPROC("glTexCoord2d");
bglTexCoord2f = GETPROC("glTexCoord2f");
bglTexCoord2i = GETPROC("glTexCoord2i");
bglNormal3f = GETPROC("glNormal3f");
// Lighting
bglShadeModel = GETPROC("glShadeModel");
bglLightfv = GETPROC("glLightfv");
// Raster funcs
bglReadPixels = GETPROC("glReadPixels");
bglRasterPos4i = GETPROC("glRasterPos4i");
bglDrawPixels = GETPROC("glDrawPixels");
bglPixelStorei = GETPROC("glPixelStorei");
// Texture mapping
bglTexEnvf = GETPROC("glTexEnvf");
bglGenTextures = GETPROC("glGenTextures");
bglDeleteTextures = GETPROC("glDeleteTextures");
bglBindTexture = GETPROC("glBindTexture");
bglTexImage2D = GETPROC("glTexImage2D");
bglCopyTexImage2D = GETPROC("glCopyTexImage2D");
bglCopyTexSubImage2D= GETPROC("glCopyTexSubImage2D");
bglTexSubImage2D = GETPROC("glTexSubImage2D");
bglTexParameterf = GETPROC("glTexParameterf");
bglTexParameteri = GETPROC("glTexParameteri");
bglGetTexParameteriv = GETPROC("glGetTexParameteriv");
bglGetTexLevelParameteriv = GETPROC("glGetTexLevelParameteriv");
bglTexGenfv = GETPROC("glTexGenfv");
// Fog
bglFogf = GETPROC("glFogf");
bglFogi = GETPROC("glFogi");
bglFogfv = GETPROC("glFogfv");
// Display Lists
bglNewList = GETPROC("glNewList");
bglEndList = GETPROC("glEndList");
bglCallList = GETPROC("glCallList");
bglDeleteLists = GETPROC("glDeleteLists");
// Vertex Arrays
bglEnableClientState = GETPROC("glEnableClientState");
bglDisableClientState = GETPROC("glDisableClientState");
bglVertexPointer = GETPROC("glVertexPointer");
bglNormalPointer = GETPROC("glNormalPointer");
bglTexCoordPointer = GETPROC("glTexCoordPointer");
bglDrawArrays = GETPROC("glDrawArrays");
bglDrawElements = GETPROC("glDrawElements");
// Stencil Buffer
bglClearStencil = GETPROC("glClearStencil");
bglStencilOp = GETPROC("glStencilOp");
bglStencilFunc = GETPROC("glStencilFunc");
loadglextensions();
loadglulibrary(getenv("BUILD_GLULIB"));
if (err) unloadgldriver();
return err;
fail:
initprintf("Failed loading \"%s\"\n",driver);
return -1;
}
int32_t loadglextensions(void)
{
int32_t err = 0;
#ifdef RENDERTYPEWIN
if (!hGLDLL) return 0;
#endif
bglTexImage3D = GETPROCEXTSOFT("glTexImage3D");
bglCompressedTexImage2DARB = GETPROCEXTSOFT("glCompressedTexImage2DARB");
bglGetCompressedTexImageARB = GETPROCEXTSOFT("glGetCompressedTexImageARB");
// GPU Programs
bglGenProgramsARB = GETPROCEXTSOFT("glGenProgramsARB");
bglBindProgramARB = GETPROCEXTSOFT("glBindProgramARB");
bglProgramStringARB = GETPROCEXTSOFT("glProgramStringARB");
bglDeleteProgramsARB= GETPROCEXTSOFT("glDeleteProgramsARB");
// Multitexturing
bglActiveTextureARB = GETPROCEXTSOFT("glActiveTextureARB");
bglClientActiveTextureARB = GETPROCEXTSOFT("glClientActiveTextureARB");
bglMultiTexCoord2dARB = GETPROCEXTSOFT("glMultiTexCoord2dARB");
bglMultiTexCoord2fARB = GETPROCEXTSOFT("glMultiTexCoord2fARB");
// Frame Buffer Objects
bglGenFramebuffersEXT = GETPROCEXTSOFT("glGenFramebuffersEXT");
bglBindFramebufferEXT = GETPROCEXTSOFT("glBindFramebufferEXT");
bglFramebufferTexture2DEXT = GETPROCEXTSOFT("glFramebufferTexture2DEXT");
bglCheckFramebufferStatusEXT = GETPROCEXTSOFT("glCheckFramebufferStatusEXT");
bglDeleteFramebuffersEXT = GETPROCEXTSOFT("glDeleteFramebuffersEXT");
// Vertex Buffer Objects
bglGenBuffersARB = GETPROCEXTSOFT("glGenBuffersARB");
bglBindBufferARB = GETPROCEXTSOFT("glBindBufferARB");
bglDeleteBuffersARB = GETPROCEXTSOFT("glDeleteBuffersARB");
bglBufferDataARB = GETPROCEXTSOFT("glBufferDataARB");
bglBufferSubDataARB = GETPROCEXTSOFT("glBufferSubDataARB");
bglMapBufferARB = GETPROCEXTSOFT("glMapBufferARB");
bglUnmapBufferARB = GETPROCEXTSOFT("glUnmapBufferARB");
// Occlusion queries
bglGenQueriesARB = GETPROCEXTSOFT("glGenQueriesARB");
bglDeleteQueriesARB = GETPROCEXTSOFT("glDeleteQueriesARB");
bglIsQueryARB = GETPROCEXTSOFT("glIsQueryARB");
bglBeginQueryARB = GETPROCEXTSOFT("glBeginQueryARB");
bglEndQueryARB = GETPROCEXTSOFT("glEndQueryARB");
bglGetQueryivARB = GETPROCEXTSOFT("glGetQueryivARB");
bglGetQueryObjectivARB = GETPROCEXTSOFT("glGetQueryObjectivARB");
bglGetQueryObjectuivARB = GETPROCEXTSOFT("glGetQueryObjectuivARB");
// Shader Objects
bglDeleteObjectARB = GETPROCEXTSOFT("glDeleteObjectARB");
bglGetHandleARB = GETPROCEXTSOFT("glGetHandleARB");
bglDetachObjectARB = GETPROCEXTSOFT("glDetachObjectARB");
bglCreateShaderObjectARB = GETPROCEXTSOFT("glCreateShaderObjectARB");
bglShaderSourceARB = GETPROCEXTSOFT("glShaderSourceARB");
bglCompileShaderARB = GETPROCEXTSOFT("glCompileShaderARB");
bglCreateProgramObjectARB = GETPROCEXTSOFT("glCreateProgramObjectARB");
bglAttachObjectARB = GETPROCEXTSOFT("glAttachObjectARB");
bglLinkProgramARB = GETPROCEXTSOFT("glLinkProgramARB");
bglUseProgramObjectARB = GETPROCEXTSOFT("glUseProgramObjectARB");
bglValidateProgramARB = GETPROCEXTSOFT("glValidateProgramARB");
bglUniform1fARB = GETPROCEXTSOFT("glUniform1fARB");
bglUniform2fARB = GETPROCEXTSOFT("glUniform2fARB");
bglUniform3fARB = GETPROCEXTSOFT("glUniform3fARB");
bglUniform4fARB = GETPROCEXTSOFT("glUniform4fARB");
bglUniform1iARB = GETPROCEXTSOFT("glUniform1iARB");
bglUniform2iARB = GETPROCEXTSOFT("glUniform2iARB");
bglUniform3iARB = GETPROCEXTSOFT("glUniform3iARB");
bglUniform4iARB = GETPROCEXTSOFT("glUniform4iARB");
bglUniform1fvARB = GETPROCEXTSOFT("glUniform1fvARB");
bglUniform2fvARB = GETPROCEXTSOFT("glUniform2fvARB");
bglUniform3fvARB = GETPROCEXTSOFT("glUniform3fvARB");
bglUniform4fvARB = GETPROCEXTSOFT("glUniform4fvARB");
bglUniform1ivARB = GETPROCEXTSOFT("glUniform1ivARB");
bglUniform2ivARB = GETPROCEXTSOFT("glUniform2ivARB");
bglUniform3ivARB = GETPROCEXTSOFT("glUniform3ivARB");
bglUniform4ivARB = GETPROCEXTSOFT("glUniform4ivARB");
bglUniformMatrix2fvARB = GETPROCEXTSOFT("glUniformMatrix2fvARB");
bglUniformMatrix3fvARB = GETPROCEXTSOFT("glUniformMatrix3fvARB");
bglUniformMatrix4fvARB = GETPROCEXTSOFT("glUniformMatrix4fvARB");
bglGetObjectParameterfvARB = GETPROCEXTSOFT("glGetObjectParameterfvARB");
bglGetObjectParameterivARB = GETPROCEXTSOFT("glGetObjectParameterivARB");
bglGetInfoLogARB = GETPROCEXTSOFT("glGetInfoLogARB");
bglGetAttachedObjectsARB = GETPROCEXTSOFT("glGetAttachedObjectsARB");
bglGetUniformLocationARB = GETPROCEXTSOFT("glGetUniformLocationARB");
bglGetActiveUniformARB = GETPROCEXTSOFT("glGetActiveUniformARB");
bglGetUniformfvARB = GETPROCEXTSOFT("glGetUniformfvARB");
bglGetUniformivARB = GETPROCEXTSOFT("glGetUniformivARB");
bglGetShaderSourceARB = GETPROCEXTSOFT("glGetShaderSourceARB");
// Vertex Shaders
bglVertexAttrib1dARB = GETPROCEXTSOFT("glVertexAttrib1dARB");
bglVertexAttrib1dvARB = GETPROCEXTSOFT("glVertexAttrib1dvARB");
bglVertexAttrib1fARB = GETPROCEXTSOFT("glVertexAttrib1fARB");
bglVertexAttrib1fvARB = GETPROCEXTSOFT("glVertexAttrib1fvARB");
bglVertexAttrib1sARB = GETPROCEXTSOFT("glVertexAttrib1sARB");
bglVertexAttrib1svARB = GETPROCEXTSOFT("glVertexAttrib1svARB");
bglVertexAttrib2dARB = GETPROCEXTSOFT("glVertexAttrib2dARB");
bglVertexAttrib2dvARB = GETPROCEXTSOFT("glVertexAttrib2dvARB");
bglVertexAttrib2fARB = GETPROCEXTSOFT("glVertexAttrib2fARB");
bglVertexAttrib2fvARB = GETPROCEXTSOFT("glVertexAttrib2fvARB");
bglVertexAttrib2sARB = GETPROCEXTSOFT("glVertexAttrib2sARB");
bglVertexAttrib2svARB = GETPROCEXTSOFT("glVertexAttrib2svARB");
bglVertexAttrib3dARB = GETPROCEXTSOFT("glVertexAttrib3dARB");
bglVertexAttrib3dvARB = GETPROCEXTSOFT("glVertexAttrib3dvARB");
bglVertexAttrib3fARB = GETPROCEXTSOFT("glVertexAttrib3fARB");
bglVertexAttrib3fvARB = GETPROCEXTSOFT("glVertexAttrib3fvARB");
bglVertexAttrib3sARB = GETPROCEXTSOFT("glVertexAttrib3sARB");
bglVertexAttrib3svARB = GETPROCEXTSOFT("glVertexAttrib3svARB");
bglVertexAttrib4NbvARB = GETPROCEXTSOFT("glVertexAttrib4NbvARB");
bglVertexAttrib4NivARB = GETPROCEXTSOFT("glVertexAttrib4NivARB");
bglVertexAttrib4NsvARB = GETPROCEXTSOFT("glVertexAttrib4NsvARB");
bglVertexAttrib4NubARB = GETPROCEXTSOFT("glVertexAttrib4NubARB");
bglVertexAttrib4NubvARB = GETPROCEXTSOFT("glVertexAttrib4NubvARB");
bglVertexAttrib4NuivARB = GETPROCEXTSOFT("glVertexAttrib4NuivARB");
bglVertexAttrib4NusvARB = GETPROCEXTSOFT("glVertexAttrib4NusvARB");
bglVertexAttrib4bvARB = GETPROCEXTSOFT("glVertexAttrib4bvARB");
bglVertexAttrib4dARB = GETPROCEXTSOFT("glVertexAttrib4dARB");
bglVertexAttrib4dvARB = GETPROCEXTSOFT("glVertexAttrib4dvARB");
bglVertexAttrib4fARB = GETPROCEXTSOFT("glVertexAttrib4fARB");
bglVertexAttrib4fvARB = GETPROCEXTSOFT("glVertexAttrib4fvARB");
bglVertexAttrib4ivARB = GETPROCEXTSOFT("glVertexAttrib4ivARB");
bglVertexAttrib4sARB = GETPROCEXTSOFT("glVertexAttrib4sARB");
bglVertexAttrib4svARB = GETPROCEXTSOFT("glVertexAttrib4svARB");
bglVertexAttrib4ubvARB = GETPROCEXTSOFT("glVertexAttrib4ubvARB");
bglVertexAttrib4uivARB = GETPROCEXTSOFT("glVertexAttrib4uivARB");
bglVertexAttrib4usvARB = GETPROCEXTSOFT("glVertexAttrib4usvARB");
bglVertexAttribPointerARB = GETPROCEXTSOFT("glVertexAttribPointerARB");
bglEnableVertexAttribArrayARB = GETPROCEXTSOFT("glEnableVertexAttribArrayARB");
bglDisableVertexAttribArrayARB = GETPROCEXTSOFT("glDisableVertexAttribArrayARB");
bglGetVertexAttribdvARB = GETPROCEXTSOFT("glGetVertexAttribdvARB");
bglGetVertexAttribfvARB = GETPROCEXTSOFT("glGetVertexAttribfvARB");
bglGetVertexAttribivARB = GETPROCEXTSOFT("glGetVertexAttribivARB");
bglGetVertexAttribPointervARB = GETPROCEXTSOFT("glGetVertexAttribPointervARB");
bglBindAttribLocationARB = GETPROCEXTSOFT("glBindAttribLocationARB");
bglGetActiveAttribARB = GETPROCEXTSOFT("glGetActiveAttribARB");
bglGetAttribLocationARB = GETPROCEXTSOFT("glGetAttribLocationARB");
// Debug Output
#ifndef __APPLE__
bglDebugMessageControlARB = GETPROCEXTSOFT("glDebugMessageControlARB");
bglDebugMessageCallbackARB = GETPROCEXTSOFT("glDebugMessageCallbackARB");
#endif
#ifdef RENDERTYPEWIN
bwglSwapIntervalEXT = GETPROCEXTSOFT("wglSwapIntervalEXT");
bwglCreateContextAttribsARB = GETPROCEXTSOFT("wglCreateContextAttribsARB");
#endif
return err;
}
int32_t unloadgldriver(void)
{
unloadglulibrary();
#ifdef RENDERTYPEWIN
if (!hGLDLL) return 0;
#endif
Bfree(gldriver);
gldriver = NULL;
#ifdef RENDERTYPEWIN
FreeLibrary(hGLDLL);
hGLDLL = NULL;
#endif
bglClearColor = NULL;
bglClear = NULL;
bglColorMask = NULL;
bglAlphaFunc = NULL;
bglBlendFunc = NULL;
bglCullFace = NULL;
bglFrontFace = NULL;
bglPolygonOffset = NULL;
bglPolygonMode = NULL;
bglEnable = NULL;
bglDisable = NULL;
bglGetDoublev = NULL;
bglGetFloatv = NULL;
bglGetIntegerv = NULL;
bglPushAttrib = NULL;
bglPopAttrib = NULL;
bglGetError = NULL;
bglGetString = NULL;
bglHint = NULL;
bglDrawBuffer = NULL;
bglReadBuffer = NULL;
bglScissor = NULL;
bglClipPlane = NULL;
// Depth
bglDepthFunc = NULL;
bglDepthMask = NULL;
bglDepthRange = NULL;
// Matrix
bglMatrixMode = NULL;
bglOrtho = NULL;
bglFrustum = NULL;
bglViewport = NULL;
bglPushMatrix = NULL;
bglPopMatrix = NULL;
bglLoadIdentity = NULL;
bglLoadMatrixf = NULL;
bglLoadMatrixd = NULL;
bglMultMatrixf = NULL;
bglMultMatrixd = NULL;
bglRotatef = NULL;
bglScalef = NULL;
bglTranslatef = NULL;
// Drawing
bglBegin = NULL;
bglEnd = NULL;
bglVertex2f = NULL;
bglVertex2i = NULL;
bglVertex3f = NULL;
bglVertex3d = NULL;
bglVertex3fv = NULL;
bglColor4f = NULL;
bglColor4ub = NULL;
bglTexCoord2d = NULL;
bglTexCoord2f = NULL;
bglTexCoord2i = NULL;
bglNormal3f = NULL;
// Lighting
bglShadeModel = NULL;
bglLightfv = NULL;
// Raster funcs
bglReadPixels = NULL;
bglRasterPos4i = NULL;
bglDrawPixels = NULL;
bglPixelStorei = NULL;
// Texture mapping
bglTexEnvf = NULL;
bglGenTextures = NULL;
bglDeleteTextures = NULL;
bglBindTexture = NULL;
bglTexImage2D = NULL;
bglTexImage3D = NULL;
bglCopyTexImage2D = NULL;
bglCopyTexSubImage2D= NULL;
bglTexSubImage2D = NULL;
bglTexParameterf = NULL;
bglTexParameteri = NULL;
bglGetTexParameteriv = NULL;
bglGetTexLevelParameteriv = NULL;
bglCompressedTexImage2DARB = NULL;
bglGetCompressedTexImageARB = NULL;
// Fog
bglFogf = NULL;
bglFogi = NULL;
bglFogfv = NULL;
// Display Lists
bglNewList = NULL;
bglEndList = NULL;
bglCallList = NULL;
bglDeleteLists = NULL;
// Vertex Arrays
bglEnableClientState = NULL;
bglDisableClientState = NULL;
bglVertexPointer = NULL;
bglNormalPointer = NULL;
bglTexCoordPointer = NULL;
bglDrawElements = NULL;
// Stencil Buffer
bglClearStencil = NULL;
bglStencilOp = NULL;
bglStencilFunc = NULL;
// GPU Programs
bglGenProgramsARB = NULL;
bglBindProgramARB = NULL;
bglProgramStringARB = NULL;
bglDeleteProgramsARB= NULL;
// Multitexturing
bglActiveTextureARB = NULL;
bglClientActiveTextureARB = NULL;
bglMultiTexCoord2dARB = NULL;
bglMultiTexCoord2fARB = NULL;
// Frame Buffer Objects
bglGenFramebuffersEXT = NULL;
bglBindFramebufferEXT = NULL;
bglFramebufferTexture2DEXT = NULL;
bglCheckFramebufferStatusEXT = NULL;
bglDeleteFramebuffersEXT = NULL;
// Vertex Buffer Objects
bglGenBuffersARB = NULL;
bglBindBufferARB = NULL;
bglDeleteBuffersARB = NULL;
bglBufferDataARB = NULL;
bglBufferSubDataARB = NULL;
bglMapBufferARB = NULL;
bglUnmapBufferARB = NULL;
// Occlusion queries
bglGenQueriesARB = NULL;
bglDeleteQueriesARB = NULL;
bglIsQueryARB = NULL;
bglBeginQueryARB = NULL;
bglEndQueryARB = NULL;
bglGetQueryivARB = NULL;
bglGetQueryObjectivARB = NULL;
bglGetQueryObjectuivARB = NULL;
// Shader Objects
bglDeleteObjectARB = NULL;
bglGetHandleARB = NULL;
bglDetachObjectARB = NULL;
bglCreateShaderObjectARB = NULL;
bglShaderSourceARB = NULL;
bglCompileShaderARB = NULL;
bglCreateProgramObjectARB = NULL;
bglAttachObjectARB = NULL;
bglLinkProgramARB = NULL;
bglUseProgramObjectARB = NULL;
bglValidateProgramARB = NULL;
bglUniform1fARB = NULL;
bglUniform2fARB = NULL;
bglUniform3fARB = NULL;
bglUniform4fARB = NULL;
bglUniform1iARB = NULL;
bglUniform2iARB = NULL;
bglUniform3iARB = NULL;
bglUniform4iARB = NULL;
bglUniform1fvARB = NULL;
bglUniform2fvARB = NULL;
bglUniform3fvARB = NULL;
bglUniform4fvARB = NULL;
bglUniform1ivARB = NULL;
bglUniform2ivARB = NULL;
bglUniform3ivARB = NULL;
bglUniform4ivARB = NULL;
bglUniformMatrix2fvARB = NULL;
bglUniformMatrix3fvARB = NULL;
bglUniformMatrix4fvARB = NULL;
bglGetObjectParameterfvARB = NULL;
bglGetObjectParameterivARB = NULL;
bglGetInfoLogARB = NULL;
bglGetAttachedObjectsARB = NULL;
bglGetUniformLocationARB = NULL;
bglGetActiveUniformARB = NULL;
bglGetUniformfvARB = NULL;
bglGetUniformivARB = NULL;
bglGetShaderSourceARB = NULL;
// Vertex Shaders
bglVertexAttrib1dARB = NULL;
bglVertexAttrib1dvARB = NULL;
bglVertexAttrib1fARB = NULL;
bglVertexAttrib1fvARB = NULL;
bglVertexAttrib1sARB = NULL;
bglVertexAttrib1svARB = NULL;
bglVertexAttrib2dARB = NULL;
bglVertexAttrib2dvARB = NULL;
bglVertexAttrib2fARB = NULL;
bglVertexAttrib2fvARB = NULL;
bglVertexAttrib2sARB = NULL;
bglVertexAttrib2svARB = NULL;
bglVertexAttrib3dARB = NULL;
bglVertexAttrib3dvARB = NULL;
bglVertexAttrib3fARB = NULL;
bglVertexAttrib3fvARB = NULL;
bglVertexAttrib3sARB = NULL;
bglVertexAttrib3svARB = NULL;
bglVertexAttrib4NbvARB = NULL;
bglVertexAttrib4NivARB = NULL;
bglVertexAttrib4NsvARB = NULL;
bglVertexAttrib4NubARB = NULL;
bglVertexAttrib4NubvARB = NULL;
bglVertexAttrib4NuivARB = NULL;
bglVertexAttrib4NusvARB = NULL;
bglVertexAttrib4bvARB = NULL;
bglVertexAttrib4dARB = NULL;
bglVertexAttrib4dvARB = NULL;
bglVertexAttrib4fARB = NULL;
bglVertexAttrib4fvARB = NULL;
bglVertexAttrib4ivARB = NULL;
bglVertexAttrib4sARB = NULL;
bglVertexAttrib4svARB = NULL;
bglVertexAttrib4ubvARB = NULL;
bglVertexAttrib4uivARB = NULL;
bglVertexAttrib4usvARB = NULL;
bglVertexAttribPointerARB = NULL;
bglEnableVertexAttribArrayARB = NULL;
bglDisableVertexAttribArrayARB = NULL;
bglGetVertexAttribdvARB = NULL;
bglGetVertexAttribfvARB = NULL;
bglGetVertexAttribivARB = NULL;
bglGetVertexAttribPointervARB = NULL;
bglBindAttribLocationARB = NULL;
bglGetActiveAttribARB = NULL;
bglGetAttribLocationARB = NULL;
#ifdef RENDERTYPEWIN
bwglCreateContext = NULL;
bwglDeleteContext = NULL;
bwglGetProcAddress = NULL;
bwglMakeCurrent = NULL;
bwglSwapBuffers = NULL;
bwglChoosePixelFormat = NULL;
bwglDescribePixelFormat = NULL;
bwglGetPixelFormat = NULL;
bwglSetPixelFormat = NULL;
bwglSwapIntervalEXT = NULL;
#endif
return 0;
}
static void *glugetproc_(const char *s, int32_t *err, int32_t fatal)
{
void *t;
#if defined _WIN32
t = (void *)GetProcAddress(hGLUDLL,s);
#else
t = (void *)dlsym(gluhandle,s);
#endif
if (!t && fatal)
{
initprintf("Failed to find %s in %s\n", s, glulibrary);
*err = 1;
}
return t;
}
#define GLUGETPROC(s) glugetproc_(s,&err,1)
#define GLUGETPROCSOFT(s) glugetproc_(s,&err,0)
int32_t loadglulibrary(const char *driver)
{
int32_t err=0;
#ifdef RENDERTYPEWIN
if (hGLUDLL) return 0;
#endif
if (!driver)
{
#ifdef _WIN32
driver = "glu32.dll";
#elif defined __APPLE__
driver = "/System/Library/Frameworks/OpenGL.framework/OpenGL"; // FIXME: like I know anything about Apple. Hah.
#else
driver = "libGLU.so.1";
#endif
}
#if defined _WIN32
hGLUDLL = LoadLibrary(driver);
if (!hGLUDLL) goto fail;
#else
gluhandle = dlopen(driver, RTLD_NOW|RTLD_GLOBAL);
if (!gluhandle) goto fail;
#endif
glulibrary = Bstrdup(driver);
bgluTessBeginContour = GLUGETPROC("gluTessBeginContour");
bgluTessBeginPolygon = GLUGETPROC("gluTessBeginPolygon");
bgluTessCallback = GLUGETPROC("gluTessCallback");
bgluTessEndContour = GLUGETPROC("gluTessEndContour");
bgluTessEndPolygon = GLUGETPROC("gluTessEndPolygon");
bgluTessNormal = GLUGETPROC("gluTessNormal");
bgluTessProperty = GLUGETPROC("gluTessProperty");
bgluTessVertex = GLUGETPROC("gluTessVertex");
bgluNewTess = GLUGETPROC("gluNewTess");
bgluDeleteTess = GLUGETPROC("gluDeleteTess");
bgluPerspective = GLUGETPROC("gluPerspective");
bgluErrorString = GLUGETPROC("gluErrorString");
bgluProject = GLUGETPROC("gluProject");
bgluUnProject = GLUGETPROC("gluUnProject");
if (err) unloadglulibrary();
return err;
fail:
initprintf("Failed loading \"%s\"\n",driver);
return -1;
}
int32_t unloadglulibrary(void)
{
#ifdef RENDERTYPEWIN
if (!hGLUDLL) return 0;
#endif
Bfree(glulibrary);
glulibrary = NULL;
#ifdef RENDERTYPEWIN
FreeLibrary(hGLUDLL);
hGLUDLL = NULL;
#else
if (gluhandle) dlclose(gluhandle);
gluhandle = NULL;
#endif
bgluTessBeginContour = NULL;
bgluTessBeginPolygon = NULL;
bgluTessCallback = NULL;
bgluTessEndContour = NULL;
bgluTessEndPolygon = NULL;
bgluTessNormal = NULL;
bgluTessProperty = NULL;
bgluTessVertex = NULL;
bgluNewTess = NULL;
bgluDeleteTess = NULL;
bgluPerspective = NULL;
bgluErrorString = NULL;
bgluProject = NULL;
bgluUnProject = NULL;
return 0;
}
//////// glGenTextures/glDeleteTextures debugging ////////
# if defined DEBUGGINGAIDS && defined DEBUG_TEXTURE_NAMES
static uint8_t *texnameused; // bitmap
static uint32_t *texnamefromwhere; // hash of __FILE__
static uint32_t texnameallocsize;
// djb3 algorithm
static inline uint32_t texdbg_getcode(const char *s)
{
uint32_t h = 5381;
int32_t ch;
while ((ch = *s++) != '\0')
h = ((h << 5) + h) ^ ch;
return h;
}
static void texdbg_realloc(uint32_t maxtexname)
{
uint32_t newsize = texnameallocsize ? texnameallocsize : 64;
if (maxtexname < texnameallocsize)
return;
while (maxtexname >= newsize)
newsize <<= 1;
// initprintf("texdebug: new size %u\n", newsize);
texnameused = Brealloc(texnameused, newsize>>3);
texnamefromwhere = Brealloc(texnamefromwhere, newsize*sizeof(uint32_t));
Bmemset(texnameused + (texnameallocsize>>3), 0, (newsize-texnameallocsize)>>3);
Bmemset(texnamefromwhere + texnameallocsize, 0, (newsize-texnameallocsize)*sizeof(uint32_t));
texnameallocsize = newsize;
}
#undef bglGenTextures
void texdbg_bglGenTextures(GLsizei n, GLuint *textures, const char *srcfn)
{
int32_t i;
uint32_t hash = srcfn ? texdbg_getcode(srcfn) : 0;
for (i=0; i<n; i++)
if (textures[i] < texnameallocsize && (texnameused[textures[i]>>3]&(1<<(textures[i]&7))))
initprintf("texdebug %x Gen: overwriting used tex name %u from %x\n", hash, textures[i], texnamefromwhere[textures[i]]);
bglGenTextures(n, textures);
{
GLuint maxtexname = 0;
for (i=0; i<n; i++)
maxtexname = max(maxtexname, textures[i]);
texdbg_realloc(maxtexname);
for (i=0; i<n; i++)
{
texnameused[textures[i]>>3] |= (1<<(textures[i]&7));
texnamefromwhere[textures[i]] = hash;
}
}
}
#undef bglDeleteTextures
void texdbg_bglDeleteTextures(GLsizei n, const GLuint *textures, const char *srcfn)
{
int32_t i;
uint32_t hash = srcfn ? texdbg_getcode(srcfn) : 0;
for (i=0; i<n; i++)
if (textures[i] < texnameallocsize)
{
if ((texnameused[textures[i]>>3]&(1<<(textures[i]&7)))==0)
initprintf("texdebug %x Del: deleting unused tex name %u\n", hash, textures[i]);
else if ((texnameused[textures[i]>>3]&(1<<(textures[i]&7))) &&
texnamefromwhere[textures[i]] != hash)
initprintf("texdebug %x Del: deleting foreign tex name %u from %x\n", hash,
textures[i], texnamefromwhere[textures[i]]);
}
bglDeleteTextures(n, textures);
if (texnameallocsize)
for (i=0; i<n; i++)
{
texnameused[textures[i]>>3] &= ~(1<<(textures[i]&7));
texnamefromwhere[textures[i]] = 0;
}
}
# endif // defined DEBUGGINGAIDS
#endif
Reference in a new issue View git blame Copy permalink