mirror of
https://github.com/dhewm/dhewm3.git
synced 2025-03-22 02:31:03 +00:00
Get rid of GL_HARDLINK, always link against libGL
This kills the funky GL logging stubs, which unnecessarily complicates the build process (think future cmake). As for logging GL calls: Use apitrace for that https://github.com/apitrace/apitrace
This commit is contained in:
dhewg
parent
9678020677
commit
1b8777a008
23 changed files with 43 additions and 4197 deletions
|
|
@ -12,7 +12,7 @@ import scons_utils
|
|||
conf_filename='site.conf'
|
||||
# choose configuration variables which should be saved between runs
|
||||
# ( we handle all those as strings )
|
||||
serialized=['CC', 'CXX', 'X86', 'BUILD', 'IDNET_HOST', 'GL_HARDLINK', 'DEDICATED',
|
||||
serialized=['CC', 'CXX', 'X86', 'BUILD', 'IDNET_HOST', 'DEDICATED',
|
||||
'DEBUG_MEMORY', 'LIBC_MALLOC', 'ID_NOLANADDRESS', 'ID_MCHECK', 'ALSA',
|
||||
'TARGET_CORE', 'TARGET_GAME', 'TARGET_D3XP', 'TARGET_MONO', 'TARGET_DEMO', 'NOCURL',
|
||||
'BUILD_ROOT', 'BUILD_GAMEPAK', 'BASEFLAGS' ]
|
||||
|
|
@ -91,10 +91,6 @@ TARGET_DEMO (default 0)
|
|||
IDNET_HOST (default to source hardcoded)
|
||||
Override builtin IDNET_HOST with your own settings
|
||||
|
||||
GL_HARDLINK (default 0)
|
||||
Instead of dynamically loading the OpenGL libraries, use implicit dependencies
|
||||
NOTE: no GL logging capability and no r_glDriver with GL_HARDLINK 1
|
||||
|
||||
DEBUG_MEMORY (default 0)
|
||||
Enables memory logging to file
|
||||
|
||||
|
|
@ -175,7 +171,6 @@ TARGET_D3XP = '1'
|
|||
TARGET_MONO = '0'
|
||||
TARGET_DEMO = '0'
|
||||
IDNET_HOST = ''
|
||||
GL_HARDLINK = '0'
|
||||
DEBUG_MEMORY = '0'
|
||||
LIBC_MALLOC = '1'
|
||||
ID_NOLANADDRESS = '0'
|
||||
|
|
@ -275,9 +270,6 @@ g_build = '%s/%s-%s' % (BUILD_ROOT, g_cpu, BUILD)
|
|||
|
||||
SConsignFile( g_build + '/scons.signatures' )
|
||||
|
||||
if ( GL_HARDLINK != '0' ):
|
||||
g_build += '-hardlink'
|
||||
|
||||
if ( DEBUG_MEMORY != '0' ):
|
||||
g_build += '-debugmem'
|
||||
|
||||
|
|
@ -328,9 +320,6 @@ else:
|
|||
print 'Unknown build configuration ' + BUILD
|
||||
sys.exit(0)
|
||||
|
||||
if ( GL_HARDLINK != '0' ):
|
||||
CORECPPFLAGS.append( '-DID_GL_HARDLINK' )
|
||||
|
||||
if ( DEBUG_MEMORY != '0' ):
|
||||
BASECPPFLAGS += [ '-DID_DEBUG_MEMORY', '-DID_REDIRECT_NEWDELETE' ]
|
||||
|
||||
|
|
@ -417,8 +406,6 @@ if ( TARGET_CORE == '1' ):
|
|||
local_dedicated = 0
|
||||
Export( 'GLOBALS ' + GLOBALS )
|
||||
|
||||
VariantDir( g_build + '/obj-core/glimp', '.', duplicate = 1 )
|
||||
SConscript( g_build + '/obj-core/glimp/sys/scons/SConscript.gl' )
|
||||
VariantDir( g_build + '/obj-core', '.', duplicate = 0 )
|
||||
idlib_objects = SConscript( g_build + '/obj-core/sys/scons/SConscript.idlib' )
|
||||
Export( 'GLOBALS ' + GLOBALS ) # update idlib_objects
|
||||
|
|
@ -429,8 +416,6 @@ if ( TARGET_CORE == '1' ):
|
|||
local_dedicated = 1
|
||||
Export( 'GLOBALS ' + GLOBALS )
|
||||
|
||||
VariantDir( g_build + '/dedicated/glimp', '.', duplicate = 1 )
|
||||
SConscript( g_build + '/dedicated/glimp/sys/scons/SConscript.gl' )
|
||||
VariantDir( g_build + '/dedicated', '.', duplicate = 0 )
|
||||
idlib_objects = SConscript( g_build + '/dedicated/sys/scons/SConscript.idlib' )
|
||||
Export( 'GLOBALS ' + GLOBALS )
|
||||
|
|
@ -476,8 +461,6 @@ if ( TARGET_MONO == '1' ):
|
|||
local_idlibpic = 0
|
||||
local_d3xp = 0
|
||||
Export( 'GLOBALS ' + GLOBALS )
|
||||
VariantDir( g_build + '/mono/glimp', '.', duplicate = 1 )
|
||||
SConscript( g_build + '/mono/glimp/sys/scons/SConscript.gl' )
|
||||
VariantDir( g_build + '/mono', '.', duplicate = 0 )
|
||||
idlib_objects = SConscript( g_build + '/mono/sys/scons/SConscript.idlib' )
|
||||
game_objects = SConscript( g_build + '/mono/sys/scons/SConscript.game' )
|
||||
|
|
@ -494,8 +477,6 @@ if ( TARGET_DEMO == '1' ):
|
|||
local_curl = 0
|
||||
local_d3xp = 0
|
||||
Export( 'GLOBALS ' + GLOBALS )
|
||||
VariantDir( g_build + '/demo/glimp', '.', duplicate = 1 )
|
||||
SConscript( g_build + '/demo/glimp/sys/scons/SConscript.gl' )
|
||||
VariantDir( g_build + '/demo', '.', duplicate = 0 )
|
||||
idlib_objects = SConscript( g_build + '/demo/sys/scons/SConscript.idlib' )
|
||||
Export( 'GLOBALS ' + GLOBALS )
|
||||
|
|
|
|||
|
|
@ -1672,10 +1672,11 @@ PurgeImage
|
|||
*/
|
||||
void idImage::PurgeImage() {
|
||||
if ( texnum != TEXTURE_NOT_LOADED ) {
|
||||
#ifdef _WIN32
|
||||
// sometimes is NULL when exiting with an error
|
||||
if ( qglDeleteTextures ) {
|
||||
if ( qglDeleteTextures )
|
||||
#endif
|
||||
qglDeleteTextures( 1, &texnum ); // this should be the ONLY place it is ever called!
|
||||
}
|
||||
texnum = TEXTURE_NOT_LOADED;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -166,7 +166,7 @@ extern PFNGLDEPTHBOUNDSEXTPROC qglDepthBoundsEXT;
|
|||
//===========================================================================
|
||||
|
||||
// non-windows systems will just redefine qgl* to gl*
|
||||
#if defined( __APPLE__ ) || defined( ID_GL_HARDLINK )
|
||||
#ifndef _WIN32
|
||||
|
||||
#include "qgl_linked.h"
|
||||
|
||||
|
|
@ -511,8 +511,6 @@ extern void ( APIENTRY * qglVertex4sv )(const GLshort *v);
|
|||
extern void ( APIENTRY * qglVertexPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
|
||||
extern void ( APIENTRY * qglViewport )(GLint x, GLint y, GLsizei width, GLsizei height);
|
||||
|
||||
#if defined( _WIN32 )
|
||||
|
||||
extern int ( WINAPI * qwglChoosePixelFormat )(HDC, CONST PIXELFORMATDESCRIPTOR *);
|
||||
extern int ( WINAPI * qwglDescribePixelFormat) (HDC, int, UINT, LPPIXELFORMATDESCRIPTOR);
|
||||
extern int ( WINAPI * qwglGetPixelFormat)(HDC);
|
||||
|
|
@ -544,24 +542,4 @@ extern BOOL ( WINAPI * qwglSwapLayerBuffers)(HDC, UINT);
|
|||
|
||||
#endif // _WIN32
|
||||
|
||||
#if defined( __unix__ )
|
||||
|
||||
//GLX Functions
|
||||
extern XVisualInfo * (*qglXChooseVisual)( Display *dpy, int screen, int *attribList );
|
||||
extern GLXContext (*qglXCreateContext)( Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct );
|
||||
extern void (*qglXDestroyContext)( Display *dpy, GLXContext ctx );
|
||||
extern Bool (*qglXMakeCurrent)( Display *dpy, GLXDrawable drawable, GLXContext ctx);
|
||||
extern void (*qglXSwapBuffers)( Display *dpy, GLXDrawable drawable );
|
||||
extern GLExtension_t (*qglXGetProcAddressARB)( const GLubyte *procname );
|
||||
|
||||
// make sure the code is correctly using qgl everywhere
|
||||
// don't enable that when building glimp itself obviously..
|
||||
#if !defined( GLIMP )
|
||||
#include "../sys/linux/qgl_enforce.h"
|
||||
#endif
|
||||
|
||||
#endif // __linux__
|
||||
|
||||
#endif // hardlinlk vs dlopen
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,336 +0,0 @@
|
|||
void;qgl;Accum;GLenum op, GLfloat value
|
||||
void;qgl;AlphaFunc;GLenum func, GLclampf ref
|
||||
GLboolean;qgl;AreTexturesResident;GLsizei n, const GLuint *textures, GLboolean *residences
|
||||
void;qgl;ArrayElement;GLint i
|
||||
void;qgl;Begin;GLenum mode
|
||||
void;qgl;BindTexture;GLenum target, GLuint texture
|
||||
void;qgl;Bitmap;GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap
|
||||
void;qgl;BlendFunc;GLenum sfactor, GLenum dfactor
|
||||
void;qgl;CallList;GLuint list
|
||||
void;qgl;CallLists;GLsizei n, GLenum type, const GLvoid *lists
|
||||
void;qgl;Clear;GLbitfield mask
|
||||
void;qgl;ClearAccum;GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha
|
||||
void;qgl;ClearColor;GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha
|
||||
void;qgl;ClearDepth;GLclampd depth
|
||||
void;qgl;ClearIndex;GLfloat c
|
||||
void;qgl;ClearStencil;GLint s
|
||||
void;qgl;ClipPlane;GLenum plane, const GLdouble *equation
|
||||
void;qgl;Color3b;GLbyte red, GLbyte green, GLbyte blue
|
||||
void;qgl;Color3bv;const GLbyte *v
|
||||
void;qgl;Color3d;GLdouble red, GLdouble green, GLdouble blue
|
||||
void;qgl;Color3dv;const GLdouble *v
|
||||
void;qgl;Color3f;GLfloat red, GLfloat green, GLfloat blue
|
||||
void;qgl;Color3fv;const GLfloat *v
|
||||
void;qgl;Color3i;GLint red, GLint green, GLint blue
|
||||
void;qgl;Color3iv;const GLint *v
|
||||
void;qgl;Color3s;GLshort red, GLshort green, GLshort blue
|
||||
void;qgl;Color3sv;const GLshort *v
|
||||
void;qgl;Color3ub;GLubyte red, GLubyte green, GLubyte blue
|
||||
void;qgl;Color3ubv;const GLubyte *v
|
||||
void;qgl;Color3ui;GLuint red, GLuint green, GLuint blue
|
||||
void;qgl;Color3uiv;const GLuint *v
|
||||
void;qgl;Color3us;GLushort red, GLushort green, GLushort blue
|
||||
void;qgl;Color3usv;const GLushort *v
|
||||
void;qgl;Color4b;GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha
|
||||
void;qgl;Color4bv;const GLbyte *v
|
||||
void;qgl;Color4d;GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha
|
||||
void;qgl;Color4dv;const GLdouble *v
|
||||
void;qgl;Color4f;GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha
|
||||
void;qgl;Color4fv;const GLfloat *v
|
||||
void;qgl;Color4i;GLint red, GLint green, GLint blue, GLint alpha
|
||||
void;qgl;Color4iv;const GLint *v
|
||||
void;qgl;Color4s;GLshort red, GLshort green, GLshort blue, GLshort alpha
|
||||
void;qgl;Color4sv;const GLshort *v
|
||||
void;qgl;Color4ub;GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha
|
||||
void;qgl;Color4ubv;const GLubyte *v
|
||||
void;qgl;Color4ui;GLuint red, GLuint green, GLuint blue, GLuint alpha
|
||||
void;qgl;Color4uiv;const GLuint *v
|
||||
void;qgl;Color4us;GLushort red, GLushort green, GLushort blue, GLushort alpha
|
||||
void;qgl;Color4usv;const GLushort *v
|
||||
void;qgl;ColorMask;GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha
|
||||
void;qgl;ColorMaterial;GLenum face, GLenum mode
|
||||
void;qgl;ColorPointer;GLint size, GLenum type, GLsizei stride, const GLvoid *pointer
|
||||
void;qgl;CopyPixels;GLint x, GLint y, GLsizei width, GLsizei height, GLenum type
|
||||
void;qgl;CopyTexImage1D;GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border
|
||||
void;qgl;CopyTexImage2D;GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border
|
||||
void;qgl;CopyTexSubImage1D;GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width
|
||||
void;qgl;CopyTexSubImage2D;GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height
|
||||
void;qgl;CullFace;GLenum mode
|
||||
void;qgl;DeleteLists;GLuint list, GLsizei range
|
||||
void;qgl;DeleteTextures;GLsizei n, const GLuint *textures
|
||||
void;qgl;DepthFunc;GLenum func
|
||||
void;qgl;DepthMask;GLboolean flag
|
||||
void;qgl;DepthRange;GLclampd zNear, GLclampd zFar
|
||||
void;qgl;Disable;GLenum cap
|
||||
void;qgl;DisableClientState;GLenum array
|
||||
void;qgl;DrawArrays;GLenum mode, GLint first, GLsizei count
|
||||
void;qgl;DrawBuffer;GLenum mode
|
||||
void;qgl;DrawElements;GLenum mode, GLsizei count, GLenum type, const GLvoid *indices
|
||||
void;qgl;DrawPixels;GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels
|
||||
void;qgl;EdgeFlag;GLboolean flag
|
||||
void;qgl;EdgeFlagPointer;GLsizei stride, const GLvoid *pointer
|
||||
void;qgl;EdgeFlagv;const GLboolean *flag
|
||||
void;qgl;Enable;GLenum cap
|
||||
void;qgl;EnableClientState;GLenum array
|
||||
void;qgl;End;void
|
||||
void;qgl;EndList;void
|
||||
void;qgl;EvalCoord1d;GLdouble u
|
||||
void;qgl;EvalCoord1dv;const GLdouble *u
|
||||
void;qgl;EvalCoord1f;GLfloat u
|
||||
void;qgl;EvalCoord1fv;const GLfloat *u
|
||||
void;qgl;EvalCoord2d;GLdouble u, GLdouble v
|
||||
void;qgl;EvalCoord2dv;const GLdouble *u
|
||||
void;qgl;EvalCoord2f;GLfloat u, GLfloat v
|
||||
void;qgl;EvalCoord2fv;const GLfloat *u
|
||||
void;qgl;EvalMesh1;GLenum mode, GLint i1, GLint i2
|
||||
void;qgl;EvalMesh2;GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2
|
||||
void;qgl;EvalPoint1;GLint i
|
||||
void;qgl;EvalPoint2;GLint i, GLint j
|
||||
void;qgl;FeedbackBuffer;GLsizei size, GLenum type, GLfloat *buffer
|
||||
void;qgl;Finish;void
|
||||
void;qgl;Flush;void
|
||||
void;qgl;Fogf;GLenum pname, GLfloat param
|
||||
void;qgl;Fogfv;GLenum pname, const GLfloat *params
|
||||
void;qgl;Fogi;GLenum pname, GLint param
|
||||
void;qgl;Fogiv;GLenum pname, const GLint *params
|
||||
void;qgl;FrontFace;GLenum mode
|
||||
void;qgl;Frustum;GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar
|
||||
GLuint;qgl;GenLists;GLsizei range
|
||||
void;qgl;GenTextures;GLsizei n, GLuint *textures
|
||||
void;qgl;GetBooleanv;GLenum pname, GLboolean *params
|
||||
void;qgl;GetClipPlane;GLenum plane, GLdouble *equation
|
||||
void;qgl;GetDoublev;GLenum pname, GLdouble *params
|
||||
GLenum;qgl;GetError;void
|
||||
void;qgl;GetFloatv;GLenum pname, GLfloat *params
|
||||
void;qgl;GetIntegerv;GLenum pname, GLint *params
|
||||
void;qgl;GetLightfv;GLenum light, GLenum pname, GLfloat *params
|
||||
void;qgl;GetLightiv;GLenum light, GLenum pname, GLint *params
|
||||
void;qgl;GetMapdv;GLenum target, GLenum query, GLdouble *v
|
||||
void;qgl;GetMapfv;GLenum target, GLenum query, GLfloat *v
|
||||
void;qgl;GetMapiv;GLenum target, GLenum query, GLint *v
|
||||
void;qgl;GetMaterialfv;GLenum face, GLenum pname, GLfloat *params
|
||||
void;qgl;GetMaterialiv;GLenum face, GLenum pname, GLint *params
|
||||
void;qgl;GetPixelMapfv;GLenum map, GLfloat *values
|
||||
void;qgl;GetPixelMapuiv;GLenum map, GLuint *values
|
||||
void;qgl;GetPixelMapusv;GLenum map, GLushort *values
|
||||
void;qgl;GetPointerv;GLenum pname, GLvoid* *params
|
||||
void;qgl;GetPolygonStipple;GLubyte *mask
|
||||
const GLubyte *;qgl;GetString;GLenum name
|
||||
void;qgl;GetTexEnvfv;GLenum target, GLenum pname, GLfloat *params
|
||||
void;qgl;GetTexEnviv;GLenum target, GLenum pname, GLint *params
|
||||
void;qgl;GetTexGendv;GLenum coord, GLenum pname, GLdouble *params
|
||||
void;qgl;GetTexGenfv;GLenum coord, GLenum pname, GLfloat *params
|
||||
void;qgl;GetTexGeniv;GLenum coord, GLenum pname, GLint *params
|
||||
void;qgl;GetTexImage;GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels
|
||||
void;qgl;GetTexLevelParameterfv;GLenum target, GLint level, GLenum pname, GLfloat *params
|
||||
void;qgl;GetTexLevelParameteriv;GLenum target, GLint level, GLenum pname, GLint *params
|
||||
void;qgl;GetTexParameterfv;GLenum target, GLenum pname, GLfloat *params
|
||||
void;qgl;GetTexParameteriv;GLenum target, GLenum pname, GLint *params
|
||||
void;qgl;Hint;GLenum target, GLenum mode
|
||||
void;qgl;IndexMask;GLuint mask
|
||||
void;qgl;IndexPointer;GLenum type, GLsizei stride, const GLvoid *pointer
|
||||
void;qgl;Indexd;GLdouble c
|
||||
void;qgl;Indexdv;const GLdouble *c
|
||||
void;qgl;Indexf;GLfloat c
|
||||
void;qgl;Indexfv;const GLfloat *c
|
||||
void;qgl;Indexi;GLint c
|
||||
void;qgl;Indexiv;const GLint *c
|
||||
void;qgl;Indexs;GLshort c
|
||||
void;qgl;Indexsv;const GLshort *c
|
||||
void;qgl;Indexub;GLubyte c
|
||||
void;qgl;Indexubv;const GLubyte *c
|
||||
void;qgl;InitNames;void
|
||||
void;qgl;InterleavedArrays;GLenum format, GLsizei stride, const GLvoid *pointer
|
||||
GLboolean;qgl;IsEnabled;GLenum cap
|
||||
GLboolean;qgl;IsList;GLuint list
|
||||
GLboolean;qgl;IsTexture;GLuint texture
|
||||
void;qgl;LightModelf;GLenum pname, GLfloat param
|
||||
void;qgl;LightModelfv;GLenum pname, const GLfloat *params
|
||||
void;qgl;LightModeli;GLenum pname, GLint param
|
||||
void;qgl;LightModeliv;GLenum pname, const GLint *params
|
||||
void;qgl;Lightf;GLenum light, GLenum pname, GLfloat param
|
||||
void;qgl;Lightfv;GLenum light, GLenum pname, const GLfloat *params
|
||||
void;qgl;Lighti;GLenum light, GLenum pname, GLint param
|
||||
void;qgl;Lightiv;GLenum light, GLenum pname, const GLint *params
|
||||
void;qgl;LineStipple;GLint factor, GLushort pattern
|
||||
void;qgl;LineWidth;GLfloat width
|
||||
void;qgl;ListBase;GLuint base
|
||||
void;qgl;LoadIdentity;void
|
||||
void;qgl;LoadMatrixd;const GLdouble *m
|
||||
void;qgl;LoadMatrixf;const GLfloat *m
|
||||
void;qgl;LoadName;GLuint name
|
||||
void;qgl;LogicOp;GLenum opcode
|
||||
void;qgl;Map1d;GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points
|
||||
void;qgl;Map1f;GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points
|
||||
void;qgl;Map2d;GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points
|
||||
void;qgl;Map2f;GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points
|
||||
void;qgl;MapGrid1d;GLint un, GLdouble u1, GLdouble u2
|
||||
void;qgl;MapGrid1f;GLint un, GLfloat u1, GLfloat u2
|
||||
void;qgl;MapGrid2d;GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2
|
||||
void;qgl;MapGrid2f;GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2
|
||||
void;qgl;Materialf;GLenum face, GLenum pname, GLfloat param
|
||||
void;qgl;Materialfv;GLenum face, GLenum pname, const GLfloat *params
|
||||
void;qgl;Materiali;GLenum face, GLenum pname, GLint param
|
||||
void;qgl;Materialiv;GLenum face, GLenum pname, const GLint *params
|
||||
void;qgl;MatrixMode;GLenum mode
|
||||
void;qgl;MultMatrixd;const GLdouble *m
|
||||
void;qgl;MultMatrixf;const GLfloat *m
|
||||
void;qgl;NewList;GLuint list, GLenum mode
|
||||
void;qgl;Normal3b;GLbyte nx, GLbyte ny, GLbyte nz
|
||||
void;qgl;Normal3bv;const GLbyte *v
|
||||
void;qgl;Normal3d;GLdouble nx, GLdouble ny, GLdouble nz
|
||||
void;qgl;Normal3dv;const GLdouble *v
|
||||
void;qgl;Normal3f;GLfloat nx, GLfloat ny, GLfloat nz
|
||||
void;qgl;Normal3fv;const GLfloat *v
|
||||
void;qgl;Normal3i;GLint nx, GLint ny, GLint nz
|
||||
void;qgl;Normal3iv;const GLint *v
|
||||
void;qgl;Normal3s;GLshort nx, GLshort ny, GLshort nz
|
||||
void;qgl;Normal3sv;const GLshort *v
|
||||
void;qgl;NormalPointer;GLenum type, GLsizei stride, const GLvoid *pointer
|
||||
void;qgl;Ortho;GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar
|
||||
void;qgl;PassThrough;GLfloat token
|
||||
void;qgl;PixelMapfv;GLenum map, GLsizei mapsize, const GLfloat *values
|
||||
void;qgl;PixelMapuiv;GLenum map, GLsizei mapsize, const GLuint *values
|
||||
void;qgl;PixelMapusv;GLenum map, GLsizei mapsize, const GLushort *values
|
||||
void;qgl;PixelStoref;GLenum pname, GLfloat param
|
||||
void;qgl;PixelStorei;GLenum pname, GLint param
|
||||
void;qgl;PixelTransferf;GLenum pname, GLfloat param
|
||||
void;qgl;PixelTransferi;GLenum pname, GLint param
|
||||
void;qgl;PixelZoom;GLfloat xfactor, GLfloat yfactor
|
||||
void;qgl;PointSize;GLfloat size
|
||||
void;qgl;PolygonMode;GLenum face, GLenum mode
|
||||
void;qgl;PolygonOffset;GLfloat factor, GLfloat units
|
||||
void;qgl;PolygonStipple;const GLubyte *mask
|
||||
void;qgl;PopAttrib;void
|
||||
void;qgl;PopClientAttrib;void
|
||||
void;qgl;PopMatrix;void
|
||||
void;qgl;PopName;void
|
||||
void;qgl;PrioritizeTextures;GLsizei n, const GLuint *textures, const GLclampf *priorities
|
||||
void;qgl;PushAttrib;GLbitfield mask
|
||||
void;qgl;PushClientAttrib;GLbitfield mask
|
||||
void;qgl;PushMatrix;void
|
||||
void;qgl;PushName;GLuint name
|
||||
void;qgl;RasterPos2d;GLdouble x, GLdouble y
|
||||
void;qgl;RasterPos2dv;const GLdouble *v
|
||||
void;qgl;RasterPos2f;GLfloat x, GLfloat y
|
||||
void;qgl;RasterPos2fv;const GLfloat *v
|
||||
void;qgl;RasterPos2i;GLint x, GLint y
|
||||
void;qgl;RasterPos2iv;const GLint *v
|
||||
void;qgl;RasterPos2s;GLshort x, GLshort y
|
||||
void;qgl;RasterPos2sv;const GLshort *v
|
||||
void;qgl;RasterPos3d;GLdouble x, GLdouble y, GLdouble z
|
||||
void;qgl;RasterPos3dv;const GLdouble *v
|
||||
void;qgl;RasterPos3f;GLfloat x, GLfloat y, GLfloat z
|
||||
void;qgl;RasterPos3fv;const GLfloat *v
|
||||
void;qgl;RasterPos3i;GLint x, GLint y, GLint z
|
||||
void;qgl;RasterPos3iv;const GLint *v
|
||||
void;qgl;RasterPos3s;GLshort x, GLshort y, GLshort z
|
||||
void;qgl;RasterPos3sv;const GLshort *v
|
||||
void;qgl;RasterPos4d;GLdouble x, GLdouble y, GLdouble z, GLdouble w
|
||||
void;qgl;RasterPos4dv;const GLdouble *v
|
||||
void;qgl;RasterPos4f;GLfloat x, GLfloat y, GLfloat z, GLfloat w
|
||||
void;qgl;RasterPos4fv;const GLfloat *v
|
||||
void;qgl;RasterPos4i;GLint x, GLint y, GLint z, GLint w
|
||||
void;qgl;RasterPos4iv;const GLint *v
|
||||
void;qgl;RasterPos4s;GLshort x, GLshort y, GLshort z, GLshort w
|
||||
void;qgl;RasterPos4sv;const GLshort *v
|
||||
void;qgl;ReadBuffer;GLenum mode
|
||||
void;qgl;ReadPixels;GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels
|
||||
void;qgl;Rectd;GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2
|
||||
void;qgl;Rectdv;const GLdouble *v1, const GLdouble *v2
|
||||
void;qgl;Rectf;GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2
|
||||
void;qgl;Rectfv;const GLfloat *v1, const GLfloat *v2
|
||||
void;qgl;Recti;GLint x1, GLint y1, GLint x2, GLint y2
|
||||
void;qgl;Rectiv;const GLint *v1, const GLint *v2
|
||||
void;qgl;Rects;GLshort x1, GLshort y1, GLshort x2, GLshort y2
|
||||
void;qgl;Rectsv;const GLshort *v1, const GLshort *v2
|
||||
GLint;qgl;RenderMode;GLenum mode
|
||||
void;qgl;Rotated;GLdouble angle, GLdouble x, GLdouble y, GLdouble z
|
||||
void;qgl;Rotatef;GLfloat angle, GLfloat x, GLfloat y, GLfloat z
|
||||
void;qgl;Scaled;GLdouble x, GLdouble y, GLdouble z
|
||||
void;qgl;Scalef;GLfloat x, GLfloat y, GLfloat z
|
||||
void;qgl;Scissor;GLint x, GLint y, GLsizei width, GLsizei height
|
||||
void;qgl;SelectBuffer;GLsizei size, GLuint *buffer
|
||||
void;qgl;ShadeModel;GLenum mode
|
||||
void;qgl;StencilFunc;GLenum func, GLint ref, GLuint mask
|
||||
void;qgl;StencilMask;GLuint mask
|
||||
void;qgl;StencilOp;GLenum fail, GLenum zfail, GLenum zpass
|
||||
void;qgl;TexCoord1d;GLdouble s
|
||||
void;qgl;TexCoord1dv;const GLdouble *v
|
||||
void;qgl;TexCoord1f;GLfloat s
|
||||
void;qgl;TexCoord1fv;const GLfloat *v
|
||||
void;qgl;TexCoord1i;GLint s
|
||||
void;qgl;TexCoord1iv;const GLint *v
|
||||
void;qgl;TexCoord1s;GLshort s
|
||||
void;qgl;TexCoord1sv;const GLshort *v
|
||||
void;qgl;TexCoord2d;GLdouble s, GLdouble t
|
||||
void;qgl;TexCoord2dv;const GLdouble *v
|
||||
void;qgl;TexCoord2f;GLfloat s, GLfloat t
|
||||
void;qgl;TexCoord2fv;const GLfloat *v
|
||||
void;qgl;TexCoord2i;GLint s, GLint t
|
||||
void;qgl;TexCoord2iv;const GLint *v
|
||||
void;qgl;TexCoord2s;GLshort s, GLshort t
|
||||
void;qgl;TexCoord2sv;const GLshort *v
|
||||
void;qgl;TexCoord3d;GLdouble s, GLdouble t, GLdouble r
|
||||
void;qgl;TexCoord3dv;const GLdouble *v
|
||||
void;qgl;TexCoord3f;GLfloat s, GLfloat t, GLfloat r
|
||||
void;qgl;TexCoord3fv;const GLfloat *v
|
||||
void;qgl;TexCoord3i;GLint s, GLint t, GLint r
|
||||
void;qgl;TexCoord3iv;const GLint *v
|
||||
void;qgl;TexCoord3s;GLshort s, GLshort t, GLshort r
|
||||
void;qgl;TexCoord3sv;const GLshort *v
|
||||
void;qgl;TexCoord4d;GLdouble s, GLdouble t, GLdouble r, GLdouble q
|
||||
void;qgl;TexCoord4dv;const GLdouble *v
|
||||
void;qgl;TexCoord4f;GLfloat s, GLfloat t, GLfloat r, GLfloat q
|
||||
void;qgl;TexCoord4fv;const GLfloat *v
|
||||
void;qgl;TexCoord4i;GLint s, GLint t, GLint r, GLint q
|
||||
void;qgl;TexCoord4iv;const GLint *v
|
||||
void;qgl;TexCoord4s;GLshort s, GLshort t, GLshort r, GLshort q
|
||||
void;qgl;TexCoord4sv;const GLshort *v
|
||||
void;qgl;TexCoordPointer;GLint size, GLenum type, GLsizei stride, const GLvoid *pointer
|
||||
void;qgl;TexEnvf;GLenum target, GLenum pname, GLfloat param
|
||||
void;qgl;TexEnvfv;GLenum target, GLenum pname, const GLfloat *params
|
||||
void;qgl;TexEnvi;GLenum target, GLenum pname, GLint param
|
||||
void;qgl;TexEnviv;GLenum target, GLenum pname, const GLint *params
|
||||
void;qgl;TexGend;GLenum coord, GLenum pname, GLdouble param
|
||||
void;qgl;TexGendv;GLenum coord, GLenum pname, const GLdouble *params
|
||||
void;qgl;TexGenf;GLenum coord, GLenum pname, GLfloat param
|
||||
void;qgl;TexGenfv;GLenum coord, GLenum pname, const GLfloat *params
|
||||
void;qgl;TexGeni;GLenum coord, GLenum pname, GLint param
|
||||
void;qgl;TexGeniv;GLenum coord, GLenum pname, const GLint *params
|
||||
void;qgl;TexImage1D;GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels
|
||||
void;qgl;TexImage2D;GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels
|
||||
void;qgl;TexParameterf;GLenum target, GLenum pname, GLfloat param
|
||||
void;qgl;TexParameterfv;GLenum target, GLenum pname, const GLfloat *params
|
||||
void;qgl;TexParameteri;GLenum target, GLenum pname, GLint param
|
||||
void;qgl;TexParameteriv;GLenum target, GLenum pname, const GLint *params
|
||||
void;qgl;TexSubImage1D;GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels
|
||||
void;qgl;TexSubImage2D;GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels
|
||||
void;qgl;Translated;GLdouble x, GLdouble y, GLdouble z
|
||||
void;qgl;Translatef;GLfloat x, GLfloat y, GLfloat z
|
||||
void;qgl;Vertex2d;GLdouble x, GLdouble y
|
||||
void;qgl;Vertex2dv;const GLdouble *v
|
||||
void;qgl;Vertex2f;GLfloat x, GLfloat y
|
||||
void;qgl;Vertex2fv;const GLfloat *v
|
||||
void;qgl;Vertex2i;GLint x, GLint y
|
||||
void;qgl;Vertex2iv;const GLint *v
|
||||
void;qgl;Vertex2s;GLshort x, GLshort y
|
||||
void;qgl;Vertex2sv;const GLshort *v
|
||||
void;qgl;Vertex3d;GLdouble x, GLdouble y, GLdouble z
|
||||
void;qgl;Vertex3dv;const GLdouble *v
|
||||
void;qgl;Vertex3f;GLfloat x, GLfloat y, GLfloat z
|
||||
void;qgl;Vertex3fv;const GLfloat *v
|
||||
void;qgl;Vertex3i;GLint x, GLint y, GLint z
|
||||
void;qgl;Vertex3iv;const GLint *v
|
||||
void;qgl;Vertex3s;GLshort x, GLshort y, GLshort z
|
||||
void;qgl;Vertex3sv;const GLshort *v
|
||||
void;qgl;Vertex4d;GLdouble x, GLdouble y, GLdouble z, GLdouble w
|
||||
void;qgl;Vertex4dv;const GLdouble *v
|
||||
void;qgl;Vertex4f;GLfloat x, GLfloat y, GLfloat z, GLfloat w
|
||||
void;qgl;Vertex4fv;const GLfloat *v
|
||||
void;qgl;Vertex4i;GLint x, GLint y, GLint z, GLint w
|
||||
void;qgl;Vertex4iv;const GLint *v
|
||||
void;qgl;Vertex4s;GLshort x, GLshort y, GLshort z, GLshort w
|
||||
void;qgl;Vertex4sv;const GLshort *v
|
||||
void;qgl;VertexPointer;GLint size, GLenum type, GLsizei stride, const GLvoid *pointer
|
||||
void;qgl;Viewport;GLint x, GLint y, GLsizei width, GLsizei height
|
||||
|
|
@ -1,6 +0,0 @@
|
|||
XVisualInfo *;qglX;ChooseVisual;Display *dpy, int screen, int *attribList
|
||||
GLXContext;qglX;CreateContext;Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct
|
||||
void;qglX;DestroyContext;Display *dpy, GLXContext ctx
|
||||
Bool;qglX;MakeCurrent;Display *dpy, GLXDrawable drawable, GLXContext ctx
|
||||
void;qglX;SwapBuffers;Display *dpy, GLXDrawable drawable
|
||||
GLExtension_t;qglX;GetProcAddressARB;const GLubyte *procName
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,61 +0,0 @@
|
|||
#include "idlib/precompiled.h"
|
||||
#pragma hdrstop
|
||||
|
||||
dnl =====================================================
|
||||
dnl utils
|
||||
dnl =====================================================
|
||||
|
||||
define(`forloop',
|
||||
`pushdef(`$1', `$2')_forloop(`$1', `$2', `$3', `$4')popdef(`$1')')
|
||||
define(`_forloop',
|
||||
`$4`'ifelse($1, `$3', ,
|
||||
`define(`$1', incr($1))_forloop(`$1', `$2', `$3', `$4')')')
|
||||
|
||||
dnl =====================================================
|
||||
dnl GL extensions
|
||||
dnl =====================================================
|
||||
|
||||
typedef struct {
|
||||
const char *ext_name;
|
||||
} glExtName_t;
|
||||
|
||||
glExtName_t glExtNames[] = {
|
||||
{ NULL }
|
||||
};
|
||||
|
||||
static void StubFunction( void ) { }
|
||||
|
||||
GLExtension_t GLimp_ExtensionPointer( const char *name ) {
|
||||
if ( strstr( name, "wgl" ) == name ) {
|
||||
common->DPrintf( "WARNING: GLimp_ExtensionPointer for '%s'\n", name );
|
||||
}
|
||||
#ifdef ID_DEDICATED
|
||||
common->Printf("GLimp_ExtensionPointer %s\n", name);
|
||||
return StubFunction;
|
||||
#else
|
||||
#if 0
|
||||
glExtName_t *n;
|
||||
for ( n = glExtNames ; n->ext_name ; n++ ) {
|
||||
if ( !strcmp( name, n->ext_name ) ) {
|
||||
common->DPrintf("matched GL extension: %s\n", name );
|
||||
break;
|
||||
}
|
||||
}
|
||||
if ( ! n->ext_name ) {
|
||||
common->DPrintf("unmatched GL extension name: %s\n", name );
|
||||
}
|
||||
#endif
|
||||
GLExtension_t ret;
|
||||
#if defined(__linux__)
|
||||
// for some reason glXGetProcAddressARB doesn't work on RH9?
|
||||
ret = qglXGetProcAddressARB((const GLubyte *) name);
|
||||
if ( !ret ) {
|
||||
common->Printf("glXGetProcAddressARB failed: \"%s\"\n", name);
|
||||
return StubFunction;
|
||||
}
|
||||
#else
|
||||
#error Need OS define
|
||||
#endif
|
||||
return ret;
|
||||
#endif
|
||||
}
|
||||
|
|
@ -1,75 +0,0 @@
|
|||
#!/usr/bin/env python
|
||||
# generate logging code
|
||||
# this requires an analysis of the parameters for verbose and do actual call
|
||||
|
||||
import sys, string, re
|
||||
from read import read_gl
|
||||
|
||||
def do_logfunc(f_in, f_out):
|
||||
|
||||
(gl, wgl, glX) = read_gl(f_in)
|
||||
|
||||
for l in (gl, glX):
|
||||
for t in l:
|
||||
# process ret type to strip trailing spaces
|
||||
t[0] = string.strip(t[0])
|
||||
f_out.write('static %s APIENTRY log%s(%s) {\n' % ( t[0], t[2], t[3] ))
|
||||
# work on parameters
|
||||
base_params = string.split(t[3], ',')
|
||||
#f_out.write('// %s\n' % repr(base_params))
|
||||
# init format string and parameter list
|
||||
params = []
|
||||
format = t[1][1:] + t[2]
|
||||
# a general help list
|
||||
types = []
|
||||
names = []
|
||||
for i in base_params:
|
||||
regex = re.compile('([a-zA-Z0-9]*)$')
|
||||
name = regex.search(i).group(1)
|
||||
type = string.strip(i[0:len(i)-len(name)])
|
||||
# catch type with no name
|
||||
if (len(type) == 0):
|
||||
type = name
|
||||
name = ''
|
||||
#f_out.write('// type: "%s" name: "%s"\n' % (type, name))
|
||||
types.append(type)
|
||||
names.append(name)
|
||||
# verbose the types
|
||||
if (type == 'GLenum'):
|
||||
format += ' %s'
|
||||
params.append( 'EnumString(' + name + ')' )
|
||||
elif (type == 'GLfloat' or type == 'GLclampf' or type == 'GLdouble'):
|
||||
format += ' %g'
|
||||
params.append( name )
|
||||
elif (type == 'GLint' or type == 'GLuint' or type == 'GLsizei' or type == 'GLbyte' or type == 'GLshort'
|
||||
or type == 'GLubyte' or type == 'GLushort'):
|
||||
format += ' %d'
|
||||
params.append( name )
|
||||
elif (type == 'GLboolean'):
|
||||
format += ' %s'
|
||||
params.append( name + ' ? "Y" : "N"' )
|
||||
elif (type == 'void'):
|
||||
pass
|
||||
else:
|
||||
f_out.write('// unknown type: "%s" name: "%s"\n' % (type, name))
|
||||
format += ' \'' + type + ' ' + name + '\''
|
||||
f_out.write('\tfprintf( tr.logFile, "' + format + '\\n"')
|
||||
for par in params:
|
||||
f_out.write(', ' + par)
|
||||
f_out.write(' );\n')
|
||||
if (t[0] != 'void'):
|
||||
f_out.write('\treturn dll%s(' % t[2])
|
||||
else:
|
||||
f_out.write('\tdll%s(' % t[2])
|
||||
started = 0
|
||||
for i in names:
|
||||
if (started):
|
||||
f_out.write(', ')
|
||||
else:
|
||||
started = 1
|
||||
f_out.write(i)
|
||||
f_out.write(');\n')
|
||||
f_out.write('}\n\n')
|
||||
|
||||
if __name__ == '__main__':
|
||||
do_logfunc(sys.stdin, sys.stdout)
|
||||
|
|
@ -1,26 +0,0 @@
|
|||
# utility module to process incoming GL description
|
||||
|
||||
import sys, string
|
||||
|
||||
def read_gl(f_in):
|
||||
buffer = f_in.read()
|
||||
lines = string.split(buffer, '\n')
|
||||
|
||||
gl = []
|
||||
wgl = []
|
||||
glX = []
|
||||
|
||||
for line in lines:
|
||||
if ( len(line) ): # drop empty lines
|
||||
tokens = string.split(line, ';')
|
||||
if ( tokens[1] == 'qgl' ):
|
||||
gl.append(tokens)
|
||||
elif ( tokens[1] == 'qwgl' ):
|
||||
wgl.append(tokens)
|
||||
elif ( tokens[1] == 'qglX' ):
|
||||
glX.append(tokens)
|
||||
else:
|
||||
sys.stderr.write('ERROR: unknown type %s\n' % tokens[1])
|
||||
raise "abort"
|
||||
|
||||
return (gl, wgl, glX)
|
||||
|
|
@ -1,22 +0,0 @@
|
|||
int ;qwgl;SwapIntervalEXT; int interval
|
||||
int ;qwgl;ChoosePixelFormat ;HDC, CONST PIXELFORMATDESCRIPTOR *
|
||||
int ;qwgl;DescribePixelFormat;HDC, int, UINT, LPPIXELFORMATDESCRIPTOR
|
||||
int ;qwgl;GetPixelFormat;HDC
|
||||
BOOL ;qwgl;SetPixelFormat;HDC, int, CONST PIXELFORMATDESCRIPTOR *
|
||||
BOOL ;qwgl;SwapBuffers;HDC
|
||||
BOOL ;qwgl;CopyContext;HGLRC, HGLRC, UINT
|
||||
HGLRC ;qwgl;CreateContext;HDC
|
||||
HGLRC ;qwgl;CreateLayerContext;HDC, int
|
||||
BOOL ;qwgl;DeleteContext;HGLRC
|
||||
HGLRC ;qwgl;GetCurrentContext;VOID
|
||||
HDC ;qwgl;GetCurrentDC;VOID
|
||||
PROC ;qwgl;GetProcAddress;LPCSTR
|
||||
BOOL ;qwgl;MakeCurrent;HDC, HGLRC
|
||||
BOOL ;qwgl;ShareLists;HGLRC, HGLRC
|
||||
BOOL ;qwgl;UseFontBitmaps;HDC, DWORD, DWORD, DWORD
|
||||
BOOL ;qwgl;UseFontOutlines;HDC, DWORD, DWORD, DWORD, FLOAT, FLOAT, int, LPGLYPHMETRICSFLOAT
|
||||
BOOL ;qwgl;DescribeLayerPlane;HDC, int, int, UINT, LPLAYERPLANEDESCRIPTOR
|
||||
int ;qwgl;SetLayerPaletteEntries;HDC, int, int, int, CONST COLORREF *
|
||||
int ;qwgl;GetLayerPaletteEntries;HDC, int, int, int, COLORREF *
|
||||
BOOL ;qwgl;RealizeLayerPalette;HDC, int, BOOL
|
||||
BOOL ;qwgl;SwapLayerBuffers;HDC, UINT
|
||||
|
|
@ -71,21 +71,4 @@ int Sys_GetVideoRam( void ) {
|
|||
GL
|
||||
==========
|
||||
*/
|
||||
|
||||
void GLimp_EnableLogging( bool enable ) { }
|
||||
|
||||
bool GLimp_Init( glimpParms_t a ) { return true; }
|
||||
|
||||
void GLimp_SetGamma( unsigned short red[256],
|
||||
unsigned short green[256],
|
||||
unsigned short blue[256] ) { }
|
||||
|
||||
void GLimp_Shutdown( void ) { }
|
||||
|
||||
void GLimp_SwapBuffers( void ) { }
|
||||
|
||||
void GLimp_DeactivateContext( void ) { }
|
||||
|
||||
void GLimp_ActivateContext( void ) { }
|
||||
|
||||
bool GLimp_SetScreenParms( glimpParms_t parms ) { return true; }
|
||||
|
|
|
|||
|
|
@ -64,16 +64,14 @@ void GLimp_WakeBackEnd(void *a) {
|
|||
common->DPrintf("GLimp_WakeBackEnd stub\n");
|
||||
}
|
||||
|
||||
#ifdef ID_GL_HARDLINK
|
||||
void GLimp_EnableLogging(bool log) {
|
||||
static bool logging;
|
||||
if (log != logging)
|
||||
{
|
||||
common->DPrintf("GLimp_EnableLogging - disabled at compile time (ID_GL_HARDLINK)\n");
|
||||
common->DPrintf("GLimp_EnableLogging - not available\n");
|
||||
logging = log;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
void GLimp_FrontEndSleep() {
|
||||
common->DPrintf("GLimp_FrontEndSleep stub\n");
|
||||
|
|
@ -188,10 +186,6 @@ void GLimp_Shutdown() {
|
|||
|
||||
qglXDestroyContext( dpy, ctx );
|
||||
|
||||
#if !defined( ID_GL_HARDLINK )
|
||||
GLimp_dlclose();
|
||||
#endif
|
||||
|
||||
XDestroyWindow( dpy, win );
|
||||
if ( vidmode_active ) {
|
||||
XF86VidModeSwitchToMode( dpy, scrnum, vidmodes[0] );
|
||||
|
|
@ -563,12 +557,6 @@ bool GLimp_Init( glimpParms_t a ) {
|
|||
return false;
|
||||
}
|
||||
|
||||
#ifndef ID_GL_HARDLINK
|
||||
if ( !GLimp_dlopen() ) {
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (!GLX_Init(a)) {
|
||||
return false;
|
||||
}
|
||||
|
|
@ -665,3 +653,33 @@ int Sys_GetVideoRam( void ) {
|
|||
run_once = 64;
|
||||
return run_once;
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
GLimp_ExtensionPointer
|
||||
===================
|
||||
*/
|
||||
static void StubFunction( void ) { }
|
||||
|
||||
GLExtension_t GLimp_ExtensionPointer( const char *name ) {
|
||||
if ( strstr( name, "wgl" ) == name ) {
|
||||
common->DPrintf( "WARNING: GLimp_ExtensionPointer for '%s'\n", name );
|
||||
}
|
||||
#ifdef ID_DEDICATED
|
||||
common->Printf("GLimp_ExtensionPointer %s\n", name);
|
||||
return StubFunction;
|
||||
#else
|
||||
GLExtension_t ret;
|
||||
#if defined(__unix__)
|
||||
// for some reason glXGetProcAddressARB doesn't work on RH9?
|
||||
ret = qglXGetProcAddressARB((const GLubyte *) name);
|
||||
if ( !ret ) {
|
||||
common->Printf("glXGetProcAddressARB failed: \"%s\"\n", name);
|
||||
return StubFunction;
|
||||
}
|
||||
#else
|
||||
#error Need OS define
|
||||
#endif
|
||||
return ret;
|
||||
#endif
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,135 +0,0 @@
|
|||
#include "idlib/precompiled.h"
|
||||
#include "renderer/tr_local.h"
|
||||
#include "sys/linux/local.h"
|
||||
#include "glimp_local.h"
|
||||
|
||||
#include <dlfcn.h>
|
||||
|
||||
dnl =====================================================
|
||||
dnl utils
|
||||
dnl =====================================================
|
||||
|
||||
define(`forloop',
|
||||
`pushdef(`$1', `$2')_forloop(`$1', `$2', `$3', `$4')popdef(`$1')')
|
||||
define(`_forloop',
|
||||
`$4`'ifelse($1, `$3', ,
|
||||
`define(`$1', incr($1))_forloop(`$1', `$2', `$3', `$4')')')
|
||||
|
||||
dnl =====================================================
|
||||
dnl the gl wgl glX definitions
|
||||
dnl =====================================================
|
||||
include(../gllog/gl_def.m4)
|
||||
|
||||
dnl =====================================================
|
||||
dnl qgl function ptrs
|
||||
dnl =====================================================
|
||||
|
||||
define(`instance_funcptr', ``$1' ( APIENTRY * qgl`$2' )(`$3');')
|
||||
forloop(`i', gl_start, gl_end, `instance_funcptr(indir(`f'i`_ret'), indir(`f'i`_name'), indir(`f'i`_params'))
|
||||
')
|
||||
|
||||
dnl =====================================================
|
||||
dnl glX function ptrs
|
||||
dnl =====================================================
|
||||
|
||||
define(`instance_funcptr', ``$1' ( * qglX`$2' )(`$3');')
|
||||
forloop(`i', glX_start, glX_end, `instance_funcptr(indir(`f'i`_ret'), indir(`f'i`_name'), indir(`f'i`_params'))
|
||||
')
|
||||
|
||||
dnl =====================================================
|
||||
dnl dll ptrs
|
||||
dnl those are the actual dlsym'ed pointers
|
||||
dnl logging configuration redirects qgl / qglX to either log or dll versions
|
||||
dnl =====================================================
|
||||
|
||||
define(`instance_funcptr', ``$1' ( * dll`$2' )(`$3');')
|
||||
forloop(`i', gl_start, gl_end, `instance_funcptr(indir(`f'i`_ret'), indir(`f'i`_name'), indir(`f'i`_params'))
|
||||
')
|
||||
forloop(`i', glX_start, glX_end, `instance_funcptr(indir(`f'i`_ret'), indir(`f'i`_name'), indir(`f'i`_params'))
|
||||
')
|
||||
|
||||
dnl =====================================================
|
||||
dnl code
|
||||
dnl =====================================================
|
||||
|
||||
/*
|
||||
======================
|
||||
GLimp_BindNative
|
||||
======================
|
||||
*/
|
||||
void GLimp_BindNative() {
|
||||
define(`assign_funcptr', `qgl`$1' = dll`$1';')
|
||||
forloop(`i', gl_start, gl_end, `assign_funcptr(indir(`f'i`_name'))
|
||||
')
|
||||
|
||||
define(`assign_funcptr', `qglX`$1' = dll`$1';')
|
||||
forloop(`i', glX_start, glX_end, `assign_funcptr(indir(`f'i`_name'))
|
||||
')
|
||||
}
|
||||
|
||||
static void *glHandle = NULL;
|
||||
|
||||
/*
|
||||
======================
|
||||
GLimp_dlsym_failed
|
||||
======================
|
||||
*/
|
||||
void GLimp_dlsym_failed(const char *name) {
|
||||
common->DPrintf("dlsym(%s) failed: %s\n", name, dlerror());
|
||||
}
|
||||
|
||||
/*
|
||||
======================
|
||||
GLimp_dlopen
|
||||
======================
|
||||
*/
|
||||
bool GLimp_dlopen() {
|
||||
const char *driverName = r_glDriver.GetString()[0] ? r_glDriver.GetString() : "libGL.so.1";
|
||||
common->Printf("dlopen(%s)\n", driverName);
|
||||
if ( !( glHandle = dlopen( driverName, RTLD_NOW | RTLD_GLOBAL ) ) ) {
|
||||
common->DPrintf("dlopen(%s) failed: %s\n", driverName, dlerror());
|
||||
return false;
|
||||
}
|
||||
|
||||
// dlsym the symbols
|
||||
|
||||
define(`dlsym_funcptr', `dll`$2' = ( `$1' ( APIENTRY *)(`$3') ) dlsym( glHandle, "gl`$2'" );')
|
||||
define(`safe_dlsym_funcptr', `dlsym_funcptr(`$1', `$2', `$3')
|
||||
if (!dll`$2') { GLimp_dlsym_failed("gl`$2'"); return false; }')
|
||||
forloop(`i', gl_start, gl_end, `safe_dlsym_funcptr(indir(`f'i`_ret'), indir(`f'i`_name'), indir(`f'i`_params'))
|
||||
')
|
||||
|
||||
define(`dlsym_funcptr', `dll`$2' = ( `$1' ( APIENTRY *)(`$3') ) dlsym( glHandle, "glX`$2'" );')
|
||||
define(`safe_dlsym_funcptr', `dlsym_funcptr(`$1', `$2', `$3')
|
||||
if (!dll`$2') { GLimp_dlsym_failed("glX`$2'"); return false; }')
|
||||
forloop(`i', glX_start, glX_end, `safe_dlsym_funcptr(indir(`f'i`_ret'), indir(`f'i`_name'), indir(`f'i`_params'))
|
||||
')
|
||||
|
||||
// make the initial binding
|
||||
GLimp_BindNative();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
======================
|
||||
GLimp_dlclose
|
||||
======================
|
||||
*/
|
||||
void GLimp_dlclose() {
|
||||
if ( !glHandle ) {
|
||||
common->DPrintf("dlclose: GL handle is NULL\n");
|
||||
} else {
|
||||
dlclose( glHandle );
|
||||
glHandle = NULL;
|
||||
}
|
||||
|
||||
define(`reset_funcptr', `qgl`$1' = NULL;')
|
||||
forloop(`i', gl_start, gl_end, `reset_funcptr(indir(`f'i`_name'))
|
||||
')
|
||||
|
||||
define(`reset_funcptr', `qglX`$1' = NULL;')
|
||||
forloop(`i', glX_start, glX_end, `reset_funcptr(indir(`f'i`_name'))
|
||||
')
|
||||
|
||||
}
|
||||
|
|
@ -1,434 +0,0 @@
|
|||
/*
|
||||
===========================================================================
|
||||
|
||||
Doom 3 GPL Source Code
|
||||
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
||||
|
||||
This file is part of the Doom 3 GPL Source Code ("Doom 3 Source Code").
|
||||
|
||||
Doom 3 Source Code 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 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Doom 3 Source Code 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 Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
||||
|
||||
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
||||
|
||||
===========================================================================
|
||||
*/
|
||||
DEF(GL_FALSE)
|
||||
DEF(GL_TRUE)
|
||||
DEF(GL_BYTE)
|
||||
DEF(GL_UNSIGNED_BYTE)
|
||||
DEF(GL_SHORT)
|
||||
DEF(GL_UNSIGNED_SHORT)
|
||||
DEF(GL_INT)
|
||||
DEF(GL_UNSIGNED_INT)
|
||||
DEF(GL_FLOAT)
|
||||
DEF(GL_DOUBLE)
|
||||
DEF(GL_TEXTURE_CUBE_MAP_EXT)
|
||||
DEF(GL_TEXTURE_3D)
|
||||
DEF(GL_TEXTURE_2D)
|
||||
DEF(GL_BLEND)
|
||||
DEF(GL_DEPTH_TEST)
|
||||
DEF(GL_CULL_FACE)
|
||||
DEF(GL_CLIP_PLANE0)
|
||||
DEF(GL_COLOR_ARRAY)
|
||||
DEF(GL_TEXTURE_COORD_ARRAY)
|
||||
DEF(GL_VERTEX_ARRAY)
|
||||
DEF(GL_ALPHA_TEST)
|
||||
DEF(GL_TEXTURE_GEN_S)
|
||||
DEF(GL_TEXTURE_GEN_T)
|
||||
DEF(GL_TEXTURE_GEN_R)
|
||||
DEF(GL_TEXTURE_GEN_Q)
|
||||
DEF(GL_STENCIL_TEST)
|
||||
DEF(GL_POLYGON_OFFSET_FILL)
|
||||
DEF(GL_TRIANGLES)
|
||||
DEF(GL_TRIANGLE_STRIP)
|
||||
DEF(GL_TRIANGLE_FAN)
|
||||
DEF(GL_QUADS)
|
||||
DEF(GL_QUAD_STRIP)
|
||||
DEF(GL_POLYGON)
|
||||
DEF(GL_POINTS)
|
||||
DEF(GL_LINES)
|
||||
DEF(GL_LINE_STRIP)
|
||||
DEF(GL_LINE_LOOP)
|
||||
DEF(GL_ALWAYS)
|
||||
DEF(GL_NEVER)
|
||||
DEF(GL_LEQUAL)
|
||||
DEF(GL_LESS)
|
||||
DEF(GL_EQUAL)
|
||||
DEF(GL_GREATER)
|
||||
DEF(GL_GEQUAL)
|
||||
DEF(GL_NOTEQUAL)
|
||||
DEF(GL_ONE)
|
||||
DEF(GL_ZERO)
|
||||
DEF(GL_SRC_ALPHA)
|
||||
DEF(GL_ONE_MINUS_SRC_ALPHA)
|
||||
DEF(GL_DST_COLOR)
|
||||
DEF(GL_ONE_MINUS_DST_COLOR)
|
||||
DEF(GL_DST_ALPHA)
|
||||
DEF(GL_MODELVIEW)
|
||||
DEF(GL_PROJECTION)
|
||||
DEF(GL_TEXTURE)
|
||||
DEF(GL_NONE)
|
||||
DEF(GL_FRONT_LEFT)
|
||||
DEF(GL_FRONT_RIGHT)
|
||||
DEF(GL_BACK_LEFT)
|
||||
DEF(GL_BACK_RIGHT)
|
||||
DEF(GL_FRONT)
|
||||
DEF(GL_BACK)
|
||||
DEF(GL_LEFT)
|
||||
DEF(GL_RIGHT)
|
||||
DEF(GL_FRONT_AND_BACK)
|
||||
DEF(GL_AUX0)
|
||||
DEF(GL_AUX1)
|
||||
DEF(GL_AUX2)
|
||||
DEF(GL_AUX3)
|
||||
DEF(GL_CURRENT_COLOR)
|
||||
DEF(GL_CURRENT_INDEX)
|
||||
DEF(GL_CURRENT_NORMAL)
|
||||
DEF(GL_CURRENT_TEXTURE_COORDS)
|
||||
DEF(GL_CURRENT_RASTER_COLOR)
|
||||
DEF(GL_CURRENT_RASTER_INDEX)
|
||||
DEF(GL_CURRENT_RASTER_TEXTURE_COORDS)
|
||||
DEF(GL_CURRENT_RASTER_POSITION)
|
||||
DEF(GL_CURRENT_RASTER_POSITION_VALID)
|
||||
DEF(GL_CURRENT_RASTER_DISTANCE)
|
||||
DEF(GL_POINT_SMOOTH)
|
||||
DEF(GL_POINT_SIZE)
|
||||
DEF(GL_POINT_SIZE_RANGE)
|
||||
DEF(GL_POINT_SIZE_GRANULARITY)
|
||||
DEF(GL_LINE_SMOOTH)
|
||||
DEF(GL_LINE_WIDTH)
|
||||
DEF(GL_LINE_WIDTH_RANGE)
|
||||
DEF(GL_LINE_WIDTH_GRANULARITY)
|
||||
DEF(GL_LINE_STIPPLE)
|
||||
DEF(GL_LINE_STIPPLE_PATTERN)
|
||||
DEF(GL_LINE_STIPPLE_REPEAT)
|
||||
DEF(GL_LIST_MODE)
|
||||
DEF(GL_MAX_LIST_NESTING)
|
||||
DEF(GL_LIST_BASE)
|
||||
DEF(GL_LIST_INDEX)
|
||||
DEF(GL_POLYGON_MODE)
|
||||
DEF(GL_POLYGON_SMOOTH)
|
||||
DEF(GL_POLYGON_STIPPLE)
|
||||
DEF(GL_EDGE_FLAG)
|
||||
DEF(GL_CULL_FACE)
|
||||
DEF(GL_CULL_FACE_MODE)
|
||||
DEF(GL_FRONT_FACE)
|
||||
DEF(GL_LIGHTING)
|
||||
DEF(GL_LIGHT_MODEL_LOCAL_VIEWER)
|
||||
DEF(GL_LIGHT_MODEL_TWO_SIDE)
|
||||
DEF(GL_LIGHT_MODEL_AMBIENT)
|
||||
DEF(GL_SHADE_MODEL)
|
||||
DEF(GL_COLOR_MATERIAL_FACE)
|
||||
DEF(GL_COLOR_MATERIAL_PARAMETER)
|
||||
DEF(GL_COLOR_MATERIAL)
|
||||
DEF(GL_FOG)
|
||||
DEF(GL_FOG_INDEX)
|
||||
DEF(GL_FOG_DENSITY)
|
||||
DEF(GL_FOG_START)
|
||||
DEF(GL_FOG_END)
|
||||
DEF(GL_FOG_MODE)
|
||||
DEF(GL_FOG_COLOR)
|
||||
DEF(GL_DEPTH_RANGE)
|
||||
DEF(GL_DEPTH_TEST)
|
||||
DEF(GL_DEPTH_WRITEMASK)
|
||||
DEF(GL_DEPTH_CLEAR_VALUE)
|
||||
DEF(GL_DEPTH_FUNC)
|
||||
DEF(GL_ACCUM_CLEAR_VALUE)
|
||||
DEF(GL_STENCIL_TEST)
|
||||
DEF(GL_STENCIL_CLEAR_VALUE)
|
||||
DEF(GL_STENCIL_FUNC)
|
||||
DEF(GL_STENCIL_VALUE_MASK)
|
||||
DEF(GL_STENCIL_FAIL)
|
||||
DEF(GL_STENCIL_PASS_DEPTH_FAIL)
|
||||
DEF(GL_STENCIL_PASS_DEPTH_PASS)
|
||||
DEF(GL_STENCIL_REF)
|
||||
DEF(GL_STENCIL_WRITEMASK)
|
||||
DEF(GL_MATRIX_MODE)
|
||||
DEF(GL_NORMALIZE)
|
||||
DEF(GL_VIEWPORT)
|
||||
DEF(GL_MODELVIEW_STACK_DEPTH)
|
||||
DEF(GL_PROJECTION_STACK_DEPTH)
|
||||
DEF(GL_TEXTURE_STACK_DEPTH)
|
||||
DEF(GL_MODELVIEW_MATRIX)
|
||||
DEF(GL_PROJECTION_MATRIX)
|
||||
DEF(GL_TEXTURE_MATRIX)
|
||||
DEF(GL_ATTRIB_STACK_DEPTH)
|
||||
DEF(GL_CLIENT_ATTRIB_STACK_DEPTH)
|
||||
DEF(GL_ALPHA_TEST)
|
||||
DEF(GL_ALPHA_TEST_FUNC)
|
||||
DEF(GL_ALPHA_TEST_REF)
|
||||
DEF(GL_DITHER)
|
||||
DEF(GL_BLEND_DST)
|
||||
DEF(GL_BLEND_SRC)
|
||||
DEF(GL_BLEND)
|
||||
DEF(GL_LOGIC_OP_MODE)
|
||||
DEF(GL_INDEX_LOGIC_OP)
|
||||
DEF(GL_COLOR_LOGIC_OP)
|
||||
DEF(GL_AUX_BUFFERS)
|
||||
DEF(GL_DRAW_BUFFER)
|
||||
DEF(GL_READ_BUFFER)
|
||||
DEF(GL_SCISSOR_BOX)
|
||||
DEF(GL_SCISSOR_TEST)
|
||||
DEF(GL_INDEX_CLEAR_VALUE)
|
||||
DEF(GL_INDEX_WRITEMASK)
|
||||
DEF(GL_COLOR_CLEAR_VALUE)
|
||||
DEF(GL_COLOR_WRITEMASK)
|
||||
DEF(GL_INDEX_MODE)
|
||||
DEF(GL_RGBA_MODE)
|
||||
DEF(GL_DOUBLEBUFFER)
|
||||
DEF(GL_STEREO)
|
||||
DEF(GL_RENDER_MODE)
|
||||
DEF(GL_PERSPECTIVE_CORRECTION_HINT)
|
||||
DEF(GL_POINT_SMOOTH_HINT)
|
||||
DEF(GL_LINE_SMOOTH_HINT)
|
||||
DEF(GL_POLYGON_SMOOTH_HINT)
|
||||
DEF(GL_FOG_HINT)
|
||||
DEF(GL_TEXTURE_GEN_S)
|
||||
DEF(GL_TEXTURE_GEN_T)
|
||||
DEF(GL_TEXTURE_GEN_R)
|
||||
DEF(GL_TEXTURE_GEN_Q)
|
||||
DEF(GL_PIXEL_MAP_I_TO_I)
|
||||
DEF(GL_PIXEL_MAP_S_TO_S)
|
||||
DEF(GL_PIXEL_MAP_I_TO_R)
|
||||
DEF(GL_PIXEL_MAP_I_TO_G)
|
||||
DEF(GL_PIXEL_MAP_I_TO_B)
|
||||
DEF(GL_PIXEL_MAP_I_TO_A)
|
||||
DEF(GL_PIXEL_MAP_R_TO_R)
|
||||
DEF(GL_PIXEL_MAP_G_TO_G)
|
||||
DEF(GL_PIXEL_MAP_B_TO_B)
|
||||
DEF(GL_PIXEL_MAP_A_TO_A)
|
||||
DEF(GL_PIXEL_MAP_I_TO_I_SIZE)
|
||||
DEF(GL_PIXEL_MAP_S_TO_S_SIZE)
|
||||
DEF(GL_PIXEL_MAP_I_TO_R_SIZE)
|
||||
DEF(GL_PIXEL_MAP_I_TO_G_SIZE)
|
||||
DEF(GL_PIXEL_MAP_I_TO_B_SIZE)
|
||||
DEF(GL_PIXEL_MAP_I_TO_A_SIZE)
|
||||
DEF(GL_PIXEL_MAP_R_TO_R_SIZE)
|
||||
DEF(GL_PIXEL_MAP_G_TO_G_SIZE)
|
||||
DEF(GL_PIXEL_MAP_B_TO_B_SIZE)
|
||||
DEF(GL_PIXEL_MAP_A_TO_A_SIZE)
|
||||
DEF(GL_UNPACK_SWAP_BYTES)
|
||||
DEF(GL_UNPACK_LSB_FIRST)
|
||||
DEF(GL_UNPACK_ROW_LENGTH)
|
||||
DEF(GL_UNPACK_SKIP_ROWS)
|
||||
DEF(GL_UNPACK_SKIP_PIXELS)
|
||||
DEF(GL_UNPACK_ALIGNMENT)
|
||||
DEF(GL_PACK_SWAP_BYTES)
|
||||
DEF(GL_PACK_LSB_FIRST)
|
||||
DEF(GL_PACK_ROW_LENGTH)
|
||||
DEF(GL_PACK_SKIP_ROWS)
|
||||
DEF(GL_PACK_SKIP_PIXELS)
|
||||
DEF(GL_PACK_ALIGNMENT)
|
||||
DEF(GL_MAP_COLOR)
|
||||
DEF(GL_MAP_STENCIL)
|
||||
DEF(GL_INDEX_SHIFT)
|
||||
DEF(GL_INDEX_OFFSET)
|
||||
DEF(GL_RED_SCALE)
|
||||
DEF(GL_RED_BIAS)
|
||||
DEF(GL_ZOOM_X)
|
||||
DEF(GL_ZOOM_Y)
|
||||
DEF(GL_GREEN_SCALE)
|
||||
DEF(GL_GREEN_BIAS)
|
||||
DEF(GL_BLUE_SCALE)
|
||||
DEF(GL_BLUE_BIAS)
|
||||
DEF(GL_ALPHA_SCALE)
|
||||
DEF(GL_ALPHA_BIAS)
|
||||
DEF(GL_DEPTH_SCALE)
|
||||
DEF(GL_DEPTH_BIAS)
|
||||
DEF(GL_MAX_EVAL_ORDER)
|
||||
DEF(GL_MAX_LIGHTS)
|
||||
DEF(GL_MAX_CLIP_PLANES)
|
||||
DEF(GL_MAX_TEXTURE_SIZE)
|
||||
DEF(GL_MAX_PIXEL_MAP_TABLE)
|
||||
DEF(GL_MAX_ATTRIB_STACK_DEPTH)
|
||||
DEF(GL_MAX_MODELVIEW_STACK_DEPTH)
|
||||
DEF(GL_MAX_NAME_STACK_DEPTH)
|
||||
DEF(GL_MAX_PROJECTION_STACK_DEPTH)
|
||||
DEF(GL_MAX_TEXTURE_STACK_DEPTH)
|
||||
DEF(GL_MAX_VIEWPORT_DIMS)
|
||||
DEF(GL_MAX_CLIENT_ATTRIB_STACK_DEPTH)
|
||||
DEF(GL_SUBPIXEL_BITS)
|
||||
DEF(GL_INDEX_BITS)
|
||||
DEF(GL_RED_BITS)
|
||||
DEF(GL_GREEN_BITS)
|
||||
DEF(GL_BLUE_BITS)
|
||||
DEF(GL_ALPHA_BITS)
|
||||
DEF(GL_DEPTH_BITS)
|
||||
DEF(GL_STENCIL_BITS)
|
||||
DEF(GL_ACCUM_RED_BITS)
|
||||
DEF(GL_ACCUM_GREEN_BITS)
|
||||
DEF(GL_ACCUM_BLUE_BITS)
|
||||
DEF(GL_ACCUM_ALPHA_BITS)
|
||||
DEF(GL_NAME_STACK_DEPTH)
|
||||
DEF(GL_AUTO_NORMAL)
|
||||
DEF(GL_MAP1_COLOR_4)
|
||||
DEF(GL_MAP1_INDEX)
|
||||
DEF(GL_MAP1_NORMAL)
|
||||
DEF(GL_MAP1_TEXTURE_COORD_1)
|
||||
DEF(GL_MAP1_TEXTURE_COORD_2)
|
||||
DEF(GL_MAP1_TEXTURE_COORD_3)
|
||||
DEF(GL_MAP1_TEXTURE_COORD_4)
|
||||
DEF(GL_MAP1_VERTEX_3)
|
||||
DEF(GL_MAP1_VERTEX_4)
|
||||
DEF(GL_MAP2_COLOR_4)
|
||||
DEF(GL_MAP2_INDEX)
|
||||
DEF(GL_MAP2_NORMAL)
|
||||
DEF(GL_MAP2_TEXTURE_COORD_1)
|
||||
DEF(GL_MAP2_TEXTURE_COORD_2)
|
||||
DEF(GL_MAP2_TEXTURE_COORD_3)
|
||||
DEF(GL_MAP2_TEXTURE_COORD_4)
|
||||
DEF(GL_MAP2_VERTEX_3)
|
||||
DEF(GL_MAP2_VERTEX_4)
|
||||
DEF(GL_MAP1_GRID_DOMAIN)
|
||||
DEF(GL_MAP1_GRID_SEGMENTS)
|
||||
DEF(GL_MAP2_GRID_DOMAIN)
|
||||
DEF(GL_MAP2_GRID_SEGMENTS)
|
||||
DEF(GL_TEXTURE_1D)
|
||||
DEF(GL_TEXTURE_2D)
|
||||
DEF(GL_FEEDBACK_BUFFER_POINTER)
|
||||
DEF(GL_FEEDBACK_BUFFER_SIZE)
|
||||
DEF(GL_FEEDBACK_BUFFER_TYPE)
|
||||
DEF(GL_SELECTION_BUFFER_POINTER)
|
||||
DEF(GL_SELECTION_BUFFER_SIZE)
|
||||
DEF(GL_COLOR)
|
||||
DEF(GL_DEPTH)
|
||||
DEF(GL_STENCIL)
|
||||
DEF(GL_COLOR_INDEX)
|
||||
DEF(GL_STENCIL_INDEX)
|
||||
DEF(GL_DEPTH_COMPONENT)
|
||||
DEF(GL_RED)
|
||||
DEF(GL_GREEN)
|
||||
DEF(GL_BLUE)
|
||||
DEF(GL_ALPHA)
|
||||
DEF(GL_RGB)
|
||||
DEF(GL_RGBA)
|
||||
DEF(GL_LUMINANCE)
|
||||
DEF(GL_LUMINANCE_ALPHA)
|
||||
DEF(GL_PIXEL_MAP_I_TO_I)
|
||||
DEF(GL_PIXEL_MAP_S_TO_S)
|
||||
DEF(GL_PIXEL_MAP_I_TO_R)
|
||||
DEF(GL_PIXEL_MAP_I_TO_G)
|
||||
DEF(GL_PIXEL_MAP_I_TO_B)
|
||||
DEF(GL_PIXEL_MAP_I_TO_A)
|
||||
DEF(GL_PIXEL_MAP_R_TO_R)
|
||||
DEF(GL_PIXEL_MAP_G_TO_G)
|
||||
DEF(GL_PIXEL_MAP_B_TO_B)
|
||||
DEF(GL_PIXEL_MAP_A_TO_A)
|
||||
DEF(GL_UNPACK_SWAP_BYTES)
|
||||
DEF(GL_UNPACK_LSB_FIRST)
|
||||
DEF(GL_UNPACK_ROW_LENGTH)
|
||||
DEF(GL_UNPACK_SKIP_ROWS)
|
||||
DEF(GL_UNPACK_SKIP_PIXELS)
|
||||
DEF(GL_UNPACK_ALIGNMENT)
|
||||
DEF(GL_PACK_SWAP_BYTES)
|
||||
DEF(GL_PACK_LSB_FIRST)
|
||||
DEF(GL_PACK_ROW_LENGTH)
|
||||
DEF(GL_PACK_SKIP_ROWS)
|
||||
DEF(GL_PACK_SKIP_PIXELS)
|
||||
DEF(GL_PACK_ALIGNMENT)
|
||||
DEF(GL_MAP_COLOR)
|
||||
DEF(GL_MAP_STENCIL)
|
||||
DEF(GL_INDEX_SHIFT)
|
||||
DEF(GL_INDEX_OFFSET)
|
||||
DEF(GL_RED_SCALE)
|
||||
DEF(GL_RED_BIAS)
|
||||
DEF(GL_GREEN_SCALE)
|
||||
DEF(GL_GREEN_BIAS)
|
||||
DEF(GL_BLUE_SCALE)
|
||||
DEF(GL_BLUE_BIAS)
|
||||
DEF(GL_ALPHA_SCALE)
|
||||
DEF(GL_ALPHA_BIAS)
|
||||
DEF(GL_DEPTH_SCALE)
|
||||
DEF(GL_DEPTH_BIAS)
|
||||
DEF(GL_BITMAP)
|
||||
DEF(GL_BYTE)
|
||||
DEF(GL_UNSIGNED_BYTE)
|
||||
DEF(GL_SHORT)
|
||||
DEF(GL_UNSIGNED_SHORT)
|
||||
DEF(GL_INT)
|
||||
DEF(GL_UNSIGNED_INT)
|
||||
DEF(GL_FLOAT)
|
||||
DEF(GL_POINT)
|
||||
DEF(GL_LINE)
|
||||
DEF(GL_FILL)
|
||||
DEF(GL_RENDER)
|
||||
DEF(GL_FEEDBACK)
|
||||
DEF(GL_SELECT)
|
||||
DEF(GL_FLAT)
|
||||
DEF(GL_SMOOTH)
|
||||
DEF(GL_ZERO)
|
||||
DEF(GL_KEEP)
|
||||
DEF(GL_REPLACE)
|
||||
DEF(GL_INCR)
|
||||
DEF(GL_DECR)
|
||||
DEF(GL_INVERT)
|
||||
DEF(GL_VENDOR)
|
||||
DEF(GL_RENDERER)
|
||||
DEF(GL_VERSION)
|
||||
DEF(GL_EXTENSIONS)
|
||||
DEF(GL_S)
|
||||
DEF(GL_T)
|
||||
DEF(GL_R)
|
||||
DEF(GL_Q)
|
||||
DEF(GL_SHORT)
|
||||
DEF(GL_INT)
|
||||
DEF(GL_FLOAT)
|
||||
DEF(GL_DOUBLE)
|
||||
DEF(GL_MODULATE)
|
||||
DEF(GL_DECAL)
|
||||
DEF(GL_BLEND)
|
||||
DEF(GL_REPLACE)
|
||||
DEF(GL_TEXTURE_ENV_MODE)
|
||||
DEF(GL_TEXTURE_ENV_COLOR)
|
||||
DEF(GL_TEXTURE_ENV)
|
||||
DEF(GL_EYE_LINEAR)
|
||||
DEF(GL_OBJECT_LINEAR)
|
||||
DEF(GL_SPHERE_MAP)
|
||||
DEF(GL_TEXTURE_GEN_MODE)
|
||||
DEF(GL_OBJECT_PLANE)
|
||||
DEF(GL_EYE_PLANE)
|
||||
DEF(GL_NEAREST)
|
||||
DEF(GL_LINEAR)
|
||||
DEF(GL_NEAREST)
|
||||
DEF(GL_LINEAR)
|
||||
DEF(GL_NEAREST_MIPMAP_NEAREST)
|
||||
DEF(GL_LINEAR_MIPMAP_NEAREST)
|
||||
DEF(GL_NEAREST_MIPMAP_LINEAR)
|
||||
DEF(GL_LINEAR_MIPMAP_LINEAR)
|
||||
DEF(GL_TEXTURE_MAG_FILTER)
|
||||
DEF(GL_TEXTURE_MIN_FILTER)
|
||||
DEF(GL_TEXTURE_WRAP_S)
|
||||
DEF(GL_TEXTURE_WRAP_T)
|
||||
DEF(GL_TEXTURE_BORDER_COLOR)
|
||||
DEF(GL_TEXTURE_PRIORITY)
|
||||
DEF(GL_TEXTURE_1D)
|
||||
DEF(GL_TEXTURE_2D)
|
||||
DEF(GL_PROXY_TEXTURE_1D)
|
||||
DEF(GL_PROXY_TEXTURE_2D)
|
||||
DEF(GL_CLAMP)
|
||||
DEF(GL_REPEAT)
|
||||
DEF(GL_SHORT)
|
||||
DEF(GL_INT)
|
||||
DEF(GL_FLOAT)
|
||||
DEF(GL_DOUBLE)
|
||||
DEF(GL_CLIENT_PIXEL_STORE_BIT)
|
||||
DEF(GL_CLIENT_VERTEX_ARRAY_BIT)
|
||||
/* DEF(GL_CLIENT_ALL_ATTRIB_BITS) */
|
||||
DEF(GL_POLYGON_OFFSET_FACTOR)
|
||||
DEF(GL_POLYGON_OFFSET_UNITS)
|
||||
DEF(GL_POLYGON_OFFSET_POINT)
|
||||
DEF(GL_POLYGON_OFFSET_LINE)
|
||||
DEF(GL_POLYGON_OFFSET_FILL)
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
dnl =====================================================
|
||||
dnl utils
|
||||
dnl =====================================================
|
||||
|
||||
define(`forloop',
|
||||
`pushdef(`$1', `$2')_forloop(`$1', `$2', `$3', `$4')popdef(`$1')')
|
||||
define(`_forloop',
|
||||
`$4`'ifelse($1, `$3', ,
|
||||
`define(`$1', incr($1))_forloop(`$1', `$2', `$3', `$4')')')
|
||||
|
||||
dnl =====================================================
|
||||
dnl the gl wgl glX definitions
|
||||
dnl =====================================================
|
||||
include(../gllog/gl_def.m4)
|
||||
|
||||
dnl =====================================================
|
||||
dnl dll funcs declare
|
||||
dnl =====================================================
|
||||
|
||||
define(`declare_funcptr', `extern `$1' ( * dll`$2' )(`$3');')
|
||||
forloop(`i', gl_start, gl_end, `declare_funcptr(indir(`f'i`_ret'), indir(`f'i`_name'), indir(`f'i`_params'))
|
||||
')
|
||||
forloop(`i', glX_start, glX_end, `declare_funcptr(indir(`f'i`_ret'), indir(`f'i`_name'), indir(`f'i`_params'))
|
||||
')
|
||||
|
|
@ -1,187 +0,0 @@
|
|||
#include "idlib/precompiled.h"
|
||||
#include "renderer/tr_local.h"
|
||||
#include "sys/linux/local.h"
|
||||
#include "glimp_local.h"
|
||||
#pragma hdrstop
|
||||
|
||||
#include <unistd.h>
|
||||
#define ID_LOG_TO_STDOUT 0
|
||||
|
||||
dnl =====================================================
|
||||
dnl utils
|
||||
dnl =====================================================
|
||||
|
||||
define(`forloop',
|
||||
`pushdef(`$1', `$2')_forloop(`$1', `$2', `$3', `$4')popdef(`$1')')
|
||||
define(`_forloop',
|
||||
`$4`'ifelse($1, `$3', ,
|
||||
`define(`$1', incr($1))_forloop(`$1', `$2', `$3', `$4')')')
|
||||
|
||||
dnl =====================================================
|
||||
dnl the gl wgl glX definitions
|
||||
dnl =====================================================
|
||||
include(../gllog/gl_def.m4)
|
||||
|
||||
dnl =====================================================
|
||||
dnl logging functions
|
||||
dnl =====================================================
|
||||
|
||||
typedef struct {
|
||||
GLenum e;
|
||||
const char *name;
|
||||
} glEnumName_t;
|
||||
|
||||
#define DEF(x) { x, #x },
|
||||
|
||||
glEnumName_t glEnumNames[] = {
|
||||
#include "sys/linux/glimp_glenum.h"
|
||||
{ 0, NULL }
|
||||
};
|
||||
|
||||
/*
|
||||
======================
|
||||
EnumString
|
||||
======================
|
||||
*/
|
||||
static const char *EnumString( GLenum t )
|
||||
{
|
||||
static char buffer[8][1024];
|
||||
static int index = 0;
|
||||
|
||||
for ( glEnumName_t *n = glEnumNames ; n->name ; n++ ) {
|
||||
if ( t == n->e ) {
|
||||
return n->name;
|
||||
}
|
||||
}
|
||||
|
||||
int oldIndex = index;
|
||||
index = ( index + 1 ) & 7;
|
||||
sprintf( buffer[oldIndex], "0x%x", t );
|
||||
|
||||
return buffer[oldIndex];
|
||||
}
|
||||
|
||||
/*
|
||||
======================
|
||||
FloatData
|
||||
======================
|
||||
*/
|
||||
#if 0
|
||||
static const char *FloatData( const GLfloat *v, int count ) {
|
||||
static char buffer[8][1024];
|
||||
static int index = 0;
|
||||
char *name;
|
||||
|
||||
name = buffer[index&7];
|
||||
sprintf( name, "f%i", index );
|
||||
index++;
|
||||
|
||||
fprintf( tr.logFile, "static float %s[%i] = {", name, count );
|
||||
for( int i = 0 ; i < count ; i++ ) {
|
||||
if ( i < count - 1 ) {
|
||||
fprintf( tr.logFile, "%f,", v[i] );
|
||||
} else {
|
||||
fprintf( tr.logFile, "%f};\n", v[i] );
|
||||
}
|
||||
}
|
||||
|
||||
return name;
|
||||
}
|
||||
#endif
|
||||
#
|
||||
#include "glimp_logfuncs.cpp"
|
||||
|
||||
dnl define(`log_func', `static `$1' APIENTRY log`$2'(`$3') {
|
||||
dnl }')
|
||||
dnl forloop(`i', gl_start, gl_end, `log_func(indir(`f'i`_ret'), indir(`f'i`_name'), indir(`f'i`_params'))
|
||||
dnl ')
|
||||
dnl forloop(`i', glX_start, glX_end, `log_func(indir(`f'i`_ret'), indir(`f'i`_name'), indir(`f'i`_params'))
|
||||
dnl ')
|
||||
|
||||
/*
|
||||
======================
|
||||
GLimp_BindLogging
|
||||
======================
|
||||
*/
|
||||
void GLimp_BindLogging() {
|
||||
define(`assign_funcptr', `qgl`$1' = log`$1';')
|
||||
forloop(`i', gl_start, gl_end, `assign_funcptr(indir(`f'i`_name'))
|
||||
')
|
||||
|
||||
define(`assign_funcptr', `qglX`$1' = log`$1';')
|
||||
forloop(`i', glX_start, glX_end, `assign_funcptr(indir(`f'i`_name'))
|
||||
')
|
||||
}
|
||||
|
||||
/*
|
||||
======================
|
||||
GLimp_EnableLogging
|
||||
======================
|
||||
*/
|
||||
void GLimp_EnableLogging(bool enable) {
|
||||
static bool isEnabled = false;
|
||||
static idStr ospath;
|
||||
static int initialFrames;
|
||||
|
||||
// return if we're already active
|
||||
if ( isEnabled && enable ) {
|
||||
// decrement log counter and stop if it has reached 0
|
||||
r_logFile.SetInteger( r_logFile.GetInteger() - 1 );
|
||||
if ( r_logFile.GetInteger() ) {
|
||||
return;
|
||||
}
|
||||
#if ID_LOG_TO_STDOUT
|
||||
common->Printf( "end stdout GL loggging after %i frames.\n", initialFrames );
|
||||
#else
|
||||
common->Printf( "closing GL logfile '%s' after %i frames.\n", ospath.c_str(), initialFrames );
|
||||
|
||||
fclose( tr.logFile );
|
||||
#endif
|
||||
enable = false;
|
||||
tr.logFile = NULL;
|
||||
}
|
||||
|
||||
// return if we're already disabled
|
||||
if ( !enable && !isEnabled ) {
|
||||
return;
|
||||
}
|
||||
|
||||
isEnabled = enable;
|
||||
|
||||
if ( enable ) {
|
||||
if ( !tr.logFile ) {
|
||||
struct tm *newtime;
|
||||
time_t aclock;
|
||||
idStr qpath;
|
||||
int i;
|
||||
|
||||
initialFrames = r_logFile.GetInteger();
|
||||
|
||||
#if ID_LOG_TO_STDOUT
|
||||
tr.logFile = fdopen( STDOUT_FILENO, "w" );
|
||||
#else
|
||||
// scan for an unused filename
|
||||
for ( i = 0 ; i < 9999 ; i++ ) {
|
||||
sprintf( qpath, "renderlog_%i.txt", i );
|
||||
if ( fileSystem->ReadFile( qpath, NULL, NULL ) == -1 ) {
|
||||
break; // use this name
|
||||
}
|
||||
}
|
||||
|
||||
ospath = fileSystem->RelativePathToOSPath( qpath );
|
||||
tr.logFile = fopen( ospath, "wt" );
|
||||
#endif
|
||||
|
||||
// write the time out to the top of the file
|
||||
time( &aclock );
|
||||
newtime = localtime( &aclock );
|
||||
fprintf( tr.logFile, "// %s", asctime( newtime ) );
|
||||
fprintf( tr.logFile, "// %s\n\n", com_version.GetString() );
|
||||
}
|
||||
|
||||
GLimp_BindLogging();
|
||||
} else {
|
||||
|
||||
GLimp_BindNative();
|
||||
}
|
||||
}
|
||||
|
|
@ -1,66 +0,0 @@
|
|||
// glimp_stub.cpp.m4
|
||||
// stub gl/glX APIs
|
||||
|
||||
#include "idlib/precompiled.h"
|
||||
#include "renderer/tr_local.h"
|
||||
#pragma hdrstop
|
||||
|
||||
dnl =====================================================
|
||||
dnl utils
|
||||
dnl =====================================================
|
||||
|
||||
define(`forloop',
|
||||
`pushdef(`$1', `$2')_forloop(`$1', `$2', `$3', `$4')popdef(`$1')')
|
||||
define(`_forloop',
|
||||
`$4`'ifelse($1, `$3', ,
|
||||
`define(`$1', incr($1))_forloop(`$1', `$2', `$3', `$4')')')
|
||||
|
||||
dnl =====================================================
|
||||
dnl the gl wgl glX definitions
|
||||
dnl =====================================================
|
||||
include(../gllog/gl_def.m4)
|
||||
|
||||
dnl =====================================================
|
||||
dnl qgl stubs
|
||||
dnl there is a number of functions for which we have special case code
|
||||
dnl =====================================================
|
||||
|
||||
define(`override_GetError', `')
|
||||
define(`override_GenLists', `')
|
||||
define(`override_GetIntegerv', `')
|
||||
define(`override_GetString', `')
|
||||
|
||||
define(`instance_funcptr', ``$1' gl`$2'(`$3'){}')
|
||||
define(`try_instance_funcptr', `ifdef(`override_'$2, ,`instance_funcptr(`$1', `$2', `$3')')')
|
||||
forloop(`i', gl_start, gl_end, `try_instance_funcptr(indir(`f'i`_ret'), indir(`f'i`_name'), indir(`f'i`_params'))
|
||||
')
|
||||
|
||||
dnl =====================================================
|
||||
dnl glX stubs
|
||||
dnl =====================================================
|
||||
|
||||
define(`override_GetProcAddressARB', `')
|
||||
|
||||
define(`instance_funcptr', ``$1' glX`$2'(`$3'){}')
|
||||
define(`try_instance_funcptr', `ifdef(`override_'$2, ,`instance_funcptr(`$1', `$2', `$3')')')
|
||||
forloop(`i', glX_start, glX_end, `try_instance_funcptr(indir(`f'i`_ret'), indir(`f'i`_name'), indir(`f'i`_params'))
|
||||
')
|
||||
|
||||
GLenum glGetError(void){return 0;}
|
||||
|
||||
GLuint glGenLists(GLsizei range){return 0;}
|
||||
|
||||
void glGetIntegerv(GLenum pname, GLint *params){
|
||||
switch( pname ) {
|
||||
case GL_MAX_TEXTURE_SIZE: *params = 1024; break;
|
||||
case GL_MAX_TEXTURE_UNITS_ARB: *params = 2; break;
|
||||
default: *params = 0; break;
|
||||
}
|
||||
}
|
||||
|
||||
const GLubyte * glGetString(GLenum name){
|
||||
switch( name ) {
|
||||
case GL_EXTENSIONS: return (GLubyte *)"GL_ARB_multitexture GL_ARB_texture_env_combine GL_ARB_texture_cube_map GL_ARB_texture_env_dot3";
|
||||
}
|
||||
return (const GLubyte *)"";
|
||||
}
|
||||
|
|
@ -52,12 +52,4 @@ void Sys_XUninstallGrabs();
|
|||
#define MOUSE_MASK (ButtonPressMask | ButtonReleaseMask | PointerMotionMask | ButtonMotionMask )
|
||||
#define X_MASK (KEY_MASK | MOUSE_MASK | VisibilityChangeMask | StructureNotifyMask )
|
||||
|
||||
#ifndef ID_GL_HARDLINK
|
||||
bool GLimp_dlopen();
|
||||
void GLimp_dlclose();
|
||||
|
||||
void GLimp_BindLogging();
|
||||
void GLimp_BindNative();
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,41 +0,0 @@
|
|||
#!/usr/bin/env python
|
||||
# process stdin into an M4 macro definition file
|
||||
# recognize three keyword qgl qwgl qglX
|
||||
#
|
||||
# output
|
||||
# global macros keep track of the three intervals for function types:
|
||||
# gl_start gl_end wgl_start wgl_end glX_start glX_end
|
||||
# NOTE: will we need similar thing for extensions?
|
||||
#
|
||||
# each function:
|
||||
# f<id>_ret: return type
|
||||
# f<id>_name: function name
|
||||
# f<id>_params: complete params
|
||||
#
|
||||
# ex:
|
||||
# define(`f1_ret', `void')
|
||||
# define(`f1_name', `Accum')
|
||||
# define(`f1_params', ``GLenum op, GLfloat value'')
|
||||
#
|
||||
|
||||
import sys, string
|
||||
from read import read_gl
|
||||
|
||||
(gl, wgl, glX) = read_gl(sys.stdin)
|
||||
|
||||
sys.stdout.write('define(`gl_start\', `0\')\n')
|
||||
sys.stdout.write('define(`gl_end\', `%d\')\n' % int(len(gl)-1))
|
||||
sys.stdout.write('define(`wgl_start\', `%d\')\n' % int(len(gl)))
|
||||
sys.stdout.write('define(`wgl_end\', `%d\')\n' % int(len(gl)+len(wgl)-1))
|
||||
sys.stdout.write('define(`glX_start\', `%d\')\n' % int(len(gl)+len(wgl)))
|
||||
sys.stdout.write('define(`glX_end\', `%d\')\n' % int(len(gl)+len(wgl)+len(glX)-1))
|
||||
|
||||
i = 0
|
||||
for l in (gl, wgl, glX):
|
||||
for t in l:
|
||||
# process ret type to strip trailing spaces
|
||||
t[0] = string.strip(t[0])
|
||||
sys.stdout.write('define(`f%d_ret\', `%s\')\n' % (i, t[0]))
|
||||
sys.stdout.write('define(`f%d_name\', `%s\')\n' % (i, t[2]))
|
||||
sys.stdout.write('define(`f%d_params\', ``%s\'\')\n' % (i, t[3]))
|
||||
i += 1
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,23 +0,0 @@
|
|||
dnl =====================================================
|
||||
dnl utils
|
||||
dnl =====================================================
|
||||
|
||||
define(`forloop',
|
||||
`pushdef(`$1', `$2')_forloop(`$1', `$2', `$3', `$4')popdef(`$1')')
|
||||
define(`_forloop',
|
||||
`$4`'ifelse($1, `$3', ,
|
||||
`define(`$1', incr($1))_forloop(`$1', `$2', `$3', `$4')')')
|
||||
|
||||
dnl =====================================================
|
||||
dnl the gl wgl glX definitions
|
||||
dnl =====================================================
|
||||
include(../gllog/gl_def.m4)
|
||||
|
||||
dnl =====================================================
|
||||
dnl issue the defines to lock out gl usage
|
||||
dnl =====================================================
|
||||
define(`define_out', `#define gl$1 use_qgl$1')
|
||||
forloop(`i', gl_start, gl_end, `define_out(indir(`f'i`_name'))
|
||||
')
|
||||
forloop(`i', glX_start, glX_end, `define_out(indir(`f'i`_name'))
|
||||
')
|
||||
|
|
@ -210,7 +210,9 @@ if ( local_dedicated == 0 ):
|
|||
linux/input.cpp \
|
||||
linux/libXNVCtrl/NVCtrl.c'
|
||||
else:
|
||||
sys_string += ' linux/dedicated.cpp'
|
||||
sys_string += ' \
|
||||
stub/stub_gl.cpp \
|
||||
linux/dedicated.cpp'
|
||||
|
||||
sys_list = scons_utils.BuildList( 'sys', sys_string )
|
||||
|
||||
|
|
@ -229,7 +231,7 @@ for i in range( len( core_list ) ):
|
|||
local_env = g_env.Clone()
|
||||
|
||||
if ( local_dedicated == 1 ):
|
||||
local_env.Append( CPPDEFINES = [ 'ID_DEDICATED', 'ID_GL_HARDLINK' ] )
|
||||
local_env.Append( CPPDEFINES = [ 'ID_DEDICATED' ] )
|
||||
# don't enable alsa for a dedicated server binary
|
||||
ALSA = '0'
|
||||
|
||||
|
|
@ -255,6 +257,9 @@ sound_lib = sound_env.StaticLibrary( 'sound', sound_list )
|
|||
|
||||
local_env.Append( LIBS = [ 'pthread', 'jpeg', 'vorbisfile' ] )
|
||||
|
||||
if ( local_dedicated == 0 ):
|
||||
local_env.Append( LIBS = [ 'GL' ] )
|
||||
|
||||
if (g_os == "Linux"):
|
||||
local_env.Append( LIBS = [ 'dl' ] )
|
||||
|
||||
|
|
@ -267,7 +272,6 @@ if ( local_dedicated == 0 ):
|
|||
|
||||
source_list = core_list
|
||||
source_list += idlib_objects
|
||||
source_list += [ '../../glimp/sys/scons/libglimp.a' ]
|
||||
source_list += sound_lib
|
||||
source_list += [ '../../openal/stubs.cpp' ]
|
||||
|
||||
|
|
|
|||
|
|
@ -1,101 +0,0 @@
|
|||
# -*- mode: python -*-
|
||||
# DOOM build script
|
||||
# TTimo <ttimo@idsoftware.com>
|
||||
# http://scons.sourceforge.net
|
||||
|
||||
# various GL-related code:
|
||||
# GL logging functions (used on all platforms)
|
||||
# GLimp code (Linux only)
|
||||
# The C code is generated using M4 macros from a description of the GL API
|
||||
# on win32, the logging functions are generated ones and kept in the source
|
||||
# on other platforms, scons generates on the fly at build time
|
||||
|
||||
import time
|
||||
Import('GLOBALS')
|
||||
Import(GLOBALS)
|
||||
|
||||
# NOTE: make sure the .api files are in LF line endings, CRLF isn't working so well
|
||||
def build_logfuncs(env, target, source):
|
||||
import os, sys
|
||||
# search for the module - source repository might make things harder
|
||||
gllog_path = 'sys/gllog'
|
||||
if ( not os.path.exists( gllog_path + '/logfunc.py' ) ):
|
||||
gllog_path = '/var/local/Doom/neo/sys/gllog'
|
||||
sys.path.append( gllog_path )
|
||||
from logfunc import do_logfunc
|
||||
f_out = open('%s' % target[0], 'w')
|
||||
f_out.write('// generated file, do not modify!\n')
|
||||
f_out.write('// ' + time.asctime() + '\n')
|
||||
f_out.write('// see SConscript.gl and sys/gllog/\n\n')
|
||||
|
||||
f_in = open( gllog_path + '/gl.api', 'r')
|
||||
do_logfunc(f_in, f_out)
|
||||
f_in.close()
|
||||
|
||||
f_out.write('\n#ifdef __linux__\n\n')
|
||||
f_in = open( gllog_path + '/glX.api', 'r')
|
||||
do_logfunc(f_in, f_out)
|
||||
f_in.close()
|
||||
f_out.write('\n#endif\n\n')
|
||||
|
||||
f_out.write('\n#ifdef WIN32\n\n')
|
||||
f_in = open( gllog_path + '/wgl.api', 'r')
|
||||
do_logfunc(f_in, f_out)
|
||||
f_in.close()
|
||||
f_out.write('\n#endif\n\n')
|
||||
|
||||
f_out.close()
|
||||
|
||||
print 'Generated %s' % target[0]
|
||||
|
||||
gl_env = g_env.Clone()
|
||||
gl_env.Append( CPPPATH = '#' )
|
||||
gl_env.Append( CPPFLAGS = '-DGLIMP' )
|
||||
|
||||
if ( local_dedicated == 1 ):
|
||||
gl_env.Append( CPPFLAGS = '-DID_DEDICATED' )
|
||||
|
||||
# general M4 builder setup
|
||||
# files we are going to generate from their M4 counterparts
|
||||
|
||||
m4_list = (
|
||||
'../gllog/gl_extensions.cpp',
|
||||
'../linux/glimp_dlopen.cpp',
|
||||
'../linux/glimp_logging.cpp',
|
||||
'../linux/glimp_stub.cpp',
|
||||
'../linux/glimp_local.h' )
|
||||
|
||||
for i_m4 in m4_list:
|
||||
gl_env.M4( i_m4, i_m4 + '.m4' )
|
||||
gl_env.Depends( i_m4, '../gllog/gl_def.m4' )
|
||||
|
||||
# enable if you need to generate again
|
||||
# FIXME: conflicts when several environements are used. move that to seperate script
|
||||
#enforce = gl_env.M4( '#sys/linux/qgl_enforce.h', '../linux/qgl_enforce.h.m4' )
|
||||
#gl_env.Depends( enforce, '../gllog/gl_def.m4' )
|
||||
|
||||
# logging functions, python generated ( that's beyond my m4-fu )
|
||||
|
||||
gl_env.Depends( '../linux/glimp_logging.cpp', '../linux/glimp_logfuncs.cpp' )
|
||||
|
||||
logfuncs = gl_env.Command( '../linux/glimp_logfuncs.cpp', '../gllog/logfunc.py', build_logfuncs )
|
||||
gl_env.Depends( logfuncs, '../gllog/gl_def.m4' )
|
||||
|
||||
sources = []
|
||||
sources.append( '../gllog/gl_extensions.cpp' )
|
||||
|
||||
if ( local_dedicated == 1 ):
|
||||
sources.append( '../linux/glimp_stub.cpp' )
|
||||
else:
|
||||
sources.append( '../linux/glimp_dlopen.cpp' )
|
||||
sources.append( '../linux/glimp_logging.cpp' )
|
||||
|
||||
#if ( DEDICATED != '0' ):
|
||||
# sources.append( '../linux/glimp_stub.cpp' )
|
||||
#
|
||||
#if ( GL_HARDLINK == '0' ):
|
||||
# sources.append( '../linux/glimp_dlopen.cpp' )
|
||||
# sources.append( '../linux/glimp_logging.cpp' )
|
||||
|
||||
lib = gl_env.StaticLibrary( 'glimp', sources )
|
||||
#gl_env.Install( '../..', lib )
|
||||
Loading…
Reference in a new issue