#include "gl_local.h" #if XASH_GL4ES #include "gl4es/include/gl4esinit.h" #include "gl4es/include/gl4eshint.h" #endif // XASH_GL4ES CVAR_DEFINE( gl_extensions, "gl_allow_extensions", "1", FCVAR_GLCONFIG|FCVAR_READ_ONLY, "allow gl_extensions" ); CVAR_DEFINE( gl_texture_anisotropy, "gl_anisotropy", "8", FCVAR_GLCONFIG, "textures anisotropic filter" ); CVAR_DEFINE_AUTO( gl_texture_lodbias, "0.0", FCVAR_GLCONFIG, "LOD bias for mipmapped textures (perfomance|quality)" ); CVAR_DEFINE_AUTO( gl_texture_nearest, "0", FCVAR_GLCONFIG, "disable texture filter" ); CVAR_DEFINE_AUTO( gl_lightmap_nearest, "0", FCVAR_GLCONFIG, "disable lightmap filter" ); CVAR_DEFINE_AUTO( gl_keeptjunctions, "1", FCVAR_GLCONFIG, "removing tjuncs causes blinking pixels" ); CVAR_DEFINE_AUTO( gl_check_errors, "1", FCVAR_GLCONFIG, "ignore video engine errors" ); CVAR_DEFINE_AUTO( gl_polyoffset, "2.0", FCVAR_GLCONFIG, "polygon offset for decals" ); CVAR_DEFINE_AUTO( gl_wireframe, "0", FCVAR_GLCONFIG|FCVAR_SPONLY, "show wireframe overlay" ); CVAR_DEFINE_AUTO( gl_finish, "0", FCVAR_GLCONFIG, "use glFinish instead of glFlush" ); CVAR_DEFINE_AUTO( gl_nosort, "0", FCVAR_GLCONFIG, "disable sorting of translucent surfaces" ); CVAR_DEFINE_AUTO( gl_test, "0", 0, "engine developer cvar for quick testing new features" ); CVAR_DEFINE_AUTO( gl_msaa, "1", FCVAR_GLCONFIG, "enable or disable multisample anti-aliasing" ); CVAR_DEFINE_AUTO( gl_stencilbits, "8", FCVAR_GLCONFIG|FCVAR_READ_ONLY, "pixelformat stencil bits (0 - auto)" ); CVAR_DEFINE_AUTO( gl_overbright, "1", FCVAR_GLCONFIG, "overbrights" ); CVAR_DEFINE_AUTO( r_lighting_extended, "1", FCVAR_GLCONFIG, "allow to get lighting from world and bmodels" ); CVAR_DEFINE_AUTO( r_lighting_ambient, "0.3", FCVAR_GLCONFIG, "map ambient lighting scale" ); CVAR_DEFINE_AUTO( r_detailtextures, "1", FCVAR_ARCHIVE, "enable detail textures support" ); CVAR_DEFINE_AUTO( r_novis, "0", 0, "ignore vis information (perfomance test)" ); CVAR_DEFINE_AUTO( r_nocull, "0", 0, "ignore frustrum culling (perfomance test)" ); CVAR_DEFINE_AUTO( r_lockpvs, "0", FCVAR_CHEAT, "lockpvs area at current point (pvs test)" ); CVAR_DEFINE_AUTO( r_lockfrustum, "0", FCVAR_CHEAT, "lock frustrum area at current point (cull test)" ); CVAR_DEFINE_AUTO( r_traceglow, "0", FCVAR_GLCONFIG, "cull flares behind models" ); CVAR_DEFINE_AUTO( gl_round_down, "2", FCVAR_GLCONFIG|FCVAR_READ_ONLY, "round texture sizes to nearest POT value" ); CVAR_DEFINE( r_vbo, "gl_vbo", "0", FCVAR_ARCHIVE, "draw world using VBO (known to be glitchy)" ); CVAR_DEFINE( r_vbo_detail, "gl_vbo_detail", "0", FCVAR_ARCHIVE, "detail vbo mode (0: disable, 1: multipass, 2: singlepass, broken decal dlights)" ); CVAR_DEFINE( r_vbo_dlightmode, "gl_vbo_dlightmode", "1", FCVAR_ARCHIVE, "vbo dlight rendering mode (0-1)" ); CVAR_DEFINE( r_vbo_overbrightmode, "gl_vbo_overbrightmode", "0", FCVAR_ARCHIVE, "vbo overbright rendering mode (0-1)" ); CVAR_DEFINE_AUTO( r_ripple, "0", FCVAR_GLCONFIG, "enable software-like water texture ripple simulation" ); CVAR_DEFINE_AUTO( r_ripple_updatetime, "0.05", FCVAR_GLCONFIG, "how fast ripple simulation is" ); CVAR_DEFINE_AUTO( r_ripple_spawntime, "0.1", FCVAR_GLCONFIG, "how fast new ripples spawn" ); DEFINE_ENGINE_SHARED_CVAR_LIST() poolhandle_t r_temppool; gl_globals_t tr; glconfig_t glConfig; glstate_t glState; glwstate_t glw_state; #ifdef XASH_GL_STATIC #define GL_CALL( x ) #x, NULL #else #define GL_CALL( x ) #x, (void**)&p##x #endif static dllfunc_t opengl_110funcs[] = { { GL_CALL( glClearColor ) }, { GL_CALL( glClear ) }, { GL_CALL( glAlphaFunc ) }, { GL_CALL( glBlendFunc ) }, { GL_CALL( glCullFace ) }, { GL_CALL( glDrawBuffer ) }, { GL_CALL( glReadBuffer ) }, { GL_CALL( glAccum ) }, { GL_CALL( glEnable ) }, { GL_CALL( glDisable ) }, { GL_CALL( glEnableClientState ) }, { GL_CALL( glDisableClientState ) }, { GL_CALL( glGetBooleanv ) }, { GL_CALL( glGetDoublev ) }, { GL_CALL( glGetFloatv ) }, { GL_CALL( glGetIntegerv ) }, { GL_CALL( glGetError ) }, { GL_CALL( glGetString ) }, { GL_CALL( glFinish ) }, { GL_CALL( glFlush ) }, { GL_CALL( glClearDepth ) }, { GL_CALL( glDepthFunc ) }, { GL_CALL( glDepthMask ) }, { GL_CALL( glDepthRange ) }, { GL_CALL( glFrontFace ) }, { GL_CALL( glDrawElements ) }, { GL_CALL( glDrawArrays ) }, { GL_CALL( glColorMask ) }, { GL_CALL( glIndexPointer ) }, { GL_CALL( glVertexPointer ) }, { GL_CALL( glNormalPointer ) }, { GL_CALL( glColorPointer ) }, { GL_CALL( glTexCoordPointer ) }, { GL_CALL( glArrayElement ) }, { GL_CALL( glColor3f ) }, { GL_CALL( glColor3fv ) }, { GL_CALL( glColor4f ) }, { GL_CALL( glColor4fv ) }, { GL_CALL( glColor3ub ) }, { GL_CALL( glColor4ub ) }, { GL_CALL( glColor4ubv ) }, { GL_CALL( glTexCoord1f ) }, { GL_CALL( glTexCoord2f ) }, { GL_CALL( glTexCoord3f ) }, { GL_CALL( glTexCoord4f ) }, { GL_CALL( glTexCoord1fv ) }, { GL_CALL( glTexCoord2fv ) }, { GL_CALL( glTexCoord3fv ) }, { GL_CALL( glTexCoord4fv ) }, { GL_CALL( glTexGenf ) }, { GL_CALL( glTexGenfv ) }, { GL_CALL( glTexGeni ) }, { GL_CALL( glVertex2f ) }, { GL_CALL( glVertex3f ) }, { GL_CALL( glVertex3fv ) }, { GL_CALL( glNormal3f ) }, { GL_CALL( glNormal3fv ) }, { GL_CALL( glBegin ) }, { GL_CALL( glEnd ) }, { GL_CALL( glLineWidth ) }, { GL_CALL( glPointSize ) }, { GL_CALL( glMatrixMode ) }, { GL_CALL( glOrtho ) }, { GL_CALL( glRasterPos2f ) }, { GL_CALL( glFrustum ) }, { GL_CALL( glViewport ) }, { GL_CALL( glPushMatrix ) }, { GL_CALL( glPopMatrix ) }, { GL_CALL( glPushAttrib ) }, { GL_CALL( glPopAttrib ) }, { GL_CALL( glLoadIdentity ) }, { GL_CALL( glLoadMatrixd ) }, { GL_CALL( glLoadMatrixf ) }, { GL_CALL( glMultMatrixd ) }, { GL_CALL( glMultMatrixf ) }, { GL_CALL( glRotated ) }, { GL_CALL( glRotatef ) }, { GL_CALL( glScaled ) }, { GL_CALL( glScalef ) }, { GL_CALL( glTranslated ) }, { GL_CALL( glTranslatef ) }, { GL_CALL( glReadPixels ) }, { GL_CALL( glDrawPixels ) }, { GL_CALL( glStencilFunc ) }, { GL_CALL( glStencilMask ) }, { GL_CALL( glStencilOp ) }, { GL_CALL( glClearStencil ) }, { GL_CALL( glIsEnabled ) }, { GL_CALL( glIsList ) }, { GL_CALL( glIsTexture ) }, { GL_CALL( glTexEnvf ) }, { GL_CALL( glTexEnvfv ) }, { GL_CALL( glTexEnvi ) }, { GL_CALL( glTexParameterf ) }, { GL_CALL( glTexParameterfv ) }, { GL_CALL( glTexParameteri ) }, { GL_CALL( glHint ) }, { GL_CALL( glPixelStoref ) }, { GL_CALL( glPixelStorei ) }, { GL_CALL( glGenTextures ) }, { GL_CALL( glDeleteTextures ) }, { GL_CALL( glBindTexture ) }, { GL_CALL( glTexImage1D ) }, { GL_CALL( glTexImage2D ) }, { GL_CALL( glTexSubImage1D ) }, { GL_CALL( glTexSubImage2D ) }, { GL_CALL( glCopyTexImage1D ) }, { GL_CALL( glCopyTexImage2D ) }, { GL_CALL( glCopyTexSubImage1D ) }, { GL_CALL( glCopyTexSubImage2D ) }, { GL_CALL( glScissor ) }, { GL_CALL( glGetTexImage ) }, { GL_CALL( glGetTexEnviv ) }, { GL_CALL( glPolygonOffset ) }, { GL_CALL( glPolygonMode ) }, { GL_CALL( glPolygonStipple ) }, { GL_CALL( glClipPlane ) }, { GL_CALL( glGetClipPlane ) }, { GL_CALL( glShadeModel ) }, { GL_CALL( glGetTexLevelParameteriv ) }, { GL_CALL( glGetTexLevelParameterfv ) }, { GL_CALL( glFogfv ) }, { GL_CALL( glFogf ) }, { GL_CALL( glFogi ) }, { NULL , NULL } }; static dllfunc_t debugoutputfuncs[] = { { GL_CALL( glDebugMessageControlARB ) }, { GL_CALL( glDebugMessageInsertARB ) }, { GL_CALL( glDebugMessageCallbackARB ) }, { GL_CALL( glGetDebugMessageLogARB ) }, { NULL , NULL } }; static dllfunc_t multitexturefuncs[] = { { GL_CALL( glMultiTexCoord1f ) }, { GL_CALL( glMultiTexCoord2f ) }, { GL_CALL( glMultiTexCoord3f ) }, { GL_CALL( glMultiTexCoord4f ) }, { GL_CALL( glActiveTexture ) }, { GL_CALL( glActiveTextureARB ) }, { GL_CALL( glClientActiveTexture ) }, { GL_CALL( glClientActiveTextureARB ) }, { NULL , NULL } }; static dllfunc_t texture3dextfuncs[] = { { GL_CALL( glTexImage3D ) }, { GL_CALL( glTexSubImage3D ) }, { GL_CALL( glCopyTexSubImage3D ) }, { NULL , NULL } }; static dllfunc_t texturecompressionfuncs[] = { { GL_CALL( glCompressedTexImage3DARB ) }, { GL_CALL( glCompressedTexImage2DARB ) }, { GL_CALL( glCompressedTexImage1DARB ) }, { GL_CALL( glCompressedTexSubImage3DARB ) }, { GL_CALL( glCompressedTexSubImage2DARB ) }, { GL_CALL( glCompressedTexSubImage1DARB ) }, { GL_CALL( glGetCompressedTexImage ) }, { NULL , NULL } }; static dllfunc_t vbofuncs[] = { { GL_CALL( glBindBufferARB ) }, { GL_CALL( glDeleteBuffersARB ) }, { GL_CALL( glGenBuffersARB ) }, { GL_CALL( glIsBufferARB ) }, #ifndef XASH_GLES { GL_CALL( glMapBufferARB ) }, { GL_CALL( glUnmapBufferARB ) }, #endif { GL_CALL( glBufferDataARB ) }, { GL_CALL( glBufferSubDataARB ) }, { NULL, NULL } }; static dllfunc_t multisampletexfuncs[] = { { GL_CALL(glTexImage2DMultisample) }, { NULL, NULL } }; static dllfunc_t drawrangeelementsfuncs[] = { { GL_CALL( glDrawRangeElements ) }, { NULL, NULL } }; static dllfunc_t drawrangeelementsextfuncs[] = { { GL_CALL( glDrawRangeElementsEXT ) }, { NULL, NULL } }; // mangling in gl2shim??? // still need resolve some ext dynamicly, and mangling beginend wrappers will help only with LTO // anyway this will not work with gl-wes/nanogl, we do not link to libGLESv2, so skip this now #ifndef XASH_GL_STATIC static dllfunc_t mapbufferrangefuncs[] = { { GL_CALL( glMapBufferRange ) }, { GL_CALL( glFlushMappedBufferRange ) }, #ifdef XASH_GLES { GL_CALL( glUnmapBufferARB ) }, #endif { NULL, NULL } }; static dllfunc_t drawrangeelementsbasevertexfuncs[] = { { GL_CALL( glDrawRangeElementsBaseVertex ) }, { NULL, NULL } }; static dllfunc_t bufferstoragefuncs[] = { { GL_CALL( glBufferStorage ) }, { NULL, NULL } }; static dllfunc_t shaderobjectsfuncs[] = { { GL_CALL( glDeleteObjectARB ) }, { GL_CALL( glGetHandleARB ) }, { GL_CALL( glDetachObjectARB ) }, { GL_CALL( glCreateShaderObjectARB ) }, { GL_CALL( glShaderSourceARB ) }, { GL_CALL( glCompileShaderARB ) }, { GL_CALL( glCreateProgramObjectARB ) }, { GL_CALL( glAttachObjectARB ) }, { GL_CALL( glLinkProgramARB ) }, { GL_CALL( glUseProgramObjectARB ) }, { GL_CALL( glValidateProgramARB ) }, { GL_CALL( glUniform1fARB ) }, { GL_CALL( glUniform2fARB ) }, { GL_CALL( glUniform3fARB ) }, { GL_CALL( glUniform4fARB ) }, { GL_CALL( glUniform1iARB ) }, { GL_CALL( glUniform2iARB ) }, { GL_CALL( glUniform3iARB ) }, { GL_CALL( glUniform4iARB ) }, { GL_CALL( glUniform1fvARB ) }, { GL_CALL( glUniform2fvARB ) }, { GL_CALL( glUniform3fvARB ) }, { GL_CALL( glUniform4fvARB ) }, { GL_CALL( glUniform1ivARB ) }, { GL_CALL( glUniform2ivARB ) }, { GL_CALL( glUniform3ivARB ) }, { GL_CALL( glUniform4ivARB ) }, { GL_CALL( glUniformMatrix2fvARB ) }, { GL_CALL( glUniformMatrix3fvARB ) }, { GL_CALL( glUniformMatrix4fvARB ) }, { GL_CALL( glGetObjectParameterfvARB ) }, { GL_CALL( glGetObjectParameterivARB ) }, { GL_CALL( glGetInfoLogARB ) }, { GL_CALL( glGetAttachedObjectsARB ) }, { GL_CALL( glGetUniformLocationARB ) }, { GL_CALL( glGetActiveUniformARB ) }, { GL_CALL( glGetUniformfvARB ) }, { GL_CALL( glGetUniformivARB ) }, { GL_CALL( glGetShaderSourceARB ) }, { GL_CALL( glVertexAttribPointerARB ) }, { GL_CALL( glEnableVertexAttribArrayARB ) }, { GL_CALL( glDisableVertexAttribArrayARB ) }, { GL_CALL( glBindAttribLocationARB ) }, { GL_CALL( glGetActiveAttribARB ) }, { GL_CALL( glGetAttribLocationARB ) }, { GL_CALL( glVertexAttrib2fARB ) }, { GL_CALL( glVertexAttrib2fvARB ) }, // { GL_CALL( glVertexAttrib3fv ) }, // { GL_CALL( glVertexAttrib4f ) }, // { GL_CALL( glVertexAttrib4fv ) }, // { GL_CALL( glVertexAttrib4ubv ) }, { NULL, NULL } }; /* ================== Even if *ARB functions may work in GL driver in Core context, renderdoc completely ignores this calls, so we cannot workaround this by removing ARB suffix after failed function resolve I desided not to remove ARB suffix from function declarations because it historicaly related to ARB_shader_object extension, not GL2+ functions and all shader code from XashXT/ancient xash3d uses it too Commented out lines left there intentionally to prevent usage on core/gles ================== */ static dllfunc_t shaderobjectsfuncs_gles[] = { { "glDeleteShader" , (void **)&pglDeleteObjectARB }, //{ "glGetHandleARB" , (void **)&pglGetHandleARB }, { "glDetachShader" , (void **)&pglDetachObjectARB }, { "glCreateShader" , (void **)&pglCreateShaderObjectARB }, { "glShaderSource" , (void **)&pglShaderSourceARB }, { "glCompileShader" , (void **)&pglCompileShaderARB }, { "glCreateProgram" , (void **)&pglCreateProgramObjectARB }, { "glAttachShader" , (void **)&pglAttachObjectARB }, { "glLinkProgram" , (void **)&pglLinkProgramARB }, { "glUseProgram" , (void **)&pglUseProgramObjectARB }, { "glValidateProgram" , (void **)&pglValidateProgramARB }, { "glUniform1f" , (void **)&pglUniform1fARB }, { "glUniform2f" , (void **)&pglUniform2fARB }, { "glUniform3f" , (void **)&pglUniform3fARB }, { "glUniform4f" , (void **)&pglUniform4fARB }, { "glUniform1i" , (void **)&pglUniform1iARB }, { "glUniform2i" , (void **)&pglUniform2iARB }, { "glUniform3i" , (void **)&pglUniform3iARB }, { "glUniform4i" , (void **)&pglUniform4iARB }, { "glUniform1f" , (void **)&pglUniform1fvARB }, { "glUniform2fv" , (void **)&pglUniform2fvARB }, { "glUniform3fv" , (void **)&pglUniform3fvARB }, { "glUniform4fv" , (void **)&pglUniform4fvARB }, { "glUniform1iv" , (void **)&pglUniform1ivARB }, { "glUniform2iv" , (void **)&pglUniform2ivARB }, { "glUniform3iv" , (void **)&pglUniform3ivARB }, { "glUniform4iv" , (void **)&pglUniform4ivARB }, { "glUniformMatrix2fv" , (void **)&pglUniformMatrix2fvARB }, { "glUniformMatrix3fv" , (void **)&pglUniformMatrix3fvARB }, { "glUniformMatrix4fv" , (void **)&pglUniformMatrix4fvARB }, // { "glGetShaderfv" , (void **)&pglGetObjectParameterfvARB }, // missing in ES2? { "glGetShaderiv" , (void **)&pglGetObjectParameterivARB }, { "glGetShaderInfoLog" , (void **)&pglGetInfoLogARB }, // { "glGetAttachedObjects" , (void **)&pglGetAttachedObjectsARB }, // missing in ES2? { "glGetUniformLocation" , (void **)&pglGetUniformLocationARB }, { "glGetActiveUniform" , (void **)&pglGetActiveUniformARB }, { "glGetUniformfv" , (void **)&pglGetUniformfvARB }, { "glGetUniformiv" , (void **)&pglGetUniformivARB }, { "glGetShaderSource" , (void **)&pglGetShaderSourceARB }, { "glVertexAttribPointer" , (void **)&pglVertexAttribPointerARB }, { "glEnableVertexAttribArray" , (void **)&pglEnableVertexAttribArrayARB }, { "glDisableVertexAttribArray" , (void **)&pglDisableVertexAttribArrayARB }, { "glBindAttribLocation" , (void **)&pglBindAttribLocationARB }, { "glGetActiveAttrib" , (void **)&pglGetActiveAttribARB }, { "glGetAttribLocation" , (void **)&pglGetAttribLocationARB }, { "glVertexAttrib2f" , (void **)&pglVertexAttrib2fARB }, { "glVertexAttrib2fv" , (void **)&pglVertexAttrib2fvARB }, { "glVertexAttrib3fv" , (void **)&pglVertexAttrib3fvARB }, // Core/GLES only { GL_CALL( glGetProgramiv ) }, { GL_CALL( glDeleteProgram ) }, { GL_CALL( glGetProgramInfoLog ) }, //{ "glVertexAttrib4f" , (void **)&pglVertexAttrib4fARB }, //{ "glVertexAttrib4fv" , (void **)&pglVertexAttrib4fvARB }, //{ "glVertexAttrib4ubv" , (void **)&pglVertexAttrib4ubvARB }, { NULL, NULL } }; static dllfunc_t vaofuncs[] = { { GL_CALL( glBindVertexArray ) }, { GL_CALL( glDeleteVertexArrays ) }, { GL_CALL( glGenVertexArrays ) }, { GL_CALL( glIsVertexArray ) }, { NULL, NULL } }; static dllfunc_t multitexturefuncs_es[] = { { GL_CALL( glActiveTexture ) }, { GL_CALL( glActiveTextureARB ) }, { GL_CALL( glClientActiveTexture ) }, { GL_CALL( glClientActiveTextureARB ) }, { NULL , NULL } }; static dllfunc_t multitexturefuncs_es2[] = { { GL_CALL( glActiveTexture ) }, { GL_CALL( glActiveTextureARB ) }, { NULL , NULL } }; #endif /* ======================== 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 ) { switch( type ) { case GL_DEBUG_TYPE_ERROR_ARB: gEngfuncs.Con_Printf( S_OPENGL_ERROR "%s\n", message ); break; case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB: case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB: gEngfuncs.Con_Printf( S_OPENGL_WARN "%s\n", message ); break; case GL_DEBUG_TYPE_PORTABILITY_ARB: gEngfuncs.Con_Reportf( S_OPENGL_WARN "%s\n", message ); break; case GL_DEBUG_TYPE_PERFORMANCE_ARB: case GL_DEBUG_TYPE_OTHER_ARB: default: gEngfuncs.Con_Printf( S_OPENGL_NOTE "%s\n", message ); break; } } /* ================= GL_SetExtension ================= */ void GL_SetExtension( int r_ext, int enable ) { if( r_ext >= 0 && r_ext < GL_EXTCOUNT ) glConfig.extension[r_ext] = enable ? GL_TRUE : GL_FALSE; else gEngfuncs.Con_Printf( S_ERROR "%s: invalid extension %d\n", __func__, r_ext ); } /* ================= GL_Support ================= */ qboolean GL_Support( int r_ext ) { if( r_ext >= 0 && r_ext < GL_EXTCOUNT ) return glConfig.extension[r_ext] ? true : false; gEngfuncs.Con_Printf( S_ERROR "%s: invalid extension %d\n", __func__, r_ext ); return false; } /* ================= GL_MaxTextureUnits ================= */ int GL_MaxTextureUnits( void ) { if( GL_Support( GL_SHADER_GLSL100_EXT )) return Q_min( Q_max( glConfig.max_texture_coords, glConfig.max_teximage_units ), MAX_TEXTURE_UNITS ); return glConfig.max_texture_units; } /* ================= GL_CheckExtension ================= */ qboolean GL_CheckExtension( const char *name, const dllfunc_t *funcs, const char *cvarname, int r_ext, float minver ) { const dllfunc_t *func; cvar_t *parm = NULL; const char *extensions_string; char desc[MAX_VA_STRING]; float glver = (float)glConfig.version_major + glConfig.version_minor / 10.0f; gEngfuncs.Con_Reportf( "%s: %s ", __func__, name ); GL_SetExtension( r_ext, true ); if( cvarname ) { // system config disable extensions Q_snprintf( desc, sizeof( desc ), CVAR_GLCONFIG_DESCRIPTION, name ); parm = gEngfuncs.Cvar_Get( cvarname, "1", FCVAR_GLCONFIG|FCVAR_READ_ONLY, desc ); } if(( parm && !parm->value ) || ( !gl_extensions.value && r_ext != GL_OPENGL_110 )) { gEngfuncs.Con_Reportf( "- disabled\n" ); GL_SetExtension( r_ext, false ); return false; // nothing to process at } extensions_string = glConfig.extensions_string; if(( name[2] == '_' || name[3] == '_' ) && !Q_strstr( extensions_string, name ) && ( glver < minver || !minver || !glver ) ) { GL_SetExtension( r_ext, false ); // update render info gEngfuncs.Con_Reportf( "- ^1failed\n" ); return false; } #ifndef XASH_GL_STATIC // clear exports for( func = funcs; func && func->name; func++ ) *func->func = NULL; for( func = funcs; func && func->name; func++ ) { // functions are cleared before all the extensions are evaluated if(( *func->func = (void *)gEngfuncs.GL_GetProcAddress( func->name )) == NULL ) { string name; char *end; size_t i = 0; #ifdef XASH_GLES const char *suffixes[] = { "", "EXT", "OES" }; #else const char *suffixes[] = { "", "EXT" }; #endif // HACK: fix ARB names Q_strncpy( name, func->name, sizeof( name )); if(( end = Q_strstr( name, "ARB" ))) { *end = '\0'; } else // I need Q_strstrnul { end = name + Q_strlen( name ); i++; // skip empty suffix } for( ; i < sizeof( suffixes ) / sizeof( suffixes[0] ); i++ ) { void *f; Q_strncat( name, suffixes[i], sizeof( name )); if(( f = gEngfuncs.GL_GetProcAddress( name ))) { // GL_GetProcAddress prints errors about missing functions, so tell user that we found it with different name gEngfuncs.Con_Printf( S_NOTE "found %s\n", name ); *func->func = f; break; } else { *end = '\0'; // cut suffix, try next } } // not found... if( i == sizeof( suffixes ) / sizeof( suffixes[0] )) { GL_SetExtension( r_ext, false ); } } } #endif if( GL_Support( r_ext )) { gEngfuncs.Con_Reportf( "- ^2enabled\n" ); return true; } gEngfuncs.Con_Reportf( "- ^1failed\n" ); return false; } /* ============== GL_GetProcAddress defined just for nanogl/glwes, so it don't link to SDL2 directly, nor use dlsym ============== */ void GAME_EXPORT *GL_GetProcAddress( const char *name ); // keep defined for nanogl/wes void GAME_EXPORT *GL_GetProcAddress( const char *name ) { return gEngfuncs.GL_GetProcAddress( name ); } /* =============== GL_SetDefaultTexState =============== */ static void GL_SetDefaultTexState( void ) { int i; memset( glState.currentTextures, -1, MAX_TEXTURE_UNITS * sizeof( *glState.currentTextures )); memset( glState.texCoordArrayMode, 0, MAX_TEXTURE_UNITS * sizeof( *glState.texCoordArrayMode )); memset( glState.genSTEnabled, 0, MAX_TEXTURE_UNITS * sizeof( *glState.genSTEnabled )); for( i = 0; i < MAX_TEXTURE_UNITS; i++ ) { glState.currentTextureTargets[i] = GL_NONE; glState.texIdentityMatrix[i] = true; } } /* =============== GL_SetDefaultState =============== */ static void GL_SetDefaultState( void ) { memset( &glState, 0, sizeof( glState )); GL_SetDefaultTexState (); // init draw stack tr.draw_list = &tr.draw_stack[0]; tr.draw_stack_pos = 0; } /* =============== GL_SetDefaults =============== */ static void GL_SetDefaults( void ) { pglFinish(); pglClearColor( 0.5f, 0.5f, 0.5f, 1.0f ); pglDisable( GL_DEPTH_TEST ); pglDisable( GL_CULL_FACE ); pglDisable( GL_SCISSOR_TEST ); pglDepthFunc( GL_LEQUAL ); pglColor4f( 1.0f, 1.0f, 1.0f, 1.0f ); if( glState.stencilEnabled ) { pglDisable( GL_STENCIL_TEST ); pglStencilMask( ( GLuint ) ~0 ); pglStencilFunc( GL_EQUAL, 0, ~0 ); pglStencilOp( GL_KEEP, GL_INCR, GL_INCR ); } pglPolygonMode( GL_FRONT_AND_BACK, GL_FILL ); pglPolygonOffset( -1.0f, -2.0f ); GL_CleanupAllTextureUnits(); pglDisable( GL_BLEND ); pglDisable( GL_ALPHA_TEST ); pglDisable( GL_POLYGON_OFFSET_FILL ); pglAlphaFunc( GL_GREATER, DEFAULT_ALPHATEST ); pglEnable( GL_TEXTURE_2D ); pglShadeModel( GL_SMOOTH ); pglFrontFace( GL_CCW ); pglPointSize( 1.2f ); pglLineWidth( 1.2f ); GL_Cull( GL_NONE ); } /* ================= R_RenderInfo_f ================= */ static void R_RenderInfo_f( void ) { gEngfuncs.Con_Printf( "\n" ); gEngfuncs.Con_Printf( "GL_VENDOR: %s\n", glConfig.vendor_string ); gEngfuncs.Con_Printf( "GL_RENDERER: %s\n", glConfig.renderer_string ); gEngfuncs.Con_Printf( "GL_VERSION: %s\n", glConfig.version_string ); // don't spam about extensions gEngfuncs.Con_Reportf( "GL_EXTENSIONS: %s\n", glConfig.extensions_string ); if( glConfig.wrapper == GLES_WRAPPER_GL4ES ) { const char *vendor = (const char *)pglGetString( GL_VENDOR | 0x10000 ); const char *renderer = (const char *)pglGetString( GL_RENDERER | 0x10000 ); const char *version = (const char *)pglGetString( GL_VERSION | 0x10000 ); const char *extensions = (const char *)pglGetString( GL_EXTENSIONS | 0x10000 ); if( vendor ) gEngfuncs.Con_Printf( "GL4ES_VENDOR: %s\n", vendor ); if( renderer ) gEngfuncs.Con_Printf( "GL4ES_RENDERER: %s\n", renderer ); if( version ) gEngfuncs.Con_Printf( "GL4ES_VERSION: %s\n", version ); if( extensions ) gEngfuncs.Con_Reportf( "GL4ES_EXTENSIONS: %s\n", extensions ); } gEngfuncs.Con_Printf( "GL_MAX_TEXTURE_SIZE: %i\n", glConfig.max_2d_texture_size ); if( GL_Support( GL_ARB_MULTITEXTURE )) gEngfuncs.Con_Printf( "GL_MAX_TEXTURE_UNITS_ARB: %i\n", glConfig.max_texture_units ); if( GL_Support( GL_TEXTURE_CUBEMAP_EXT )) gEngfuncs.Con_Printf( "GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB: %i\n", glConfig.max_cubemap_size ); if( GL_Support( GL_ANISOTROPY_EXT )) gEngfuncs.Con_Printf( "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT: %.1f\n", glConfig.max_texture_anisotropy ); if( GL_Support( GL_TEXTURE_2D_RECT_EXT )) gEngfuncs.Con_Printf( "GL_MAX_RECTANGLE_TEXTURE_SIZE: %i\n", glConfig.max_2d_rectangle_size ); if( GL_Support( GL_TEXTURE_ARRAY_EXT )) gEngfuncs.Con_Printf( "GL_MAX_ARRAY_TEXTURE_LAYERS_EXT: %i\n", glConfig.max_2d_texture_layers ); if( GL_Support( GL_SHADER_GLSL100_EXT )) { gEngfuncs.Con_Printf( "GL_MAX_TEXTURE_COORDS_ARB: %i\n", glConfig.max_texture_coords ); gEngfuncs.Con_Printf( "GL_MAX_TEXTURE_IMAGE_UNITS_ARB: %i\n", glConfig.max_teximage_units ); gEngfuncs.Con_Printf( "GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB: %i\n", glConfig.max_vertex_uniforms ); gEngfuncs.Con_Printf( "GL_MAX_VERTEX_ATTRIBS_ARB: %i\n", glConfig.max_vertex_attribs ); } gEngfuncs.Con_Printf( "\n" ); gEngfuncs.Con_Printf( "MODE: %ix%i\n", gpGlobals->width, gpGlobals->height ); gEngfuncs.Con_Printf( "\n" ); gEngfuncs.Con_Printf( "VERTICAL SYNC: %s\n", gl_vsync->value ? "enabled" : "disabled" ); gEngfuncs.Con_Printf( "Color %d bits, Alpha %d bits, Depth %d bits, Stencil %d bits\n", glConfig.color_bits, glConfig.alpha_bits, glConfig.depth_bits, glConfig.stencil_bits ); } #ifdef XASH_GLES static void GL_InitExtensionsGLES( void ) { int extid; // intialize wrapper type #ifdef XASH_NANOGL glConfig.context = CONTEXT_TYPE_GLES_1_X; glConfig.wrapper = GLES_WRAPPER_NANOGL; #elif defined( XASH_WES ) glConfig.context = CONTEXT_TYPE_GLES_2_X; glConfig.wrapper = GLES_WRAPPER_WES; #elif defined( XASH_GLES3COMPAT ) glConfig.context = CONTEXT_TYPE_GLES_2_X; glConfig.wrapper = GLES_WRAPPER_NONE; #else #error "unknown gles wrapper" #endif glConfig.hardware_type = GLHW_GENERIC; for( extid = GL_OPENGL_110 + 1; extid < GL_EXTCOUNT; extid++ ) { switch( extid ) { case GL_ARB_VERTEX_BUFFER_OBJECT_EXT: GL_CheckExtension( "vertex_buffer_object", vbofuncs, "gl_vertex_buffer_object", extid, 1.0 ); break; case GL_ARB_MULTITEXTURE: if( !GL_CheckExtension( "multitexture", multitexturefuncs, "gl_arb_multitexture", GL_ARB_MULTITEXTURE, 1.0 ) && glConfig.wrapper == GLES_WRAPPER_NONE ) { #ifndef XASH_GL_STATIC if( !GL_CheckExtension( "multitexture_es1", multitexturefuncs_es, "gl_arb_multitexture", GL_ARB_MULTITEXTURE, 1.0 ) && !GL_CheckExtension( "multitexture_es2", multitexturefuncs_es2, "gl_arb_multitexture", GL_ARB_MULTITEXTURE, 2.0 )) break; #endif } GL_SetExtension( extid, true ); // required to be supported by wrapper pglGetIntegerv( GL_MAX_TEXTURE_UNITS_ARB, &glConfig.max_texture_units ); if( glConfig.max_texture_units <= 1 ) pglGetIntegerv( GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &glConfig.max_texture_units ); if( glConfig.max_texture_units <= 1 ) { GL_SetExtension( extid, false ); glConfig.max_texture_units = 1; } glConfig.max_texture_coords = glConfig.max_teximage_units = glConfig.max_texture_units; break; case GL_TEXTURE_CUBEMAP_EXT: if( GL_CheckExtension( "GL_OES_texture_cube_map", NULL, "gl_texture_cubemap", extid, 0 )) pglGetIntegerv( GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, &glConfig.max_cubemap_size ); break; case GL_ANISOTROPY_EXT: glConfig.max_texture_anisotropy = 0.0f; if( GL_CheckExtension( "GL_EXT_texture_filter_anisotropic", NULL, "gl_ext_anisotropic_filter", extid, 0 )) pglGetFloatv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &glConfig.max_texture_anisotropy ); break; case GL_TEXTURE_LOD_BIAS: if( GL_CheckExtension( "GL_EXT_texture_lod_bias", NULL, "gl_texture_mipmap_biasing", extid, 0 )) pglGetFloatv( GL_MAX_TEXTURE_LOD_BIAS_EXT, &glConfig.max_texture_lod_bias ); break; case GL_ARB_TEXTURE_NPOT_EXT: GL_CheckExtension( "GL_OES_texture_npot", NULL, "gl_texture_npot", extid, 0 ); break; #ifndef XASH_GL_STATIC case GL_SHADER_OBJECTS_EXT: GL_CheckExtension( "ES2 Shaders", shaderobjectsfuncs_gles, "gl_shaderobjects", extid, 2.0 ); break; case GL_ARB_VERTEX_ARRAY_OBJECT_EXT: if( !GL_CheckExtension( "GL_OES_vertex_array_object", vaofuncs, "gl_vertex_array_object", extid, 3.0 )) GL_CheckExtension( "GL_EXT_vertex_array_object", vaofuncs, "gl_vertex_array_object", extid, 3.0 ); break; case GL_DRAW_RANGEELEMENTS_EXT: if( !GL_CheckExtension( "GL_EXT_draw_range_elements", drawrangeelementsfuncs, "gl_drawrangeelements", extid, 3.0 )) GL_CheckExtension( "GL_OES_draw_range_elements", drawrangeelementsfuncs, "gl_drawrangeelements", extid, 3.0 ); break; case GL_DRAW_RANGE_ELEMENTS_BASE_VERTEX_EXT: if( !GL_CheckExtension( "GL_OES_draw_elements_base_vertex", drawrangeelementsbasevertexfuncs, "gl_drawrangeelementsbasevertex", GL_DRAW_RANGE_ELEMENTS_BASE_VERTEX_EXT, 0 )) GL_CheckExtension( "GL_EXT_draw_elements_base_vertex", drawrangeelementsbasevertexfuncs, "gl_drawrangeelementsbasevertex", GL_DRAW_RANGE_ELEMENTS_BASE_VERTEX_EXT, 3.2 ); break; case GL_MAP_BUFFER_RANGE_EXT: GL_CheckExtension( "GL_EXT_map_buffer_range", mapbufferrangefuncs, "gl_map_buffer_range", GL_MAP_BUFFER_RANGE_EXT , 3.0); break; case GL_BUFFER_STORAGE_EXT: GL_CheckExtension( "GL_EXT_buffer_storage", bufferstoragefuncs, "gl_buffer_storage", GL_BUFFER_STORAGE_EXT, 0); break; #endif case GL_DEBUG_OUTPUT: if( glw_state.extended ) GL_CheckExtension( "GL_KHR_debug", debugoutputfuncs, "gl_debug_output", extid, 0 ); else GL_SetExtension( extid, false ); break; // case GL_TEXTURE_COMPRESSION_EXT: NOPE // case GL_SHADER_GLSL100_EXT: NOPE // case GL_TEXTURE_2D_RECT_EXT: NOPE // case GL_TEXTURE_ARRAY_EXT: NOPE // case GL_TEXTURE_3D_EXT: NOPE // case GL_CLAMPTOEDGE_EXT: NOPE // case GL_CLAMP_TEXBORDER_EXT: NOPE // case GL_ARB_TEXTURE_FLOAT_EXT: NOPE // case GL_ARB_DEPTH_FLOAT_EXT: NOPE // case GL_ARB_SEAMLESS_CUBEMAP: NOPE // case GL_EXT_GPU_SHADER4: NOPE // case GL_DEPTH_TEXTURE: NOPE // case GL_DRAWRANGEELEMENTS_EXT: NOPE default: GL_SetExtension( extid, false ); } } #ifndef XASH_GL_STATIC GL2_ShimInit(); #endif } #else static void GL_InitExtensionsBigGL( void ) { // intialize wrapper type glConfig.context = gEngfuncs.Sys_CheckParm( "-glcore" )? CONTEXT_TYPE_GL_CORE : CONTEXT_TYPE_GL; glConfig.wrapper = GLES_WRAPPER_NONE; 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 if( Q_stristr( glConfig.renderer_string, "intel" )) glConfig.hardware_type = GLHW_INTEL; else glConfig.hardware_type = GLHW_GENERIC; // gl4es may be used system-wide if( Q_stristr( glConfig.renderer_string, "gl4es" )) glConfig.wrapper = GLES_WRAPPER_GL4ES; // multitexture glConfig.max_texture_units = glConfig.max_texture_coords = glConfig.max_teximage_units = 1; if( GL_CheckExtension( "GL_ARB_multitexture", multitexturefuncs, "gl_arb_multitexture", GL_ARB_MULTITEXTURE, 1.3f )) { pglGetIntegerv( GL_MAX_TEXTURE_UNITS_ARB, &glConfig.max_texture_units ); } if( glConfig.max_texture_units == 1 ) GL_SetExtension( GL_ARB_MULTITEXTURE, false ); // 3d texture support if( GL_CheckExtension( "GL_EXT_texture3D", texture3dextfuncs, "gl_texture_3d", GL_TEXTURE_3D_EXT, 2.0f )) { pglGetIntegerv( GL_MAX_3D_TEXTURE_SIZE, &glConfig.max_3d_texture_size ); if( glConfig.max_3d_texture_size < 32 ) { GL_SetExtension( GL_TEXTURE_3D_EXT, false ); gEngfuncs.Con_Printf( S_ERROR "GL_EXT_texture3D reported bogus GL_MAX_3D_TEXTURE_SIZE, disabled\n" ); } } // 2d texture array support if( GL_CheckExtension( "GL_EXT_texture_array", texture3dextfuncs, "gl_texture_2d_array", GL_TEXTURE_ARRAY_EXT, 0 )) pglGetIntegerv( GL_MAX_ARRAY_TEXTURE_LAYERS_EXT, &glConfig.max_2d_texture_layers ); // cubemaps support if( GL_CheckExtension( "GL_ARB_texture_cube_map", NULL, "gl_texture_cubemap", GL_TEXTURE_CUBEMAP_EXT, 0 )) { pglGetIntegerv( GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, &glConfig.max_cubemap_size ); // check for seamless cubemaps too GL_CheckExtension( "GL_ARB_seamless_cube_map", NULL, "gl_texture_cubemap_seamless", GL_ARB_SEAMLESS_CUBEMAP, 0 ); } GL_CheckExtension( "GL_ARB_texture_non_power_of_two", NULL, "gl_texture_npot", GL_ARB_TEXTURE_NPOT_EXT, 0 ); GL_CheckExtension( "GL_ARB_texture_compression", texturecompressionfuncs, "gl_texture_dxt_compression", GL_TEXTURE_COMPRESSION_EXT, 0 ); if( !GL_CheckExtension( "GL_EXT_texture_edge_clamp", NULL, "gl_clamp_to_edge", GL_CLAMPTOEDGE_EXT, 2.0 )) // present in ES2 GL_CheckExtension( "GL_SGIS_texture_edge_clamp", NULL, "gl_clamp_to_edge", GL_CLAMPTOEDGE_EXT, 0 ); glConfig.max_texture_anisotropy = 0.0f; if( GL_CheckExtension( "GL_EXT_texture_filter_anisotropic", NULL, "gl_texture_anisotropic_filter", GL_ANISOTROPY_EXT, 0 )) pglGetFloatv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &glConfig.max_texture_anisotropy ); #if XASH_WIN32 // Win32 only drivers? // g-cont. because lodbias it too glitchy on Intel's cards if( glConfig.hardware_type != GLHW_INTEL ) #endif { if( GL_CheckExtension( "GL_EXT_texture_lod_bias", NULL, "gl_texture_mipmap_biasing", GL_TEXTURE_LOD_BIAS, 1.4 )) pglGetFloatv( GL_MAX_TEXTURE_LOD_BIAS_EXT, &glConfig.max_texture_lod_bias ); } GL_CheckExtension( "GL_ARB_texture_border_clamp", NULL, NULL, GL_CLAMP_TEXBORDER_EXT, 2.0 ); // present in ES2 GL_CheckExtension( "GL_ARB_depth_texture", NULL, NULL, GL_DEPTH_TEXTURE, 1.4 ); // missing in gles, check GL_OES_depth_texture GL_CheckExtension( "GL_ARB_texture_float", NULL, "gl_texture_float", GL_ARB_TEXTURE_FLOAT_EXT, 0 ); GL_CheckExtension( "GL_ARB_depth_buffer_float", NULL, "gl_texture_depth_float", GL_ARB_DEPTH_FLOAT_EXT, 0 ); GL_CheckExtension( "GL_EXT_gpu_shader4", NULL, NULL, GL_EXT_GPU_SHADER4, 0 ); // don't confuse users GL_CheckExtension( "GL_ARB_vertex_buffer_object", vbofuncs, "gl_vertex_buffer_object", GL_ARB_VERTEX_BUFFER_OBJECT_EXT, 2.0 ); GL_CheckExtension( "GL_ARB_texture_multisample", multisampletexfuncs, "gl_texture_multisample", GL_TEXTURE_MULTISAMPLE, 0 ); GL_CheckExtension( "GL_ARB_texture_compression_bptc", NULL, "gl_texture_bptc_compression", GL_ARB_TEXTURE_COMPRESSION_BPTC, 0 ); #ifndef XASH_GL_STATIC if( glConfig.context == CONTEXT_TYPE_GL_CORE ) GL_CheckExtension( "shader_objects", shaderobjectsfuncs_gles, "gl_shaderobjects", GL_SHADER_OBJECTS_EXT, 2.0 ); else GL_CheckExtension( "GL_ARB_shader_objects", shaderobjectsfuncs, "gl_shaderobjects", GL_SHADER_OBJECTS_EXT, 2.0 ); GL_CheckExtension( "GL_ARB_vertex_array_object", vaofuncs, "gl_vertex_array_object", GL_ARB_VERTEX_ARRAY_OBJECT_EXT, 3.0 ); GL_CheckExtension( "GL_ARB_buffer_storage", bufferstoragefuncs, "gl_buffer_storage", GL_BUFFER_STORAGE_EXT, 4.4); GL_CheckExtension( "GL_ARB_map_buffer_range", mapbufferrangefuncs, "gl_map_buffer_range", GL_MAP_BUFFER_RANGE_EXT , 3.0); GL_CheckExtension( "GL_ARB_draw_elements_base_vertex", drawrangeelementsbasevertexfuncs, "gl_drawrangeelementsbasevertex", GL_DRAW_RANGE_ELEMENTS_BASE_VERTEX_EXT, 3.2 ); #endif if( GL_CheckExtension( "GL_ARB_shading_language_100", NULL, NULL, GL_SHADER_GLSL100_EXT, 2.0 )) { pglGetIntegerv( GL_MAX_TEXTURE_COORDS_ARB, &glConfig.max_texture_coords ); pglGetIntegerv( GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &glConfig.max_teximage_units ); // 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 ); #if XASH_WIN32 // Win32 only drivers? if( glConfig.hardware_type == GLHW_RADEON && glConfig.max_vertex_uniforms > 512 ) glConfig.max_vertex_uniforms /= 4; // radeon returns not correct info #endif } else { // just get from multitexturing glConfig.max_texture_coords = glConfig.max_teximage_units = glConfig.max_texture_units; } // rectangle textures support GL_CheckExtension( "GL_ARB_texture_rectangle", NULL, "gl_texture_rectangle", GL_TEXTURE_2D_RECT_EXT, 0 ); if( !GL_CheckExtension( "glDrawRangeElements", drawrangeelementsfuncs, "gl_drawrangeelements", GL_DRAW_RANGEELEMENTS_EXT, 0 ) ) { if( GL_CheckExtension( "glDrawRangeElementsEXT", drawrangeelementsextfuncs, "gl_drawrangelements", GL_DRAW_RANGEELEMENTS_EXT, 0 )) { #ifndef XASH_GL_STATIC pglDrawRangeElements = pglDrawRangeElementsEXT; #endif } } // this won't work without extended context if( glw_state.extended ) GL_CheckExtension( "GL_ARB_debug_output", debugoutputfuncs, "gl_debug_output", GL_DEBUG_OUTPUT, 0 ); #if XASH_PSVITA // not all GL1.1 functions are implemented in vitaGL, but there's enough GL_SetExtension( GL_OPENGL_110, true ); // init our immediate mode override VGL_ShimInit(); #endif #if !defined(XASH_GLES) && !defined(XASH_GL_STATIC) if( gEngfuncs.Sys_CheckParm( "-gl2shim" )) GL2_ShimInit(); #endif } #endif void GL_InitExtensions( void ) { char value[MAX_VA_STRING]; GLint major = 0, minor = 0; GL_OnContextCreated(); // initialize gl extensions GL_CheckExtension( "OpenGL 1.1.0", opengl_110funcs, NULL, GL_OPENGL_110, 1.0 ); // 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 ); pglGetIntegerv( GL_MAJOR_VERSION, &major ); pglGetIntegerv( GL_MINOR_VERSION, &minor ); if( !major && glConfig.version_string ) { const char *str = glConfig.version_string; float ver; while( *str && ( *str < '0' || *str > '9' )) str++; ver = Q_atof(str); if( ver ) { glConfig.version_major = ver; glConfig.version_minor = (int)(ver * 10) % 10; } } else { glConfig.version_major = major; glConfig.version_minor = minor; } #ifndef XASH_GL_STATIC if( !glConfig.extensions_string ) { int n = 0; pglGetStringi = gEngfuncs.GL_GetProcAddress( "glGetStringi" ); pglGetIntegerv( GL_NUM_EXTENSIONS, &n ); if( n && pglGetStringi ) { int i, len = 1; char *str; for( i = 0; i < n; i++ ) len += Q_strlen((const char *)pglGetStringi( GL_EXTENSIONS, i )) + 1; str = (char*)Mem_Calloc( r_temppool, len ); glConfig.extensions_string = str; for( i = 0; i < n; i++ ) { int l = Q_strncpy( str, pglGetStringi( GL_EXTENSIONS, i ), len ); str += l; *str++ = ' '; len -= l + 1; } } } #endif gEngfuncs.Con_Reportf( "^3Video^7: %s\n", glConfig.renderer_string ); #ifdef XASH_GLES GL_InitExtensionsGLES(); #else GL_InitExtensionsBigGL(); #endif pglGetIntegerv( GL_MAX_TEXTURE_SIZE, &glConfig.max_2d_texture_size ); if( glConfig.max_2d_texture_size <= 0 ) glConfig.max_2d_texture_size = 256; #ifndef XASH_GL4ES // enable gldebug if allowed if( GL_Support( GL_DEBUG_OUTPUT )) { if( gpGlobals->developer ) { gEngfuncs.Con_Reportf( "Installing GL_DebugOutput...\n"); pglDebugMessageCallbackARB( GL_DebugOutput, NULL ); // force everything to happen in the main thread instead of in a separate driver thread pglEnable( GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB ); } // enable all the low priority messages pglDebugMessageControlARB( GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_LOW_ARB, 0, NULL, true ); } #endif if( GL_Support( GL_TEXTURE_2D_RECT_EXT )) pglGetIntegerv( GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT, &glConfig.max_2d_rectangle_size ); Q_snprintf( value, sizeof( value ), "%i", glConfig.max_2d_texture_size ); gEngfuncs.Cvar_Get( "gl_max_size", value, 0, "opengl texture max dims" ); gEngfuncs.Cvar_SetValue( "gl_anisotropy", bound( 0, gl_texture_anisotropy.value, glConfig.max_texture_anisotropy )); if( GL_Support( GL_TEXTURE_COMPRESSION_EXT )) gEngfuncs.Image_AddCmdFlags( IL_DDS_HARDWARE ); // MCD has buffering issues #if XASH_WIN32 if( Q_strstr( glConfig.renderer_string, "gdi" )) gEngfuncs.Cvar_SetValue( "gl_finish", 1 ); #endif R_RenderInfo_f(); tr.framecount = tr.visframecount = 1; glw_state.initialized = true; } void GL_ClearExtensions( void ) { // now all extensions are disabled memset( glConfig.extension, 0, sizeof( glConfig.extension )); glw_state.initialized = false; #if XASH_PSVITA // deinit our immediate mode override VGL_ShimShutdown(); #endif } //======================================================================= /* ================= GL_InitCommands ================= */ static void GL_InitCommands( void ) { RETRIEVE_ENGINE_SHARED_CVAR_LIST(); gEngfuncs.Cvar_RegisterVariable( &r_lighting_extended ); gEngfuncs.Cvar_RegisterVariable( &r_lighting_ambient ); gEngfuncs.Cvar_RegisterVariable( &r_novis ); gEngfuncs.Cvar_RegisterVariable( &r_nocull ); gEngfuncs.Cvar_RegisterVariable( &r_detailtextures ); gEngfuncs.Cvar_RegisterVariable( &r_lockpvs ); gEngfuncs.Cvar_RegisterVariable( &r_lockfrustum ); gEngfuncs.Cvar_RegisterVariable( &r_traceglow ); gEngfuncs.Cvar_RegisterVariable( &r_studio_sort_textures ); gEngfuncs.Cvar_RegisterVariable( &r_studio_drawelements ); gEngfuncs.Cvar_RegisterVariable( &r_ripple ); gEngfuncs.Cvar_RegisterVariable( &r_ripple_updatetime ); gEngfuncs.Cvar_RegisterVariable( &r_ripple_spawntime ); gEngfuncs.Cvar_RegisterVariable( &gl_extensions ); gEngfuncs.Cvar_RegisterVariable( &gl_texture_nearest ); gEngfuncs.Cvar_RegisterVariable( &gl_lightmap_nearest ); gEngfuncs.Cvar_RegisterVariable( &gl_check_errors ); gEngfuncs.Cvar_RegisterVariable( &gl_texture_anisotropy ); gEngfuncs.Cvar_RegisterVariable( &gl_texture_lodbias ); gEngfuncs.Cvar_RegisterVariable( &gl_keeptjunctions ); gEngfuncs.Cvar_RegisterVariable( &gl_finish ); gEngfuncs.Cvar_RegisterVariable( &gl_nosort ); gEngfuncs.Cvar_RegisterVariable( &gl_test ); gEngfuncs.Cvar_RegisterVariable( &gl_wireframe ); gEngfuncs.Cvar_RegisterVariable( &gl_msaa ); gEngfuncs.Cvar_RegisterVariable( &gl_stencilbits ); gEngfuncs.Cvar_RegisterVariable( &gl_round_down ); gEngfuncs.Cvar_RegisterVariable( &gl_overbright ); // these cvar not used by engine but some mods requires this gEngfuncs.Cvar_RegisterVariable( &gl_polyoffset ); // make sure gl_vsync is checked after vid_restart SetBits( gl_vsync->flags, FCVAR_CHANGED ); gEngfuncs.Cmd_AddCommand( "r_info", R_RenderInfo_f, "display renderer info" ); gEngfuncs.Cmd_AddCommand( "timerefresh", SCR_TimeRefresh_f, "turn quickly and print rendering statistcs" ); } /* =============== R_CheckVBO register VBO cvars and get default value =============== */ static void R_CheckVBO( void ) { qboolean disable = false; // some bad GLES1 implementations breaks dlights completely if( glConfig.max_texture_units < 3 ) disable = true; #ifdef XASH_MOBILE_PLATFORM // VideoCore4 drivers have a problem with mixing VBO and client arrays // Disable it, as there is no suitable workaround here if( Q_stristr( glConfig.renderer_string, "VideoCore IV" ) || Q_stristr( glConfig.renderer_string, "vc4" ) ) disable = true; #endif if( disable ) { r_vbo.flags = r_vbo_dlightmode.flags = 0; r_vbo.string = "0"; r_vbo_dlightmode.string = "0"; } gEngfuncs.Cvar_RegisterVariable( &r_vbo ); gEngfuncs.Cvar_RegisterVariable( &r_vbo_dlightmode ); gEngfuncs.Cvar_RegisterVariable( &r_vbo_overbrightmode ); gEngfuncs.Cvar_RegisterVariable( &r_vbo_detail ); } /* ================= GL_RemoveCommands ================= */ static void GL_RemoveCommands( void ) { gEngfuncs.Cmd_RemoveCommand( "r_info" ); } /* =============== R_Init =============== */ qboolean R_Init( void ) { if( glw_state.initialized ) return true; GL_InitCommands(); GL_InitRandomTable(); GL_SetDefaultState(); r_temppool = Mem_AllocPool( "Render Zone" ); // create the window and set up the context if( !gEngfuncs.R_Init_Video( REF_GL )) // request GL context { GL_RemoveCommands(); gEngfuncs.R_Free_Video(); // Why? Host_Error again??? // gEngfuncs.Host_Error( "Can't initialize video subsystem\nProbably driver was not installed" ); Mem_FreePool( &r_temppool ); return false; } // see R_ProcessEntData for tr.entities initialization tr.world = (struct world_static_s *)ENGINE_GET_PARM( PARM_GET_WORLD_PTR ); tr.movevars = (movevars_t *)ENGINE_GET_PARM( PARM_GET_MOVEVARS_PTR ); tr.palette = (color24 *)ENGINE_GET_PARM( PARM_GET_PALETTE_PTR ); tr.viewent = (cl_entity_t *)ENGINE_GET_PARM( PARM_GET_VIEWENT_PTR ); GL_SetDefaults(); R_CheckVBO(); R_InitImages(); R_SpriteInit(); R_StudioInit(); R_AliasInit(); R_ClearDecals(); R_ClearScene(); return true; } /* =============== R_Shutdown =============== */ void R_Shutdown( void ) { if( !glw_state.initialized ) return; GL_RemoveCommands(); R_ShutdownImages(); #if !defined(XASH_GLES) && !defined(XASH_GL_STATIC) GL2_ShimShutdown(); #endif Mem_FreePool( &r_temppool ); #ifdef XASH_GL4ES close_gl4es(); #endif // XASH_GL4ES // shut down OS specific OpenGL stuff like contexts, etc. gEngfuncs.R_Free_Video(); } /* ================= GL_ErrorString convert errorcode to string ================= */ const char *GL_ErrorString( int err ) { switch( err ) { case GL_STACK_OVERFLOW: return "GL_STACK_OVERFLOW"; case GL_STACK_UNDERFLOW: return "GL_STACK_UNDERFLOW"; case GL_INVALID_ENUM: return "GL_INVALID_ENUM"; case GL_INVALID_VALUE: return "GL_INVALID_VALUE"; case GL_INVALID_OPERATION: return "GL_INVALID_OPERATION"; case GL_OUT_OF_MEMORY: return "GL_OUT_OF_MEMORY"; default: return "UNKNOWN ERROR"; } } /* ================= GL_CheckForErrors obsolete ================= */ void GL_CheckForErrors_( const char *filename, const int fileline ) { int err; if( !gl_check_errors.value ) return; if(( err = pglGetError( )) == GL_NO_ERROR ) return; gEngfuncs.Con_Printf( S_OPENGL_ERROR "%s (at %s:%i)\n", GL_ErrorString( err ), filename, fileline ); } void GL_SetupAttributes( int safegl ) { int context_flags = 0; // REFTODO!!!!! int samples = 0; #ifdef XASH_GLES gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_PROFILE_MASK, REF_GL_CONTEXT_PROFILE_ES ); gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_EGL, 1 ); #ifdef XASH_NANOGL gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_MAJOR_VERSION, 1 ); gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_MINOR_VERSION, 1 ); #else gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_MAJOR_VERSION, 2 ); gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_MINOR_VERSION, 0 ); #endif #elif defined XASH_GL4ES gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_PROFILE_MASK, REF_GL_CONTEXT_PROFILE_ES ); gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_EGL, 1 ); gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_MAJOR_VERSION, 2 ); gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_MINOR_VERSION, 0 ); #else // GL1.x if( gEngfuncs.Sys_CheckParm( "-glcore" )) { SetBits( context_flags, FCONTEXT_CORE_PROFILE ); gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_PROFILE_MASK, REF_GL_CONTEXT_PROFILE_CORE ); gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_MAJOR_VERSION, 3 ); gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_MINOR_VERSION, 3 ); } else { if( !safegl ) gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_PROFILE_MASK, REF_GL_CONTEXT_PROFILE_COMPATIBILITY ); else { gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_MAJOR_VERSION, 1 ); gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_MINOR_VERSION, 1 ); } } #endif // XASH_GLES if( gEngfuncs.Sys_CheckParm( "-gldebug" )) { gEngfuncs.Con_Reportf( "Creating an extended GL context for debug...\n" ); SetBits( context_flags, FCONTEXT_DEBUG_ARB ); gEngfuncs.GL_SetAttribute( REF_GL_CONTEXT_FLAGS, REF_GL_CONTEXT_DEBUG_FLAG ); glw_state.extended = true; } if( safegl > SAFE_DONTCARE ) { safegl = -1; // can't retry anymore, can only shutdown engine return; } gEngfuncs.Con_Printf( "Trying safe opengl mode %d\n", safegl ); if( safegl == SAFE_DONTCARE ) return; gEngfuncs.GL_SetAttribute( REF_GL_DOUBLEBUFFER, 1 ); if( safegl < SAFE_NOACC ) gEngfuncs.GL_SetAttribute( REF_GL_ACCELERATED_VISUAL, 1 ); gEngfuncs.Con_Printf( "bpp %d\n", gpGlobals->desktopBitsPixel ); if( safegl < SAFE_NOSTENCIL ) gEngfuncs.GL_SetAttribute( REF_GL_STENCIL_SIZE, gl_stencilbits.value ); if( safegl < SAFE_NOALPHA ) gEngfuncs.GL_SetAttribute( REF_GL_ALPHA_SIZE, 8 ); if( safegl < SAFE_NODEPTH ) gEngfuncs.GL_SetAttribute( REF_GL_DEPTH_SIZE, 24 ); else gEngfuncs.GL_SetAttribute( REF_GL_DEPTH_SIZE, 8 ); if( safegl < SAFE_NOCOLOR ) { if( gpGlobals->desktopBitsPixel >= 24 ) { gEngfuncs.GL_SetAttribute( REF_GL_RED_SIZE, 8 ); gEngfuncs.GL_SetAttribute( REF_GL_GREEN_SIZE, 8 ); gEngfuncs.GL_SetAttribute( REF_GL_BLUE_SIZE, 8 ); } else if( gpGlobals->desktopBitsPixel >= 16 ) { gEngfuncs.GL_SetAttribute( REF_GL_RED_SIZE, 5 ); gEngfuncs.GL_SetAttribute( REF_GL_GREEN_SIZE, 6 ); gEngfuncs.GL_SetAttribute( REF_GL_BLUE_SIZE, 5 ); } else { gEngfuncs.GL_SetAttribute( REF_GL_RED_SIZE, 3 ); gEngfuncs.GL_SetAttribute( REF_GL_GREEN_SIZE, 3 ); gEngfuncs.GL_SetAttribute( REF_GL_BLUE_SIZE, 2 ); } } if( safegl < SAFE_NOMSAA ) { switch( (int)gEngfuncs.pfnGetCvarFloat( "gl_msaa_samples" )) { case 2: case 4: case 8: case 16: samples = gEngfuncs.pfnGetCvarFloat( "gl_msaa_samples" ); break; default: samples = 0; // don't use, because invalid parameter is passed } if( samples ) { gEngfuncs.GL_SetAttribute( REF_GL_MULTISAMPLEBUFFERS, 1 ); gEngfuncs.GL_SetAttribute( REF_GL_MULTISAMPLESAMPLES, samples ); glConfig.max_multisamples = samples; } else { gEngfuncs.GL_SetAttribute( REF_GL_MULTISAMPLEBUFFERS, 0 ); gEngfuncs.GL_SetAttribute( REF_GL_MULTISAMPLESAMPLES, 0 ); glConfig.max_multisamples = 0; } } else { gEngfuncs.Cvar_Set( "gl_msaa_samples", "0" ); } } void wes_init( const char *gles2 ); int nanoGL_Init( void ); #ifdef XASH_GL4ES static void GL4ES_GetMainFBSize( int *width, int *height ) { *width = gpGlobals->width; *height = gpGlobals->height; } static void *GL4ES_GetProcAddress( const char *name ) { if( !Q_strcmp(name, "glShadeModel") ) // combined gles/gles2/gl implementation exports this, but it is invalid return NULL; return gEngfuncs.GL_GetProcAddress( name ); } #endif void GL_OnContextCreated( void ) { int colorBits[3]; #ifdef XASH_NANOGL nanoGL_Init(); #endif gEngfuncs.GL_GetAttribute( REF_GL_RED_SIZE, &colorBits[0] ); gEngfuncs.GL_GetAttribute( REF_GL_GREEN_SIZE, &colorBits[1] ); gEngfuncs.GL_GetAttribute( REF_GL_BLUE_SIZE, &colorBits[2] ); glConfig.color_bits = colorBits[0] + colorBits[1] + colorBits[2]; gEngfuncs.GL_GetAttribute( REF_GL_ALPHA_SIZE, &glConfig.alpha_bits ); gEngfuncs.GL_GetAttribute( REF_GL_DEPTH_SIZE, &glConfig.depth_bits ); gEngfuncs.GL_GetAttribute( REF_GL_STENCIL_SIZE, &glConfig.stencil_bits ); glState.stencilEnabled = glConfig.stencil_bits ? true : false; gEngfuncs.GL_GetAttribute( REF_GL_MULTISAMPLESAMPLES, &glConfig.msaasamples ); gEngfuncs.GL_GetAttribute( REF_GL_CONTEXT_MAJOR_VERSION, &glConfig.version_major ); gEngfuncs.GL_GetAttribute( REF_GL_CONTEXT_MINOR_VERSION, &glConfig.version_minor ); #ifdef XASH_WES wes_init( "" ); #endif #ifdef XASH_GL4ES set_getprocaddress( GL4ES_GetProcAddress ); set_getmainfbsize( GL4ES_GetMainFBSize ); initialize_gl4es(); // merge glBegin/glEnd in beams and console pglHint( GL_BEGINEND_HINT_GL4ES, 1 ); // dxt unpacked to 16-bit looks ugly pglHint( GL_AVOID16BITS_HINT_GL4ES, 1 ); #endif }