FWGS
/
Paranoia2
forked from a1batross/Paranoia2_original
2
0
Fork 2
Code Issues Pull Requests 1 Releases Wiki Activity
Paranoia2/cl_dll/render/gl_export.cpp

1029 lines
36 KiB
C++
Raw Blame History

/*
gl_export.cpp - OpenGL dynamically linkage
Copyright (C) 2010 Uncle Mike
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
*/
#define APIENTRY_LINKAGE
#include "hud.h"
#include "cl_util.h"
#include "gl_local.h"
#include <stringlib.h>
#include "gl_world.h"
#include "gl_decals.h"
#include "gl_studio.h"
#include "gl_grass.h"
#include "material.h"
#include "gl_occlusion.h"
#define MAX_RESERVED_UNIFORMS 22 // while MAX_LIGHTSTYLES 64
#define PROJ_SIZE 64
glState_t glState;
glConfig_t glConfig;
static dllfunc_t opengl_110funcs[] =
{
{ "glClearColor" , (void **)&pglClearColor },
{ "glClear" , (void **)&pglClear },
{ "glAlphaFunc" , (void **)&pglAlphaFunc },
{ "glBlendFunc" , (void **)&pglBlendFunc },
{ "glCullFace" , (void **)&pglCullFace },
{ "glDrawBuffer" , (void **)&pglDrawBuffer },
{ "glReadBuffer" , (void **)&pglReadBuffer },
{ "glAccum" , (void **)&pglAccum },
{ "glEnable" , (void **)&pglEnable },
{ "glDisable" , (void **)&pglDisable },
{ "glEnableClientState" , (void **)&pglEnableClientState },
{ "glDisableClientState" , (void **)&pglDisableClientState },
{ "glGetBooleanv" , (void **)&pglGetBooleanv },
{ "glGetDoublev" , (void **)&pglGetDoublev },
{ "glGetFloatv" , (void **)&pglGetFloatv },
{ "glGetIntegerv" , (void **)&pglGetIntegerv },
{ "glGetError" , (void **)&pglGetError },
{ "glGetString" , (void **)&pglGetString },
{ "glFinish" , (void **)&pglFinish },
{ "glFlush" , (void **)&pglFlush },
{ "glClearDepth" , (void **)&pglClearDepth },
{ "glDepthFunc" , (void **)&pglDepthFunc },
{ "glDepthMask" , (void **)&pglDepthMask },
{ "glDepthRange" , (void **)&pglDepthRange },
{ "glFrontFace" , (void **)&pglFrontFace },
{ "glDrawElements" , (void **)&pglDrawElements },
{ "glDrawArrays" , (void **)&pglDrawArrays },
{ "glColorMask" , (void **)&pglColorMask },
{ "glIndexPointer" , (void **)&pglIndexPointer },
{ "glVertexPointer" , (void **)&pglVertexPointer },
{ "glNormalPointer" , (void **)&pglNormalPointer },
{ "glColorPointer" , (void **)&pglColorPointer },
{ "glTexCoordPointer" , (void **)&pglTexCoordPointer },
{ "glArrayElement" , (void **)&pglArrayElement },
{ "glColor3f" , (void **)&pglColor3f },
{ "glColor3fv" , (void **)&pglColor3fv },
{ "glColor4f" , (void **)&pglColor4f },
{ "glColor4fv" , (void **)&pglColor4fv },
{ "glColor3ub" , (void **)&pglColor3ub },
{ "glColor4ub" , (void **)&pglColor4ub },
{ "glColor4ubv" , (void **)&pglColor4ubv },
{ "glTexCoord1f" , (void **)&pglTexCoord1f },
{ "glTexCoord2f" , (void **)&pglTexCoord2f },
{ "glTexCoord3f" , (void **)&pglTexCoord3f },
{ "glTexCoord4f" , (void **)&pglTexCoord4f },
{ "glTexCoord1fv" , (void **)&pglTexCoord1fv },
{ "glTexCoord2fv" , (void **)&pglTexCoord2fv },
{ "glTexCoord3fv" , (void **)&pglTexCoord3fv },
{ "glTexCoord4fv" , (void **)&pglTexCoord4fv },
{ "glTexGenf" , (void **)&pglTexGenf },
{ "glTexGenfv" , (void **)&pglTexGenfv },
{ "glTexGeni" , (void **)&pglTexGeni },
{ "glVertex2f" , (void **)&pglVertex2f },
{ "glVertex3f" , (void **)&pglVertex3f },
{ "glVertex3fv" , (void **)&pglVertex3fv },
{ "glNormal3f" , (void **)&pglNormal3f },
{ "glNormal3fv" , (void **)&pglNormal3fv },
{ "glBegin" , (void **)&pglBegin },
{ "glEnd" , (void **)&pglEnd },
{ "glLineWidth" , (void**)&pglLineWidth },
{ "glPointSize" , (void**)&pglPointSize },
{ "glMatrixMode" , (void **)&pglMatrixMode },
{ "glOrtho" , (void **)&pglOrtho },
{ "glRasterPos2f" , (void **) &pglRasterPos2f },
{ "glFrustum" , (void **)&pglFrustum },
{ "glViewport" , (void **)&pglViewport },
{ "glPushMatrix" , (void **)&pglPushMatrix },
{ "glPopMatrix" , (void **)&pglPopMatrix },
{ "glPushAttrib" , (void **)&pglPushAttrib },
{ "glPopAttrib" , (void **)&pglPopAttrib },
{ "glLoadIdentity" , (void **)&pglLoadIdentity },
{ "glLoadMatrixd" , (void **)&pglLoadMatrixd },
{ "glLoadMatrixf" , (void **)&pglLoadMatrixf },
{ "glMultMatrixd" , (void **)&pglMultMatrixd },
{ "glMultMatrixf" , (void **)&pglMultMatrixf },
{ "glRotated" , (void **)&pglRotated },
{ "glRotatef" , (void **)&pglRotatef },
{ "glScaled" , (void **)&pglScaled },
{ "glScalef" , (void **)&pglScalef },
{ "glTranslated" , (void **)&pglTranslated },
{ "glTranslatef" , (void **)&pglTranslatef },
{ "glReadPixels" , (void **)&pglReadPixels },
{ "glDrawPixels" , (void **)&pglDrawPixels },
{ "glStencilFunc" , (void **)&pglStencilFunc },
{ "glStencilMask" , (void **)&pglStencilMask },
{ "glStencilOp" , (void **)&pglStencilOp },
{ "glClearStencil" , (void **)&pglClearStencil },
{ "glIsEnabled" , (void **)&pglIsEnabled },
{ "glIsList" , (void **)&pglIsList },
{ "glIsTexture" , (void **)&pglIsTexture },
{ "glTexEnvf" , (void **)&pglTexEnvf },
{ "glTexEnvfv" , (void **)&pglTexEnvfv },
{ "glTexEnvi" , (void **)&pglTexEnvi },
{ "glTexParameterf" , (void **)&pglTexParameterf },
{ "glTexParameterfv" , (void **)&pglTexParameterfv },
{ "glTexParameteri" , (void **)&pglTexParameteri },
{ "glHint" , (void **)&pglHint },
{ "glPixelStoref" , (void **)&pglPixelStoref },
{ "glPixelStorei" , (void **)&pglPixelStorei },
{ "glGenTextures" , (void **)&pglGenTextures },
{ "glDeleteTextures" , (void **)&pglDeleteTextures },
{ "glBindTexture" , (void **)&pglBindTexture },
{ "glTexImage1D" , (void **)&pglTexImage1D },
{ "glTexImage2D" , (void **)&pglTexImage2D },
{ "glTexSubImage1D" , (void **)&pglTexSubImage1D },
{ "glTexSubImage2D" , (void **)&pglTexSubImage2D },
{ "glCopyTexImage1D" , (void **)&pglCopyTexImage1D },
{ "glCopyTexImage2D" , (void **)&pglCopyTexImage2D },
{ "glCopyTexSubImage1D" , (void **)&pglCopyTexSubImage1D },
{ "glCopyTexSubImage2D" , (void **)&pglCopyTexSubImage2D },
{ "glScissor" , (void **)&pglScissor },
{ "glGetTexImage" , (void **)&pglGetTexImage },
{ "glGetTexEnviv" , (void **)&pglGetTexEnviv },
{ "glPolygonOffset" , (void **)&pglPolygonOffset },
{ "glPolygonMode" , (void **)&pglPolygonMode },
{ "glPolygonStipple" , (void **)&pglPolygonStipple },
{ "glClipPlane" , (void **)&pglClipPlane },
{ "glGetClipPlane" , (void **)&pglGetClipPlane },
{ "glShadeModel" , (void **)&pglShadeModel },
{ "glGetTexLevelParameteriv" , (void **)&pglGetTexLevelParameteriv },
{ "glGetTexLevelParameterfv" , (void **)&pglGetTexLevelParameterfv },
{ "glFogfv" , (void **)&pglFogfv },
{ "glFogf" , (void **)&pglFogf },
{ "glFogi" , (void **)&pglFogi },
{ NULL, NULL }
};
static dllfunc_t drawrangeelementsfuncs[] =
{
{ "glDrawRangeElements" , (void **)&pglDrawRangeElements },
{ NULL, NULL }
};
static dllfunc_t drawrangeelementsextfuncs[] =
{
{ "glDrawRangeElementsEXT" , (void **)&pglDrawRangeElementsEXT },
{ NULL, NULL }
};
static dllfunc_t debugoutputfuncs[] =
{
{ "glDebugMessageControlARB" , (void **)&pglDebugMessageControlARB },
{ "glDebugMessageInsertARB" , (void **)&pglDebugMessageInsertARB },
{ "glDebugMessageCallbackARB" , (void **)&pglDebugMessageCallbackARB },
{ "glGetDebugMessageLogARB" , (void **)&pglGetDebugMessageLogARB },
{ NULL, NULL }
};
static dllfunc_t multitexturefuncs[] =
{
{ "glMultiTexCoord1fARB" , (void **)&pglMultiTexCoord1f },
{ "glMultiTexCoord2fARB" , (void **)&pglMultiTexCoord2f },
{ "glMultiTexCoord3fARB" , (void **)&pglMultiTexCoord3f },
{ "glMultiTexCoord4fARB" , (void **)&pglMultiTexCoord4f },
{ "glActiveTextureARB" , (void **)&pglActiveTexture },
{ "glActiveTextureARB" , (void **)&pglActiveTextureARB },
{ "glClientActiveTextureARB" , (void **)&pglClientActiveTexture },
{ "glClientActiveTextureARB" , (void **)&pglClientActiveTextureARB },
{ NULL, NULL }
};
static dllfunc_t texture3dextfuncs[] =
{
{ "glTexImage3DEXT" , (void **)&pglTexImage3D },
{ "glTexSubImage3DEXT" , (void **)&pglTexSubImage3D },
{ "glCopyTexSubImage3DEXT" , (void **)&pglCopyTexSubImage3D },
{ NULL, NULL }
};
static dllfunc_t blendseparatefunc[] =
{
{ "glBlendFuncSeparateEXT", (void **)&pglBlendFuncSeparate },
{ NULL, NULL }
};
static dllfunc_t shaderobjectsfuncs[] =
{
{ "glDeleteObjectARB" , (void **)&pglDeleteObjectARB },
{ "glGetHandleARB" , (void **)&pglGetHandleARB },
{ "glDetachObjectARB" , (void **)&pglDetachObjectARB },
{ "glCreateShaderObjectARB" , (void **)&pglCreateShaderObjectARB },
{ "glShaderSourceARB" , (void **)&pglShaderSourceARB },
{ "glCompileShaderARB" , (void **)&pglCompileShaderARB },
{ "glCreateProgramObjectARB" , (void **)&pglCreateProgramObjectARB },
{ "glAttachObjectARB" , (void **)&pglAttachObjectARB },
{ "glLinkProgramARB" , (void **)&pglLinkProgramARB },
{ "glUseProgramObjectARB" , (void **)&pglUseProgramObjectARB },
{ "glValidateProgramARB" , (void **)&pglValidateProgramARB },
{ "glUniform1fARB" , (void **)&pglUniform1fARB },
{ "glUniform2fARB" , (void **)&pglUniform2fARB },
{ "glUniform3fARB" , (void **)&pglUniform3fARB },
{ "glUniform4fARB" , (void **)&pglUniform4fARB },
{ "glUniform1iARB" , (void **)&pglUniform1iARB },
{ "glUniform2iARB" , (void **)&pglUniform2iARB },
{ "glUniform3iARB" , (void **)&pglUniform3iARB },
{ "glUniform4iARB" , (void **)&pglUniform4iARB },
{ "glUniform1fvARB" , (void **)&pglUniform1fvARB },
{ "glUniform2fvARB" , (void **)&pglUniform2fvARB },
{ "glUniform3fvARB" , (void **)&pglUniform3fvARB },
{ "glUniform4fvARB" , (void **)&pglUniform4fvARB },
{ "glUniform1ivARB" , (void **)&pglUniform1ivARB },
{ "glUniform2ivARB" , (void **)&pglUniform2ivARB },
{ "glUniform3ivARB" , (void **)&pglUniform3ivARB },
{ "glUniform4ivARB" , (void **)&pglUniform4ivARB },
{ "glUniformMatrix2fvARB" , (void **)&pglUniformMatrix2fvARB },
{ "glUniformMatrix3fvARB" , (void **)&pglUniformMatrix3fvARB },
{ "glUniformMatrix4fvARB" , (void **)&pglUniformMatrix4fvARB },
{ "glGetObjectParameterfvARB" , (void **)&pglGetObjectParameterfvARB },
{ "glGetObjectParameterivARB" , (void **)&pglGetObjectParameterivARB },
{ "glGetInfoLogARB" , (void **)&pglGetInfoLogARB },
{ "glGetAttachedObjectsARB" , (void **)&pglGetAttachedObjectsARB },
{ "glGetUniformLocationARB" , (void **)&pglGetUniformLocationARB },
{ "glGetActiveUniformARB" , (void **)&pglGetActiveUniformARB },
{ "glGetUniformfvARB" , (void **)&pglGetUniformfvARB },
{ "glGetUniformivARB" , (void **)&pglGetUniformivARB },
{ "glGetShaderSourceARB" , (void **)&pglGetShaderSourceARB },
{ "glVertexAttribPointerARB" , (void **)&pglVertexAttribPointerARB },
{ "glEnableVertexAttribArrayARB" , (void **)&pglEnableVertexAttribArrayARB },
{ "glDisableVertexAttribArrayARB" , (void **)&pglDisableVertexAttribArrayARB },
{ "glBindAttribLocationARB" , (void **)&pglBindAttribLocationARB },
{ "glGetActiveAttribARB" , (void **)&pglGetActiveAttribARB },
{ "glGetAttribLocationARB" , (void **)&pglGetAttribLocationARB },
{ "glVertexAttrib2f" , (void **)&pglVertexAttrib2fARB },
{ "glVertexAttrib2fv" , (void **)&pglVertexAttrib2fvARB },
{ "glVertexAttrib3fv" , (void **)&pglVertexAttrib3fvARB },
{ "glVertexAttrib4fv" , (void **)&pglVertexAttrib4fvARB },
{ "glVertexAttrib4ubv" , (void **)&pglVertexAttrib4ubvARB },
{ NULL, NULL }
};
static dllfunc_t vertexshaderfuncs[] =
{
{ "glVertexAttribPointerARB" , (void **)&pglVertexAttribPointerARB },
{ "glEnableVertexAttribArrayARB" , (void **)&pglEnableVertexAttribArrayARB },
{ "glDisableVertexAttribArrayARB" , (void **)&pglDisableVertexAttribArrayARB },
{ "glBindAttribLocationARB" , (void **)&pglBindAttribLocationARB },
{ "glGetActiveAttribARB" , (void **)&pglGetActiveAttribARB },
{ "glGetAttribLocationARB" , (void **)&pglGetAttribLocationARB },
{ NULL, NULL }
};
static dllfunc_t binaryshaderfuncs[] =
{
{ "glProgramBinary" , (void **)&pglProgramBinary },
{ "glGetProgramBinary" , (void **)&pglGetProgramBinary },
{ "glProgramParameteri" , (void **)&pglProgramParameteri },
{ "glGetProgramiv" , (void **)&pglGetProgramivARB },
{ NULL, NULL }
};
static dllfunc_t vbofuncs[] =
{
{ "glBindBufferARB" , (void **)&pglBindBufferARB },
{ "glDeleteBuffersARB" , (void **)&pglDeleteBuffersARB },
{ "glGenBuffersARB" , (void **)&pglGenBuffersARB },
{ "glIsBufferARB" , (void **)&pglIsBufferARB },
{ "glMapBufferARB" , (void **)&pglMapBufferARB },
{ "glUnmapBufferARB" , (void **)&pglUnmapBufferARB },
{ "glBufferDataARB" , (void **)&pglBufferDataARB },
{ "glBufferSubDataARB" , (void **)&pglBufferSubDataARB },
{ NULL, NULL }
};
static dllfunc_t vaofuncs[] =
{
{ "glBindVertexArray" , (void **)&pglBindVertexArray },
{ "glDeleteVertexArrays" , (void **)&pglDeleteVertexArrays },
{ "glGenVertexArrays" , (void **)&pglGenVertexArrays },
{ "glIsVertexArray" , (void **)&pglIsVertexArray },
{ NULL, NULL }
};
static dllfunc_t fbofuncs[] =
{
{ "glIsRenderbuffer" , (void **)&pglIsRenderbuffer },
{ "glBindRenderbuffer" , (void **)&pglBindRenderbuffer },
{ "glDeleteRenderbuffers" , (void **)&pglDeleteRenderbuffers },
{ "glGenRenderbuffers" , (void **)&pglGenRenderbuffers },
{ "glRenderbufferStorage" , (void **)&pglRenderbufferStorage },
{ "glGetRenderbufferParameteriv" , (void **)&pglGetRenderbufferParameteriv },
{ "glIsFramebuffer" , (void **)&pglIsFramebuffer },
{ "glBindFramebuffer" , (void **)&pglBindFramebuffer },
{ "glDeleteFramebuffers" , (void **)&pglDeleteFramebuffers },
{ "glGenFramebuffers" , (void **)&pglGenFramebuffers },
{ "glCheckFramebufferStatus" , (void **)&pglCheckFramebufferStatus },
{ "glFramebufferTexture1D" , (void **)&pglFramebufferTexture1D },
{ "glFramebufferTexture2D" , (void **)&pglFramebufferTexture2D },
{ "glFramebufferTexture3D" , (void **)&pglFramebufferTexture3D },
{ "glFramebufferRenderbuffer" , (void **)&pglFramebufferRenderbuffer },
{ "glGetFramebufferAttachmentParameteriv" , (void **)&pglGetFramebufferAttachmentParameteriv },
{ "glGenerateMipmap" , (void **)&pglGenerateMipmap },
{ "glColorMaski" , (void **)&pglColorMaski },
{ NULL, NULL}
};
static dllfunc_t occlusionfunc[] =
{
{ "glGenQueriesARB" , (void **)&pglGenQueriesARB },
{ "glDeleteQueriesARB" , (void **)&pglDeleteQueriesARB },
{ "glIsQueryARB" , (void **)&pglIsQueryARB },
{ "glBeginQueryARB" , (void **)&pglBeginQueryARB },
{ "glEndQueryARB" , (void **)&pglEndQueryARB },
{ "glGetQueryivARB" , (void **)&pglGetQueryivARB },
{ "glGetQueryObjectivARB" , (void **)&pglGetQueryObjectivARB },
{ "glGetQueryObjectuivARB" , (void **)&pglGetQueryObjectuivARB },
{ NULL, NULL }
};
static dllfunc_t drawbuffersfuncs[] =
{
{ "glDrawBuffersARB" , (void **)&pglDrawBuffersARB },
{ NULL, NULL }
};
/*
========================
DebugCallback
For ARB_debug_output
========================
*/
static void APIENTRY GL_DebugOutput( GLuint source, GLuint type, GLuint id, GLuint severity, GLint length, const GLcharARB *message, GLvoid *userParam )
{
static char string[8192];
char *msg;
string[0] = '\0';
switch( type )
{
case GL_DEBUG_TYPE_ERROR_ARB:
string[0] = 3; // no extra refresh
msg = va( "^1OpenGL Error:^7 %s\n", message );
Q_strncat( string, msg, sizeof( string ));
break;
case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB:
string[0] = 3; // no extra refresh
msg = va( "^3OpenGL Warning:^7 %s\n", message );
Q_strncat( string, msg, sizeof( string ));
break;
case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB:
string[0] = 3; // no extra refresh
msg = va( "^3OpenGL Warning:^7 %s\n", message );
Q_strncat( string, msg, sizeof( string ));
break;
case GL_DEBUG_TYPE_PORTABILITY_ARB:
if( developer_level < DEV_EXTENDED )
return;
string[0] = 3; // no extra refresh
msg = va( "^3OpenGL Warning:^7 %s\n", message );
Q_strncat( string, msg, sizeof( string ));
break;
case GL_DEBUG_TYPE_PERFORMANCE_ARB:
if( developer_level < DEV_EXTENDED )
return;
string[0] = 3; // no extra refresh
msg = va( "OpenGL Notify: %s\n", message );
Q_strncat( string, msg, sizeof( string ));
break;
case GL_DEBUG_TYPE_OTHER_ARB:
default:
// ignore spam about detailed infos
if( !Q_strnicmp( message, "Buffer detailed info", 20 ))
return;
if( !Q_strnicmp( message, "Framebuffer detailed info", 25 ))
return;
string[0] = 3; // no extra refresh
msg = va( "OpenGL: %s\n", message );
Q_strncat( string, msg, sizeof( string ));
break;
}
if( !string[0] ) return;
gEngfuncs.Con_Printf( string );
}
/*
=================
GL_SetExtension
=================
*/
void GL_SetExtension( int r_ext, int enable )
{
if( r_ext >= 0 && r_ext < R_EXTCOUNT )
glConfig.extension[r_ext] = enable ? GL_TRUE : GL_FALSE;
else ALERT( at_error, "GL_SetExtension: invalid extension %d\n", r_ext );
}
/*
=================
GL_Support
=================
*/
bool GL_Support( int r_ext )
{
if( r_ext >= 0 && r_ext < R_EXTCOUNT )
return glConfig.extension[r_ext] ? true : false;
ALERT( at_error, "GL_Support: invalid extension %d\n", r_ext );
return false;
}
/*
=================
GL_CheckExtension
=================
*/
void GL_CheckExtension( const char *name, const dllfunc_t *funcs, const char *cvarname, int r_ext, bool cvar_from_engine = false )
{
const dllfunc_t *func;
cvar_t *parm;
ALERT( at_aiconsole, "GL_CheckExtension: %s ", name );
// ugly hack for p1 opengl32.dll
if(( name[0] == 'P' || name[2] == '_' || name[3] == '_' ) && !Q_strstr( glConfig.extensions_string, name ))
{
GL_SetExtension( r_ext, false ); // update render info
ALERT( at_aiconsole, "- ^1failed\n" );
return;
}
if( cvarname )
{
// NOTE: engine will be ignore cvar value if variable already exitsts (e.g. created on exec opengl.cfg)
// so this call just update variable description (because Host_WriteOpenGLConfig won't archive cvars without it)
if( cvar_from_engine ) parm = CVAR_GET_POINTER( cvarname );
else parm = CVAR_REGISTER( (char *)cvarname, "1", FCVAR_GLCONFIG );
if( !CVAR_TO_BOOL( parm ) || ( !CVAR_TO_BOOL( gl_extensions ) && r_ext != R_OPENGL_110 ))
{
ALERT( at_aiconsole, "- disabled\n" );
GL_SetExtension( r_ext, false );
return; // nothing to process at
}
GL_SetExtension( r_ext, true );
}
// clear exports
for( func = funcs; func && func->name; func++ )
*func->func = NULL;
GL_SetExtension( r_ext, true ); // predict extension state
for( func = funcs; func && func->name != NULL; func++ )
{
// functions are cleared before all the extensions are evaluated
if(!(*func->func = (void *)GL_GetProcAddress( func->name )))
GL_SetExtension( r_ext, false ); // one or more functions are invalid, extension will be disabled
}
if( GL_Support( r_ext ))
ALERT( at_aiconsole, "- ^2enabled\n" );
else ALERT( at_aiconsole, "- ^1failed\n" );
}
static void GL_InitExtensions( void )
{
// initialize gl extensions
GL_CheckExtension( "OpenGL 1.1.0", opengl_110funcs, NULL, R_OPENGL_110 );
if( !GL_Support( R_OPENGL_110 ))
{
ALERT( at_error, "OpenGL 1.0 can't be installed. Custom renderer disabled\n" );
g_fRenderInterfaceValid = FALSE;
g_fRenderInitialized = FALSE;
return;
}
// get our various GL strings
glConfig.vendor_string = (const char*)pglGetString( GL_VENDOR );
glConfig.renderer_string = (const char*)pglGetString( GL_RENDERER );
glConfig.version_string = (const char*)pglGetString( GL_VERSION );
glConfig.extensions_string = (const char*)pglGetString( GL_EXTENSIONS );
if( Q_stristr( glConfig.renderer_string, "geforce" ))
glConfig.hardware_type = GLHW_NVIDIA;
else if( Q_stristr( glConfig.renderer_string, "quadro fx" ))
glConfig.hardware_type = GLHW_NVIDIA;
else if( Q_stristr(glConfig.renderer_string, "rv770" ))
glConfig.hardware_type = GLHW_RADEON;
else if( Q_stristr(glConfig.renderer_string, "radeon hd" ))
glConfig.hardware_type = GLHW_RADEON;
else if( Q_stristr( glConfig.renderer_string, "eah4850" ) || Q_stristr( glConfig.renderer_string, "eah4870" ))
glConfig.hardware_type = GLHW_RADEON;
else if( Q_stristr( glConfig.renderer_string, "radeon" ))
glConfig.hardware_type = GLHW_RADEON;
else glConfig.hardware_type = GLHW_GENERIC;
glConfig.version = Q_atof( glConfig.version_string );
Msg( "GL_VERSION: %g\n", glConfig.version );
GL_CheckExtension( "glDrawRangeElements", drawrangeelementsfuncs, "gl_drawrangeelments", R_DRAW_RANGEELEMENTS_EXT );
if( !GL_Support( R_DRAW_RANGEELEMENTS_EXT ))
GL_CheckExtension( "GL_EXT_draw_range_elements", drawrangeelementsextfuncs, "gl_drawrangeelments", R_DRAW_RANGEELEMENTS_EXT );
// we don't care if it's an extension or not, they are identical functions, so keep it simple in the rendering code
if( pglDrawRangeElementsEXT == NULL ) pglDrawRangeElementsEXT = pglDrawRangeElements;
if( !GL_Support( R_DRAW_RANGEELEMENTS_EXT ))
{
ALERT( at_error, "GL_EXT_draw_range_elements not support. Custom renderer disabled\n" );
g_fRenderInitialized = FALSE;
return;
}
// multitexture
glConfig.max_texture_units = 1;
GL_CheckExtension( "GL_ARB_multitexture", multitexturefuncs, "gl_arb_multitexture", R_ARB_MULTITEXTURE, true );
if( GL_Support( R_ARB_MULTITEXTURE ))
pglGetIntegerv( GL_MAX_TEXTURE_UNITS_ARB, &glConfig.max_texture_units );
if( glConfig.max_texture_units == 1 )
GL_SetExtension( R_ARB_MULTITEXTURE, false );
if( !GL_Support( R_ARB_MULTITEXTURE ))
{
ALERT( at_error, "GL_ARB_multitexture not support. Custom renderer disabled\n" );
g_fRenderInitialized = FALSE;
return;
}
// 3d texture support
GL_CheckExtension( "GL_EXT_texture3D", texture3dextfuncs, "gl_texture_3d", R_TEXTURE_3D_EXT, true );
if( GL_Support( R_TEXTURE_3D_EXT ))
{
pglGetIntegerv( GL_MAX_3D_TEXTURE_SIZE, &glConfig.max_3d_texture_size );
if( glConfig.max_3d_texture_size < 32 )
{
GL_SetExtension( R_TEXTURE_3D_EXT, false );
ALERT( at_error, "GL_EXT_texture3D reported bogus GL_MAX_3D_TEXTURE_SIZE, disabled\n" );
}
}
// 2d texture array support
GL_CheckExtension( "GL_EXT_texture_array", texture3dextfuncs, "gl_texture_2d_array", R_TEXTURE_ARRAY_EXT, true );
if( !GL_Support( R_TEXTURE_ARRAY_EXT ))
ALERT( at_warning, "GL_EXT_texture_array not support. Landscapes will be unavailable\n" );
// occlusion queries
GL_CheckExtension( "GL_ARB_occlusion_query", occlusionfunc, "gl_occlusion_queries", R_OCCLUSION_QUERIES_EXT );
// separate blend
GL_CheckExtension( "GL_EXT_blend_func_separate", blendseparatefunc, "gl_separate_blend", R_SEPARATE_BLENDFUNC_EXT );
// hardware cubemaps
GL_CheckExtension( "GL_ARB_texture_cube_map", NULL, "gl_texture_cubemap", R_TEXTURECUBEMAP_EXT, true );
if( GL_Support( R_TEXTURECUBEMAP_EXT ))
pglGetIntegerv( GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, &glConfig.max_cubemap_size );
else ALERT( at_warning, "GL_ARB_texture_cube_map not support. Cubemap reflections and omni shadows will be disabled\n" );
GL_CheckExtension( "GL_ARB_texture_non_power_of_two", NULL, "gl_texture_npot", R_ARB_TEXTURE_NPOT_EXT, true );
GL_CheckExtension( "GL_ARB_draw_buffers", drawbuffersfuncs, "gl_draw_buffers", R_DRAW_BUFFERS_EXT );
GL_CheckExtension( "GL_ARB_vertex_buffer_object", vbofuncs, "gl_vertex_buffer_object", R_ARB_VERTEX_BUFFER_OBJECT_EXT );
if( !GL_Support( R_ARB_VERTEX_BUFFER_OBJECT_EXT ))
{
ALERT( at_error, "GL_ARB_vertex_buffer_object not support. Custom renderer disabled\n" );
g_fRenderInitialized = FALSE;
return;
}
GL_CheckExtension( "GL_ARB_vertex_array_object", vaofuncs, "gl_vertex_array_object", R_ARB_VERTEX_ARRAY_OBJECT_EXT );
if( !GL_Support( R_ARB_VERTEX_ARRAY_OBJECT_EXT ))
{
ALERT( at_error, "GL_ARB_vertex_array_object not support. Custom renderer disabled\n" );
g_fRenderInitialized = FALSE;
return;
}
GL_CheckExtension( "GL_EXT_gpu_shader4", NULL, "gl_ext_gpu_shader4", R_EXT_GPU_SHADER4 );
if( !GL_Support( R_EXT_GPU_SHADER4 ))
ALERT( at_warning, "GL_EXT_gpu_shader4 not support. Shadows from omni lights will be disabled\n" );
GL_CheckExtension( "GL_ARB_debug_output", debugoutputfuncs, "gl_debug_output", R_DEBUG_OUTPUT, true );
// vp and fp shaders
GL_CheckExtension( "GL_ARB_shader_objects", shaderobjectsfuncs, "gl_shaderobjects", R_SHADER_OBJECTS_EXT );
if( !GL_Support( R_SHADER_OBJECTS_EXT ))
{
ALERT( at_error, "GL_ARB_shader_objects not support. Custom renderer disabled\n" );
g_fRenderInitialized = FALSE;
return;
}
GL_CheckExtension( "GL_ARB_shading_language_100", NULL, "gl_shading_language", R_SHADER_GLSL100_EXT );
if( !GL_Support( R_SHADER_GLSL100_EXT ))
{
ALERT( at_error, "GL_ARB_shading_language_100 not support. Custom renderer disabled\n" );
g_fRenderInitialized = FALSE;
return;
}
GL_CheckExtension( "GL_ARB_vertex_shader", vertexshaderfuncs, "gl_vertexshader", R_VERTEX_SHADER_EXT );
if( !GL_Support( R_VERTEX_SHADER_EXT ))
{
ALERT( at_error, "GL_ARB_vertex_shader not support. Custom renderer disabled\n" );
g_fRenderInitialized = FALSE;
return;
}
GL_CheckExtension( "GL_ARB_fragment_shader", NULL, "gl_pixelshader", R_FRAGMENT_SHADER_EXT );
if( !GL_Support( R_FRAGMENT_SHADER_EXT ))
{
ALERT( at_error, "GL_ARB_fragment_shader not support. Custom renderer disabled\n" );
g_fRenderInitialized = FALSE;
return;
}
GL_CheckExtension( "GL_ARB_get_program_binary", binaryshaderfuncs, "gl_binaryshader", R_BINARY_SHADER_EXT );
GL_CheckExtension( "GL_ARB_depth_texture", NULL, "gl_depthtexture", R_DEPTH_TEXTURE );
GL_CheckExtension( "GL_ARB_shadow", NULL, "gl_arb_shadow", R_SHADOW_EXT );
GL_CheckExtension( "GL_ARB_texture_rectangle", NULL, "gl_texture_rectangle", R_TEXTURE_2D_RECT_EXT, true );
if( GL_Support( R_BINARY_SHADER_EXT ))
{
pglGetIntegerv( GL_NUM_PROGRAM_BINARY_FORMATS, &glConfig.num_formats );
pglGetIntegerv( GL_PROGRAM_BINARY_FORMATS, &glConfig.binary_formats );
}
if( !GL_Support( R_DEPTH_TEXTURE ) || !GL_Support( R_SHADOW_EXT ))
{
ALERT( at_warning, "GL_ARB_depth_texture or GL_ARB_shadow not support. Dynamic shadows disabled\n" );
tr.shadows_notsupport = true;
}
glConfig.max_2d_texture_size = 0;
pglGetIntegerv( GL_MAX_TEXTURE_SIZE, &glConfig.max_2d_texture_size );
if( glConfig.max_2d_texture_size <= 0 ) glConfig.max_2d_texture_size = 256;
if( GL_Support( R_TEXTURE_ARRAY_EXT ))
pglGetIntegerv( GL_MAX_ARRAY_TEXTURE_LAYERS_EXT, &glConfig.max_2d_texture_layers );
// FBO support
GL_CheckExtension( "GL_ARB_framebuffer_object", fbofuncs, "gl_framebuffers", R_FRAMEBUFFER_OBJECT );
// Paranoia OpenGL32.dll may be eliminate shadows. Run special check for it
GL_CheckExtension( "PARANOIA_HACKS_V1", NULL, NULL, R_PARANOIA_EXT );
GL_CheckExtension( "GL_ARB_seamless_cube_map", NULL, "gl_seamless_cubemap", R_SEAMLESS_CUBEMAP );
// check for hardware skinning
pglGetIntegerv( GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &glConfig.max_vertex_uniforms );
pglGetIntegerv( GL_MAX_VERTEX_ATTRIBS_ARB, &glConfig.max_vertex_attribs );
pglGetIntegerv( GL_MAX_VARYING_FLOATS_ARB, &glConfig.max_varying_floats );
if( glConfig.hardware_type == GLHW_RADEON && glConfig.max_vertex_uniforms > 512 )
glConfig.max_vertex_uniforms /= 4; // only radion returns count of floats other returns count of vec4
glConfig.max_skinning_bones = bound( 0, ( Q_max( glConfig.max_vertex_uniforms - MAX_RESERVED_UNIFORMS, 0 ) / 7 ), MAXSTUDIOBONES );
if( glConfig.max_skinning_bones < 32 )
{
ALERT( at_error, "Hardware Skinning not support. Custom renderer disabled\n" );
g_fRenderInitialized = FALSE;
return;
}
else if( glConfig.max_skinning_bones < MAXSTUDIOBONES )
ALERT( at_warning, "Hardware Skinning has a limitation (max %i bones)\n", glConfig.max_skinning_bones );
ALERT( at_aiconsole, "GL_InitExtensions: max vertex uniforms %i\n", glConfig.max_vertex_uniforms );
ALERT( at_aiconsole, "GL_InitExtensions: max varying floats %i\n", glConfig.max_varying_floats );
ALERT( at_aiconsole, "GL_InitExtensions: MaxSkinned bones %i\n", glConfig.max_skinning_bones );
glConfig.max_texture_units = RENDER_GET_PARM( PARM_MAX_IMAGE_UNITS, 0 );
if( GL_Support( R_DEBUG_OUTPUT ))
{
if( developer_level >= 2 )
{
pglDebugMessageCallbackARB( GL_DebugOutput, NULL );
}
if( developer_level >= 3 )
{
// force everything to happen in the main thread instead of in a separate driver thread
pglEnable( GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB );
}
if( developer_level >= 4 )
{
// enable all the low priority messages
pglDebugMessageControlARB( GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_LOW_ARB, 0, NULL, true );
}
}
}
/*
===============
GL_SetDefaultState
===============
*/
void GL_SetDefaultState( void )
{
glState.depthmin = glState.depthmax = -1.0f;
glState.depthmask = -1;
GL_CleanupAllTextureUnits();
pglBindVertexArray( GL_FALSE ); // should be first!
pglBindBufferARB( GL_ARRAY_BUFFER_ARB, 0 );
pglBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, 0 );
pglDisable( GL_SCISSOR_TEST );
pglShadeModel( GL_SMOOTH );
GL_BindFBO( FBO_MAIN );
GL_BindShader( NULL );
}
void R_CreateSpotLightTexture( void )
{
if( tr.defaultProjTexture ) return;
byte data[PROJ_SIZE*PROJ_SIZE*4];
byte *p = data;
for( int i = 0; i < PROJ_SIZE; i++ )
{
float dy = (PROJ_SIZE * 0.5f - i + 0.5f) / (PROJ_SIZE * 0.5f);
for( int j = 0; j < PROJ_SIZE; j++ )
{
float dx = (PROJ_SIZE * 0.5f - j + 0.5f) / (PROJ_SIZE * 0.5f);
float r = cos( M_PI / 2.0f * sqrt(dx * dx + dy * dy));
float c;
r = (r < 0) ? 0 : r * r;
c = 0xFF * r;
p[0] = (c <= 0xFF) ? c : 0xFF;
p[1] = (c <= 0xFF) ? c : 0xFF;
p[2] = (c <= 0xFF) ? c : 0xFF;
p[3] = (c <= 0xff) ? c : 0xFF;
p += 4;
}
}
tr.defaultProjTexture = CREATE_TEXTURE( "*spotlight", PROJ_SIZE, PROJ_SIZE, data, TF_SPOTLIGHT );
}
/*
==================
R_InitBlankBumpTexture
==================
*/
static void R_InitBlankBumpTexture( void )
{
byte data2D[256*4];
// default normalmap texture
for( int i = 0; i < 256; i++ )
{
data2D[i*4+0] = 127;
data2D[i*4+1] = 127;
data2D[i*4+2] = 255;
}
tr.normalmapTexture = CREATE_TEXTURE( "*blankbump", 16, 16, data2D, TF_NORMALMAP );
}
/*
==================
R_InitVSDCTCubemap
Virtual Shadow Depth Cube Texture
==================
*/
static void R_InitVSDCTCubemap( void )
{
if( !GL_Support( R_TEXTURECUBEMAP_EXT ))
return;
// maps to a 2x3 texture rectangle with normalized coordinates
// +-
// XX
// YY
// ZZ
// stores abs(dir.xy), offset.xy/2.5
static byte data[4*6] =
{
0xFF, 0x00, 0x33, 0x33, // +X: <1, 0>, <0.5, 0.5>
0xFF, 0x00, 0x99, 0x33, // -X: <1, 0>, <1.5, 0.5>
0x00, 0xFF, 0x33, 0x99, // +Y: <0, 1>, <0.5, 1.5>
0x00, 0xFF, 0x99, 0x99, // -Y: <0, 1>, <1.5, 1.5>
0x00, 0x00, 0x33, 0xFF, // +Z: <0, 0>, <0.5, 2.5>
0x00, 0x00, 0x99, 0xFF, // -Z: <0, 0>, <1.5, 2.5>
};
tr.vsdctCubeTexture = CREATE_TEXTURE( "*vsdct", 1, 1, data, TF_NEAREST|TF_HAS_ALPHA|TF_CUBEMAP|TF_CLAMP );
}
/*
==================
R_InitWhiteCubemap
==================
*/
static void R_InitWhiteCubemap( void )
{
byte dataCM[4*4*6*4];
int size = 4;
if( !GL_Support( R_TEXTURECUBEMAP_EXT ))
return;
// white cubemap - just stub for pointlights
memset( dataCM, 0xFF, sizeof( dataCM ));
tr.whiteCubeTexture = CREATE_TEXTURE( "*whiteCube", size, size, dataCM, TF_NOMIPMAP|TF_CUBEMAP|TF_CLAMP );
}
/*
=============
R_LoadIdentity
=============
*/
static void R_LoadIdentity( void )
{
glState.identityMatrix[ 0] = 1.0f;
glState.identityMatrix[ 1] = 0.0f;
glState.identityMatrix[ 2] = 0.0f;
glState.identityMatrix[ 3] = 0.0f;
glState.identityMatrix[ 4] = 0.0f;
glState.identityMatrix[ 5] = 1.0f;
glState.identityMatrix[ 6] = 0.0f;
glState.identityMatrix[ 7] = 0.0f;
glState.identityMatrix[ 8] = 0.0f;
glState.identityMatrix[ 9] = 0.0f;
glState.identityMatrix[10] = 1.0f;
glState.identityMatrix[11] = 0.0f;
glState.identityMatrix[12] = 0.0f;
glState.identityMatrix[13] = 0.0f;
glState.identityMatrix[14] = 0.0f;
glState.identityMatrix[15] = 1.0f;
}
void R_InitDefaultLights( void )
{
// this used to precache uber-shaders
memset( &tr.defaultlightSpot, 0, sizeof( tr.defaultlightSpot ));
memset( &tr.defaultlightOmni, 0, sizeof( tr.defaultlightOmni ));
memset( &tr.defaultlightProj, 0, sizeof( tr.defaultlightProj ));
tr.defaultlightSpot.type = LIGHT_SPOT;
tr.defaultlightOmni.type = LIGHT_OMNI;
tr.defaultlightProj.type = LIGHT_DIRECTIONAL;
}
static void GL_InitTextures( void )
{
// just get it from engine
tr.defaultTexture = FIND_TEXTURE( "*default" ); // use for bad textures
tr.deluxemapTexture = FIND_TEXTURE( "*gray" ); // like Vector( 0, 0, 0 )
tr.whiteTexture = FIND_TEXTURE( "*white" );
tr.grayTexture = FIND_TEXTURE( "*gray" );
tr.blackTexture = FIND_TEXTURE( "*black" );
tr.depthTexture = CREATE_TEXTURE( "*depth", 8, 8, NULL, TF_SHADOW );
R_InitWhiteCubemap();
R_InitBlankBumpTexture();
R_InitVSDCTCubemap();
if( GL_Support( R_EXT_GPU_SHADER4 ))
tr.depthCubemap = CREATE_TEXTURE( "depthCube", 8, 8, NULL, TF_SHADOW_CUBEMAP );
// best fit normals
tr.normalsFitting = LOAD_TEXTURE( "gfx/NormalsFitting.dds", NULL, 0, TF_KEEP_SOURCE|TF_CLAMP|TF_NEAREST );
if( !tr.normalsFitting ) tr.normalsFitting = tr.whiteTexture; // fallback
// load water animation
for( int i = 0; i < WATER_TEXTURES; i++ )
{
char path[256];
Q_snprintf( path, sizeof( path ), "gfx/water/water_normal_%i", i );
tr.waterTextures[i] = LOAD_TEXTURE( path, NULL, 0, TF_NORMALMAP );
}
R_CreateSpotLightTexture ();
// initialize spotlights
if( !tr.spotlightTexture[0] )
{
char path[256];
tr.spotlightTexture[0] = tr.defaultProjTexture; // always present
tr.flashlightTexture = LOAD_TEXTURE( "gfx/flashlight", NULL, 0, TF_SPOTLIGHT );
if( !tr.flashlightTexture ) tr.flashlightTexture = tr.defaultProjTexture;
// 7 custom textures allowed
for( int i = 1; i < 8; i++ )
{
Q_snprintf( path, sizeof( path ), "gfx/spotlight%i", i );
if( IMAGE_EXISTS( path ))
tr.spotlightTexture[i] = LOAD_TEXTURE( path, NULL, 0, TF_SPOTLIGHT );
if( !tr.spotlightTexture[i] )
tr.spotlightTexture[i] = tr.defaultProjTexture; // make default if missed
}
}
}
/*
==================
GL_Init
==================
*/
bool GL_Init( void )
{
R_InitRefState();
GL_InitExtensions();
BuildGammaTable();
R_LoadIdentity();
if( !g_fRenderInitialized )
{
CVAR_SET_FLOAT( "gl_renderer", 0 );
GL_Shutdown();
return false;
}
DBG_PrintVertexVBOSizes();
GL_InitGPUShaders();
InitPostEffects();
GL_InitTextures();
COM_InitMatdef();
CL_InitMaterials();
GL_SetDefaultState();
GL_InitRandomTable();
pglPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
pglPixelStorei( GL_PACK_ALIGNMENT, 1 );
pglPointSize( 10.0f );
pglLineWidth( 1.0f );
InitRain(); // rain
DecalsInit();
R_GrassInit();
return true;
}
/*
===============
GL_Shutdown
===============
*/
void GL_Shutdown( void )
{
int i;
g_StudioRenderer.DestroyAllModelInstances();
g_StudioRenderer.FreeStudioCacheVL();
g_StudioRenderer.FreeStudioCacheFL();
if( tr.materials )
Mem_Free( tr.materials );
for( i = 0; i < tr.num_framebuffers; i++ )
{
if( !tr.frame_buffers[i].init )
break;
R_FreeFrameBuffer( i );
}
tr.fbo_shadow2D.Free();
tr.fbo_shadowCM.Free();
for( i = 0; i < MAX_SHADOWMAPS; i++ )
{
tr.sunShadowFBO[i].Free();
}
R_FreeCinematics();
DecalsShutdown();
R_GrassShutdown();
GL_FreeGPUShaders();
GL_FreeDrawbuffers();
// now all extensions are disabled
memset( glConfig.extension, 0, sizeof( glConfig.extension[0] ) * R_EXTCOUNT );
}
Reference in New Issue View Git Blame Copy Permalink