summaryrefslogtreecommitdiff
path: root/src/sdl/sdl_glimp.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/sdl/sdl_glimp.cpp')
-rw-r--r--src/sdl/sdl_glimp.cpp935
1 files changed, 935 insertions, 0 deletions
diff --git a/src/sdl/sdl_glimp.cpp b/src/sdl/sdl_glimp.cpp
new file mode 100644
index 0000000..9ecd224
--- /dev/null
+++ b/src/sdl/sdl_glimp.cpp
@@ -0,0 +1,935 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2013 Darklegion Development
+Copyright (C) 2015-2019 GrangerHub
+
+This file is part of Tremulous.
+
+Tremulous 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.
+
+Tremulous 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 Tremulous; if not, see <https://www.gnu.org/licenses/>
+
+===========================================================================
+*/
+
+#ifdef USE_LOCAL_HEADERS
+# include "SDL.h"
+#else
+# include <SDL.h>
+#endif
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#include "renderercommon/tr_common.h"
+#include "qcommon/cvar.h"
+#include "sys/sys_local.h"
+#include "sdl_icon.h"
+
+typedef enum
+{
+ RSERR_OK,
+
+ RSERR_INVALID_FULLSCREEN,
+ RSERR_INVALID_MODE,
+
+ RSERR_UNKNOWN
+} rserr_t;
+
+SDL_Window *SDL_window = NULL;
+static SDL_GLContext SDL_glContext = NULL;
+
+cvar_t *r_allowSoftwareGL; // Don't abort out if a hardware visual can't be obtained
+cvar_t *r_allowResize; // make window resizable
+cvar_t *r_centerWindow;
+cvar_t *r_sdlDriver;
+
+void (APIENTRYP qglActiveTextureARB) (GLenum texture);
+void (APIENTRYP qglClientActiveTextureARB) (GLenum texture);
+void (APIENTRYP qglMultiTexCoord2fARB) (GLenum target, GLfloat s, GLfloat t);
+
+void (APIENTRYP qglLockArraysEXT) (GLint first, GLsizei count);
+void (APIENTRYP qglUnlockArraysEXT) (void);
+
+/*
+===============
+GLimp_Shutdown
+===============
+*/
+void GLimp_Shutdown( void )
+{
+ float oldDisplayAspect = glConfig.displayAspect;
+
+ ri.IN_Shutdown();
+
+ SDL_QuitSubSystem( SDL_INIT_VIDEO );
+
+ glConfig.displayAspect = oldDisplayAspect;
+}
+
+/*
+===============
+GLimp_Minimize
+
+Minimize the game so that user is back at the desktop
+===============
+*/
+void GLimp_Minimize( void )
+{
+ SDL_MinimizeWindow( SDL_window );
+}
+
+
+/*
+===============
+GLimp_LogComment
+===============
+*/
+void GLimp_LogComment( const char *comment )
+{
+}
+
+/*
+===============
+GLimp_CompareModes
+===============
+*/
+static int GLimp_CompareModes( const void *a, const void *b )
+{
+ const float ASPECT_EPSILON = 0.001f;
+ SDL_Rect *modeA = (SDL_Rect *)a;
+ SDL_Rect *modeB = (SDL_Rect *)b;
+ float aspectA = (float)modeA->w / (float)modeA->h;
+ float aspectB = (float)modeB->w / (float)modeB->h;
+ int areaA = modeA->w * modeA->h;
+ int areaB = modeB->w * modeB->h;
+ float aspectDiffA = fabs( aspectA - glConfig.displayAspect );
+ float aspectDiffB = fabs( aspectB - glConfig.displayAspect );
+ float aspectDiffsDiff = aspectDiffA - aspectDiffB;
+
+ if( aspectDiffsDiff > ASPECT_EPSILON )
+ return 1;
+ else if( aspectDiffsDiff < -ASPECT_EPSILON )
+ return -1;
+ else
+ return areaA - areaB;
+}
+
+
+/*
+===============
+GLimp_DetectAvailableModes
+===============
+*/
+static void GLimp_DetectAvailableModes(void)
+{
+ int i, j;
+ char buf[ MAX_STRING_CHARS ] = { 0 };
+ int numSDLModes;
+ SDL_Rect *modes;
+ int numModes = 0;
+
+ SDL_DisplayMode windowMode;
+ int display = SDL_GetWindowDisplayIndex( SDL_window );
+ if( display < 0 )
+ {
+ ri.Printf( PRINT_WARNING, "Couldn't get window display index, no resolutions detected: %s\n", SDL_GetError() );
+ return;
+ }
+ numSDLModes = SDL_GetNumDisplayModes( display );
+
+ if( SDL_GetWindowDisplayMode( SDL_window, &windowMode ) < 0 || numSDLModes <= 0 )
+ {
+ ri.Printf( PRINT_WARNING, "Couldn't get window display mode, no resolutions detected: %s\n", SDL_GetError() );
+ return;
+ }
+
+ modes = (SDL_Rect*)SDL_calloc( (size_t)numSDLModes, sizeof( SDL_Rect ) );
+ if ( !modes )
+ {
+ ri.Error( ERR_FATAL, "Out of memory" );
+ }
+
+ for( i = 0; i < numSDLModes; i++ )
+ {
+ SDL_DisplayMode mode;
+
+ if( SDL_GetDisplayMode( display, i, &mode ) < 0 )
+ continue;
+
+ if( !mode.w || !mode.h )
+ {
+ ri.Printf( PRINT_ALL, "Display supports any resolution\n" );
+ SDL_free( modes );
+ return;
+ }
+
+ if( windowMode.format != mode.format )
+ continue;
+
+ // SDL can give the same resolution with different refresh rates.
+ // Only list resolution once.
+ for( j = 0; j < numModes; j++ )
+ {
+ if( mode.w == modes[ j ].w && mode.h == modes[ j ].h )
+ break;
+ }
+
+ if( j != numModes )
+ continue;
+
+ modes[ numModes ].w = mode.w;
+ modes[ numModes ].h = mode.h;
+ numModes++;
+ }
+
+ if( numModes > 1 )
+ qsort( modes, numModes, sizeof( SDL_Rect ), GLimp_CompareModes );
+
+ for( i = 0; i < numModes; i++ )
+ {
+ const char *newModeString = va( "%ux%u ", modes[ i ].w, modes[ i ].h );
+
+ if( strlen( newModeString ) < (int)sizeof( buf ) - strlen( buf ) )
+ Q_strcat( buf, sizeof( buf ), newModeString );
+ else
+ ri.Printf( PRINT_WARNING, "Skipping mode %ux%u, buffer too small\n", modes[ i ].w, modes[ i ].h );
+ }
+
+ if( *buf )
+ {
+ buf[ strlen( buf ) - 1 ] = 0;
+ ri.Printf( PRINT_ALL, "Available modes: '%s'\n", buf );
+ ri.Cvar_Set( "r_availableModes", buf );
+ }
+ SDL_free( modes );
+}
+
+#define R_FAILSAFE_WIDTH 640
+#define R_FAILSAFE_HEIGHT 480
+
+/*
+===============
+GLimp_SetMode
+===============
+*/
+static int GLimp_SetMode( bool failSafe, bool fullscreen, bool noborder, bool coreContext )
+{
+ const char *glstring;
+ int perChannelColorBits;
+ int colorBits, alphaBits, depthBits, stencilBits;
+ int samples;
+ int i = 0;
+ SDL_Surface *icon = NULL;
+ Uint32 flags = SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL;
+ SDL_DisplayMode desktopMode;
+ int display = 0;
+ int x = SDL_WINDOWPOS_UNDEFINED, y = SDL_WINDOWPOS_UNDEFINED;
+
+ ri.Printf( PRINT_ALL, "Initializing OpenGL display\n");
+
+ if ( r_allowResize->integer )
+ flags |= SDL_WINDOW_RESIZABLE;
+
+#ifdef USE_ICON
+ icon = SDL_CreateRGBSurfaceFrom(
+ (void *)CLIENT_WINDOW_ICON.pixel_data,
+ CLIENT_WINDOW_ICON.width,
+ CLIENT_WINDOW_ICON.height,
+ CLIENT_WINDOW_ICON.bytes_per_pixel * 8,
+ CLIENT_WINDOW_ICON.bytes_per_pixel * CLIENT_WINDOW_ICON.width,
+#ifdef Q3_LITTLE_ENDIAN
+ 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000
+#else
+ 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
+#endif
+ );
+#endif
+
+ // If a window exists, note its display index
+ if( SDL_window != NULL )
+ {
+ display = SDL_GetWindowDisplayIndex( SDL_window );
+ if( display < 0 )
+ {
+ ri.Printf( PRINT_DEVELOPER, "SDL_GetWindowDisplayIndex() failed: %s\n", SDL_GetError() );
+ }
+ }
+
+ if( display >= 0 && SDL_GetDesktopDisplayMode( display, &desktopMode ) == 0 )
+ {
+ glConfig.displayAspect = (float)desktopMode.w / (float)desktopMode.h;
+
+ ri.Printf( PRINT_ALL, "Display aspect: %.3f\n", glConfig.displayAspect );
+ }
+ else
+ {
+ Com_Memset( &desktopMode, 0, sizeof( SDL_DisplayMode ) );
+
+ ri.Printf( PRINT_ALL,
+ "Cannot determine display aspect, assuming 1.333\n" );
+ }
+
+ if( !failSafe )
+ {
+ if( r_width->integer > 0 && r_height->integer > 0 )
+ {
+ glConfig.vidWidth = r_width->integer;
+ glConfig.vidHeight = r_height->integer;
+ }
+ else if( desktopMode.h > 0 )
+ {
+ // use desktop video resolution
+ glConfig.vidWidth = desktopMode.w;
+ glConfig.vidHeight = desktopMode.h;
+ }
+ else
+ {
+ glConfig.vidWidth = 640;
+ glConfig.vidHeight = 480;
+ ri.Printf( PRINT_ALL,
+ "Cannot determine display resolution, assuming 640x480\n" );
+ }
+
+ glConfig.windowAspect = (float)glConfig.vidWidth /
+ ( (float)glConfig.vidHeight * r_pixelAspect->value );
+ }
+ else if( glConfig.vidWidth != R_FAILSAFE_WIDTH &&
+ glConfig.vidHeight != R_FAILSAFE_HEIGHT )
+ {
+ ri.Printf( PRINT_ALL, "Setting mode %dx%d failed, falling back on mode %dx%d\n",
+ glConfig.vidWidth, glConfig.vidHeight, R_FAILSAFE_WIDTH, R_FAILSAFE_HEIGHT );
+
+ glConfig.vidWidth = R_FAILSAFE_WIDTH;
+ glConfig.vidHeight = R_FAILSAFE_HEIGHT;
+ glConfig.windowAspect = 1.0f;
+ }
+ else
+ return RSERR_INVALID_MODE;
+
+ ri.Printf (PRINT_ALL, "...setting mode %dx%d\n", glConfig.vidWidth, glConfig.vidHeight);
+
+ // Center window
+ if( r_centerWindow->integer && !fullscreen )
+ {
+ x = ( desktopMode.w / 2 ) - ( glConfig.vidWidth / 2 );
+ y = ( desktopMode.h / 2 ) - ( glConfig.vidHeight / 2 );
+ }
+
+ // Destroy existing state if it exists
+ if( SDL_glContext != NULL )
+ {
+ SDL_GL_DeleteContext( SDL_glContext );
+ SDL_glContext = NULL;
+ }
+
+ if( SDL_window != NULL )
+ {
+ SDL_GetWindowPosition( SDL_window, &x, &y );
+ ri.Printf( PRINT_DEVELOPER, "Existing window at %dx%d before being destroyed\n", x, y );
+ SDL_DestroyWindow( SDL_window );
+ SDL_window = NULL;
+ }
+
+ if( fullscreen )
+ {
+ flags |= SDL_WINDOW_FULLSCREEN;
+ glConfig.isFullscreen = qtrue;
+ }
+ else
+ {
+ if( noborder )
+ flags |= SDL_WINDOW_BORDERLESS;
+
+ glConfig.isFullscreen = qfalse;
+ }
+
+ colorBits = r_colorbits->value;
+ if ((!colorBits) || (colorBits >= 32))
+ colorBits = 24;
+
+ alphaBits = r_alphabits->value;
+
+ if (!r_depthbits->value)
+ depthBits = 24;
+ else
+ depthBits = r_depthbits->value;
+
+ stencilBits = r_stencilbits->value;
+ samples = r_ext_multisample->value;
+
+ for (i = 0; i < 16; i++)
+ {
+ int testColorBits, testDepthBits, testStencilBits;
+
+ // 0 - default
+ // 1 - minus colorBits
+ // 2 - minus depthBits
+ // 3 - minus stencil
+ if ((i % 4) == 0 && i)
+ {
+ // one pass, reduce
+ switch (i / 4)
+ {
+ case 2 :
+ if (colorBits == 24)
+ colorBits = 16;
+ break;
+ case 1 :
+ if (depthBits == 24)
+ depthBits = 16;
+ else if (depthBits == 16)
+ depthBits = 8;
+ case 3 :
+ if (stencilBits == 24)
+ stencilBits = 16;
+ else if (stencilBits == 16)
+ stencilBits = 8;
+ }
+ }
+
+ testColorBits = colorBits;
+ testDepthBits = depthBits;
+ testStencilBits = stencilBits;
+
+ if ((i % 4) == 3)
+ { // reduce colorBits
+ if (testColorBits == 24)
+ testColorBits = 16;
+ }
+
+ if ((i % 4) == 2)
+ { // reduce depthBits
+ if (testDepthBits == 24)
+ testDepthBits = 16;
+ else if (testDepthBits == 16)
+ testDepthBits = 8;
+ }
+
+ if ((i % 4) == 1)
+ { // reduce stencilBits
+ if (testStencilBits == 24)
+ testStencilBits = 16;
+ else if (testStencilBits == 16)
+ testStencilBits = 8;
+ else
+ testStencilBits = 0;
+ }
+
+ if (testColorBits == 24)
+ perChannelColorBits = 8;
+ else
+ perChannelColorBits = 4;
+
+#ifdef __sgi /* Fix for SGIs grabbing too many bits of color */
+ if (perChannelColorBits == 4)
+ perChannelColorBits = 0; /* Use minimum size for 16-bit color */
+
+ /* Need alpha or else SGIs choose 36+ bit RGB mode */
+ if (alphaBits < 1)
+ alphaBits = 1;
+#endif
+
+ SDL_GL_SetAttribute( SDL_GL_RED_SIZE, perChannelColorBits );
+ SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, perChannelColorBits );
+ SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, perChannelColorBits );
+ SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, alphaBits );
+ SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, testDepthBits );
+ SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, testStencilBits );
+
+ SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, samples ? 1 : 0 );
+ SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, samples );
+
+ if(r_stereoEnabled->integer)
+ {
+ glConfig.stereoEnabled = qtrue;
+ SDL_GL_SetAttribute(SDL_GL_STEREO, 1);
+ }
+ else
+ {
+ glConfig.stereoEnabled = qfalse;
+ SDL_GL_SetAttribute(SDL_GL_STEREO, 0);
+ }
+
+ SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
+
+#if 0 // if multisampling is enabled on X11, this causes create window to fail.
+ // If not allowing software GL, demand accelerated
+ if( !r_allowSoftwareGL->integer )
+ SDL_GL_SetAttribute( SDL_GL_ACCELERATED_VISUAL, 1 );
+#endif
+
+ if( ( SDL_window = SDL_CreateWindow( CLIENT_WINDOW_TITLE, x, y,
+ glConfig.vidWidth, glConfig.vidHeight, flags ) ) == NULL )
+ {
+ ri.Printf( PRINT_DEVELOPER, "SDL_CreateWindow failed: %s\n", SDL_GetError( ) );
+ continue;
+ }
+
+ if( fullscreen )
+ {
+ SDL_DisplayMode mode;
+
+ switch( testColorBits )
+ {
+ case 16: mode.format = SDL_PIXELFORMAT_RGB565; break;
+ case 24: mode.format = SDL_PIXELFORMAT_RGB24; break;
+ default: ri.Printf( PRINT_DEVELOPER, "testColorBits is %d, can't fullscreen\n", testColorBits ); continue;
+ }
+
+ mode.w = glConfig.vidWidth;
+ mode.h = glConfig.vidHeight;
+ mode.refresh_rate = glConfig.displayFrequency = ri.Cvar_VariableIntegerValue( "r_displayRefresh" );
+ mode.driverdata = NULL;
+
+ if( SDL_SetWindowDisplayMode( SDL_window, &mode ) < 0 )
+ {
+ ri.Printf( PRINT_DEVELOPER, "SDL_SetWindowDisplayMode failed: %s\n", SDL_GetError( ) );
+ continue;
+ }
+ }
+
+ SDL_SetWindowIcon( SDL_window, icon );
+
+ if (coreContext)
+ {
+ int profileMask, majorVersion, minorVersion;
+ SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &profileMask);
+ SDL_GL_GetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, &majorVersion);
+ SDL_GL_GetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, &minorVersion);
+
+ ri.Printf(PRINT_ALL, "Trying to get an OpenGL 3.2 core context\n");
+ SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
+ SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
+ SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
+ if ((SDL_glContext = SDL_GL_CreateContext(SDL_window)) == NULL)
+ {
+ ri.Printf(PRINT_ALL, "SDL_GL_CreateContext failed: %s\n", SDL_GetError());
+ ri.Printf(PRINT_ALL, "Reverting to default context\n");
+
+ SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, profileMask);
+ SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, majorVersion);
+ SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, minorVersion);
+ }
+ else
+ {
+ ri.Printf(PRINT_ALL, "SDL_GL_CreateContext succeeded.\n");
+
+ const char *renderer = (const char*)qglGetString(GL_RENDERER);
+ if (renderer && (strstr(renderer, "Software Renderer") || strstr(renderer, "Software Rasterizer")))
+ {
+ ri.Printf(PRINT_ALL, "GL_RENDERER is %s, rejecting context\n", renderer);
+
+ SDL_GL_DeleteContext(SDL_glContext);
+ SDL_glContext = NULL;
+
+ SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, profileMask);
+ SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, majorVersion);
+ SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, minorVersion);
+ }
+ }
+ }
+ else
+ {
+ SDL_glContext = NULL;
+ }
+
+ if( !SDL_glContext && ( SDL_glContext = SDL_GL_CreateContext( SDL_window ) ) == NULL )
+ {
+ ri.Printf( PRINT_DEVELOPER, "SDL_GL_CreateContext failed: %s\n", SDL_GetError( ) );
+ continue;
+ }
+
+ qglClearColor( 0, 0, 0, 1 );
+ qglClear( GL_COLOR_BUFFER_BIT );
+ SDL_GL_SwapWindow( SDL_window );
+
+ if( SDL_GL_SetSwapInterval( r_swapInterval->integer ) == -1 )
+ {
+ ri.Printf( PRINT_DEVELOPER, "SDL_GL_SetSwapInterval failed: %s\n", SDL_GetError( ) );
+ }
+
+ glConfig.colorBits = testColorBits;
+ glConfig.depthBits = testDepthBits;
+ glConfig.stencilBits = testStencilBits;
+
+ ri.Printf( PRINT_ALL, "Using %d color bits, %d depth, %d stencil display.\n",
+ glConfig.colorBits, glConfig.depthBits, glConfig.stencilBits );
+ break;
+ }
+
+ SDL_FreeSurface( icon );
+
+ if( !SDL_window )
+ {
+ ri.Printf( PRINT_ALL, "Couldn't get a visual\n" );
+ return RSERR_INVALID_MODE;
+ }
+
+ GLimp_DetectAvailableModes();
+
+ glstring = (char *) qglGetString (GL_RENDERER);
+ ri.Printf( PRINT_ALL, "GL_RENDERER: %s\n", glstring );
+
+ return RSERR_OK;
+}
+
+/*
+===============
+GLimp_StartDriverAndSetMode
+===============
+*/
+static bool GLimp_StartDriverAndSetMode( bool failSafe, bool fullscreen, bool noborder, bool gl3Core )
+{
+ if (!SDL_WasInit(SDL_INIT_VIDEO))
+ {
+
+ if (SDL_Init(SDL_INIT_VIDEO) != 0)
+ {
+ ri.Printf( PRINT_ALL, "SDL_Init( SDL_INIT_VIDEO ) FAILED (%s)\n", SDL_GetError());
+ return false;
+ }
+
+ const char *driverName = SDL_GetCurrentVideoDriver( );
+ ri.Printf( PRINT_ALL, "SDL using driver \"%s\"\n", driverName );
+ ri.Cvar_Set( "r_sdlDriver", driverName );
+ }
+
+ if (fullscreen && ri.Cvar_VariableIntegerValue( "in_nograb" ) )
+ {
+ ri.Printf( PRINT_ALL, "Fullscreen not allowed with in_nograb 1\n");
+ ri.Cvar_Set( "r_fullscreen", "0" );
+ r_fullscreen->modified = qfalse;
+ fullscreen = false;
+ }
+
+ rserr_t err = (rserr_t)GLimp_SetMode( failSafe, fullscreen, noborder, gl3Core );
+
+ switch ( err )
+ {
+ case RSERR_INVALID_FULLSCREEN:
+ ri.Printf( PRINT_ALL, "...WARNING: fullscreen unavailable in this mode\n" );
+ return false;
+ case RSERR_INVALID_MODE:
+ ri.Printf( PRINT_ALL, "...WARNING: could not set the given mode\n" );
+ return false;
+ default:
+ break;
+ }
+
+ return true;
+}
+
+static bool GLimp_HaveExtension(const char *ext)
+{
+ const char *ptr = Q_stristr( glConfig.extensions_string, ext );
+ if (ptr == NULL)
+ return qfalse;
+ ptr += strlen(ext);
+ return ((*ptr == ' ') || (*ptr == '\0')); // verify it's complete string.
+}
+
+
+/*
+===============
+GLimp_InitExtensions
+===============
+*/
+static void GLimp_InitExtensions( void )
+{
+ if ( !r_allowExtensions->integer )
+ {
+ ri.Printf( PRINT_ALL, "* IGNORING OPENGL EXTENSIONS *\n" );
+ return;
+ }
+
+ ri.Printf( PRINT_ALL, "Initializing OpenGL extensions\n" );
+
+ glConfig.textureCompression = TC_NONE;
+
+ // GL_EXT_texture_compression_s3tc
+ if ( GLimp_HaveExtension( "GL_ARB_texture_compression" ) &&
+ GLimp_HaveExtension( "GL_EXT_texture_compression_s3tc" ) )
+ {
+ if ( r_ext_compressed_textures->value )
+ {
+ glConfig.textureCompression = TC_S3TC_ARB;
+ ri.Printf( PRINT_ALL, "...using GL_EXT_texture_compression_s3tc\n" );
+ }
+ else
+ {
+ ri.Printf( PRINT_ALL, "...ignoring GL_EXT_texture_compression_s3tc\n" );
+ }
+ }
+ else
+ {
+ ri.Printf( PRINT_ALL, "...GL_EXT_texture_compression_s3tc not found\n" );
+ }
+
+ // GL_S3_s3tc ... legacy extension before GL_EXT_texture_compression_s3tc.
+ if (glConfig.textureCompression == TC_NONE)
+ {
+ if ( GLimp_HaveExtension( "GL_S3_s3tc" ) )
+ {
+ if ( r_ext_compressed_textures->value )
+ {
+ glConfig.textureCompression = TC_S3TC;
+ ri.Printf( PRINT_ALL, "...using GL_S3_s3tc\n" );
+ }
+ else
+ {
+ ri.Printf( PRINT_ALL, "...ignoring GL_S3_s3tc\n" );
+ }
+ }
+ else
+ {
+ ri.Printf( PRINT_ALL, "...GL_S3_s3tc not found\n" );
+ }
+ }
+
+
+ // GL_EXT_texture_env_add
+ glConfig.textureEnvAddAvailable = qfalse;
+ if ( GLimp_HaveExtension( "GL_EXT_texture_env_add" ) )
+ {
+ if ( r_ext_texture_env_add->integer )
+ {
+ glConfig.textureEnvAddAvailable = qtrue;
+ ri.Printf( PRINT_ALL, "...using GL_EXT_texture_env_add\n" );
+ }
+ else
+ {
+ glConfig.textureEnvAddAvailable = qfalse;
+ ri.Printf( PRINT_ALL, "...ignoring GL_EXT_texture_env_add\n" );
+ }
+ }
+ else
+ {
+ ri.Printf( PRINT_ALL, "...GL_EXT_texture_env_add not found\n" );
+ }
+
+ // GL_ARB_multitexture
+ qglMultiTexCoord2fARB = NULL;
+ qglActiveTextureARB = NULL;
+ qglClientActiveTextureARB = NULL;
+ if ( GLimp_HaveExtension( "GL_ARB_multitexture" ) )
+ {
+ if ( r_ext_multitexture->value )
+ {
+ qglMultiTexCoord2fARB = (decltype(qglMultiTexCoord2fARB)) SDL_GL_GetProcAddress( "glMultiTexCoord2fARB" );
+ qglActiveTextureARB = (decltype(qglActiveTextureARB)) SDL_GL_GetProcAddress( "glActiveTextureARB" );
+ qglClientActiveTextureARB = (decltype(qglClientActiveTextureARB)) SDL_GL_GetProcAddress( "glClientActiveTextureARB" );
+
+ if ( qglActiveTextureARB )
+ {
+ GLint glint = 0;
+ qglGetIntegerv( GL_MAX_TEXTURE_UNITS_ARB, &glint );
+ glConfig.numTextureUnits = (int) glint;
+ if ( glConfig.numTextureUnits > 1 )
+ {
+ ri.Printf( PRINT_ALL, "...using GL_ARB_multitexture\n" );
+ }
+ else
+ {
+ qglMultiTexCoord2fARB = NULL;
+ qglActiveTextureARB = NULL;
+ qglClientActiveTextureARB = NULL;
+ ri.Printf( PRINT_ALL, "...not using GL_ARB_multitexture, < 2 texture units\n" );
+ }
+ }
+ }
+ else
+ {
+ ri.Printf( PRINT_ALL, "...ignoring GL_ARB_multitexture\n" );
+ }
+ }
+ else
+ {
+ ri.Printf( PRINT_ALL, "...GL_ARB_multitexture not found\n" );
+ }
+
+ // GL_EXT_compiled_vertex_array
+ if ( GLimp_HaveExtension( "GL_EXT_compiled_vertex_array" ) )
+ {
+ if ( r_ext_compiled_vertex_array->value )
+ {
+ ri.Printf( PRINT_ALL, "...using GL_EXT_compiled_vertex_array\n" );
+ qglLockArraysEXT = ( void ( APIENTRY * )( GLint, GLint ) ) SDL_GL_GetProcAddress( "glLockArraysEXT" );
+ qglUnlockArraysEXT = ( void ( APIENTRY * )( void ) ) SDL_GL_GetProcAddress( "glUnlockArraysEXT" );
+ if (!qglLockArraysEXT || !qglUnlockArraysEXT)
+ {
+ ri.Error (ERR_FATAL, "bad getprocaddress");
+ }
+ }
+ else
+ {
+ ri.Printf( PRINT_ALL, "...ignoring GL_EXT_compiled_vertex_array\n" );
+ }
+ }
+ else
+ {
+ ri.Printf( PRINT_ALL, "...GL_EXT_compiled_vertex_array not found\n" );
+ }
+
+ glConfig.textureFilterAnisotropic = qfalse;
+ if ( GLimp_HaveExtension( "GL_EXT_texture_filter_anisotropic" ) )
+ {
+ if ( r_ext_texture_filter_anisotropic->integer ) {
+ qglGetIntegerv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, (GLint *)&glConfig.maxAnisotropy );
+ if ( glConfig.maxAnisotropy <= 0 ) {
+ ri.Printf( PRINT_ALL, "...GL_EXT_texture_filter_anisotropic not properly supported!\n" );
+ glConfig.maxAnisotropy = 0;
+ }
+ else
+ {
+ ri.Printf( PRINT_ALL, "...using GL_EXT_texture_filter_anisotropic (max: %i)\n", glConfig.maxAnisotropy );
+ glConfig.textureFilterAnisotropic = qtrue;
+ }
+ }
+ else
+ {
+ ri.Printf( PRINT_ALL, "...ignoring GL_EXT_texture_filter_anisotropic\n" );
+ }
+ }
+ else
+ {
+ ri.Printf( PRINT_ALL, "...GL_EXT_texture_filter_anisotropic not found\n" );
+ }
+}
+
+/*
+===============
+GLimp_Init
+
+This routine is responsible for initializing the OS specific portions
+of OpenGL
+===============
+*/
+void GLimp_Init(bool coreContext)
+{
+ ri.Printf( PRINT_DEVELOPER, "Glimp_Init( )\n" );
+
+ r_allowSoftwareGL = ri.Cvar_Get( "r_allowSoftwareGL", "0", CVAR_LATCH );
+ r_sdlDriver = ri.Cvar_Get( "r_sdlDriver", "", CVAR_ROM );
+ r_allowResize = ri.Cvar_Get( "r_allowResize", "0", CVAR_ARCHIVE | CVAR_LATCH );
+ r_centerWindow = ri.Cvar_Get( "r_centerWindow", "0", CVAR_ARCHIVE | CVAR_LATCH );
+
+#ifndef DEBUG
+ if( ri.Cvar_VariableIntegerValue( "com_abnormalExit" ) )
+ {
+ ri.Cvar_Set( "r_width", va( "%d", R_FAILSAFE_WIDTH ) );
+ ri.Cvar_Set( "r_height", va( "%d", R_FAILSAFE_HEIGHT ) );
+ ri.Cvar_Set( "r_fullscreen", "0" );
+ ri.Cvar_Set( "r_centerWindow", "0" );
+ ri.Cvar_Set( "com_abnormalExit", "0" );
+ }
+#endif
+
+ ri.Sys_GLimpInit( );
+
+ // Create the window and set up the context
+ if( GLimp_StartDriverAndSetMode( false, r_fullscreen->integer, r_noborder->integer, coreContext ) )
+ goto success;
+
+ // Try again, this time in a platform specific "safe mode"
+ ri.Sys_GLimpSafeInit( );
+
+ if( GLimp_StartDriverAndSetMode( false, r_fullscreen->integer, false, coreContext ) )
+ goto success;
+
+ // Finally, try the default screen resolution
+ if( GLimp_StartDriverAndSetMode( true, r_fullscreen->integer, false, coreContext ) )
+ goto success;
+
+ // Nothing worked, give up
+ ri.Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem" );
+
+success:
+ // These values force the UI to disable driver selection
+ glConfig.driverType = GLDRV_ICD;
+ glConfig.hardwareType = GLHW_GENERIC;
+
+ // Only using SDL_SetWindowBrightness to determine if hardware gamma is supported
+ glConfig.deviceSupportsGamma = (qboolean)(!r_ignorehwgamma->integer && SDL_SetWindowBrightness( SDL_window, 1.0f ) >= 0);
+
+ // get our config strings
+ Q_strncpyz( glConfig.vendor_string, (char *) qglGetString (GL_VENDOR), sizeof( glConfig.vendor_string ) );
+ Q_strncpyz( glConfig.renderer_string, (char *) qglGetString (GL_RENDERER), sizeof( glConfig.renderer_string ) );
+ if (*glConfig.renderer_string && glConfig.renderer_string[strlen(glConfig.renderer_string) - 1] == '\n')
+ glConfig.renderer_string[strlen(glConfig.renderer_string) - 1] = 0;
+ Q_strncpyz( glConfig.version_string, (char *) qglGetString (GL_VERSION), sizeof( glConfig.version_string ) );
+ if (qglGetString(GL_EXTENSIONS))
+ Q_strncpyz( glConfig.extensions_string, (char *) qglGetString (GL_EXTENSIONS), sizeof( glConfig.extensions_string ) );
+ else
+ Q_strncpyz( glConfig.extensions_string, "Not available (core context, fixme)", sizeof( glConfig.extensions_string ) );
+
+ // initialize extensions
+ GLimp_InitExtensions( );
+
+ ri.Cvar_Get( "r_availableModes", "", CVAR_ROM );
+
+ // This depends on SDL_INIT_VIDEO, hence having it here
+ ri.IN_Init( SDL_window );
+}
+
+
+/*
+===============
+GLimp_EndFrame
+
+Responsible for doing a swapbuffers
+===============
+*/
+void GLimp_EndFrame( void )
+{
+ // don't flip if drawing to front buffer
+ if ( Q_stricmp( r_drawBuffer->string, "GL_FRONT" ) != 0 )
+ {
+ SDL_GL_SwapWindow( SDL_window );
+ }
+
+ if( r_fullscreen->modified )
+ {
+ int fullscreen;
+ bool needToToggle;
+ bool sdlToggled = false;
+
+ // Find out the current state
+ fullscreen = !!( SDL_GetWindowFlags( SDL_window ) & SDL_WINDOW_FULLSCREEN );
+
+ if( r_fullscreen->integer && ri.Cvar_VariableIntegerValue( "in_nograb" ) )
+ {
+ ri.Printf( PRINT_ALL, "Fullscreen not allowed with in_nograb 1\n");
+ ri.Cvar_Set( "r_fullscreen", "0" );
+ r_fullscreen->modified = false;
+ }
+
+ // Is the state we want different from the current state?
+ needToToggle = !!r_fullscreen->integer != fullscreen;
+
+ if( needToToggle )
+ {
+ sdlToggled = SDL_SetWindowFullscreen( SDL_window, r_fullscreen->integer ) >= 0;
+
+ // SDL_WM_ToggleFullScreen didn't work, so do it the slow way
+ if( !sdlToggled )
+ ri.Cmd_ExecuteText(EXEC_APPEND, "vid_restart\n");
+
+ ri.IN_Restart( );
+ }
+
+ r_fullscreen->modified = false;
+ }
+}
generated by cgit (git 2.34.1) at 2024-07-01 16:24:24 +0000