opengl.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include "SDL.h"
#include "SDL_error.h"
#include "SDL_image.h"
#include "physfsrwops.h"
 
#include "naev.h"
 
#include "opengl.h"
 
#include "conf.h"
#include "debug.h" // IWYU pragma: keep
#include "gltf.h"
#include "log.h"
#include "render.h"
 
glInfo gl_screen = {
   .window = NULL, /* Should be initialized to NULL as is used for cases of
                      SDL_ShowSimpleMessageBox. */
}; 
static int gl_activated = 0; 
 
static unsigned int cb_correct_pp =
   0; 
static unsigned int cb_simulate_pp =
   0; 
 
/*
 * Viewport offsets
 */
static int gl_view_x      = 0; /* X viewport offset. */
static int gl_view_y      = 0; /* Y viewport offset. */
static int gl_view_w      = 0; /* Viewport width. */
static int gl_view_h      = 0; /* Viewport height. */
mat4       gl_view_matrix = { { { { 0 } } } };
 
/*
 * prototypes
 */
/* gl */
static int gl_setupAttributes( int fallback );
static int gl_createWindow( unsigned int flags );
static int gl_getFullscreenMode( void );
static int gl_getGLInfo( void );
static int gl_defState( void );
static int gl_setupScaling( void );

static void gl_applyFixes( void )
{
#if __LINUX__
   // Set AMD_DEBUG environment variable before initializing OpenGL to
   // workaround driver bug.
   if ( setenv( "AMD_DEBUG", "nooptvariant", 1 ) != 0 ) {
      WARN( _( "Failed to set AMD_DEBUG environment variable" ) );
   } else {
      DEBUG( _( "Set AMD_DEBUG environment variable to 'nooptvariant'" ) );
   }
#endif
}
 
/*
 *
 * M I S C
 *
 */
void gl_screenshot( const char *filename )
{
   GLubyte     *screenbuf;
   SDL_RWops   *rw;
   SDL_Surface *surface;
   int          w, h;
 
   /* Allocate data. */
   w         = gl_screen.rw;
   h         = gl_screen.rh;
   screenbuf = malloc( sizeof( GLubyte ) * 3 * w * h );
   surface   = SDL_CreateRGBSurface( 0, w, h, 24, RGBAMASK );
 
   /* Read pixels from buffer -- SLOW. */
   glPixelStorei( GL_PACK_ALIGNMENT, 1 ); /* Force them to pack the bytes. */
   glReadPixels( 0, 0, w, h, GL_RGB, GL_UNSIGNED_BYTE, screenbuf );
 
   /* Convert data. */
   for ( int i = 0; i < h; i++ )
      memcpy( (GLubyte *)surface->pixels + i * surface->pitch,
              &screenbuf[( h - i - 1 ) * ( 3 * w )], 3 * w );
   free( screenbuf );
 
   /* Save PNG. */
   if ( !( rw = PHYSFSRWOPS_openWrite( filename ) ) )
      WARN( _( "Aborting screenshot" ) );
   else
      IMG_SavePNG_RW( surface, rw, 1 );
 
   /* Check to see if an error occurred. */
   gl_checkErr();
 
   /* Free memory. */
   SDL_FreeSurface( surface );
}
 
void gl_saveFboDepth( GLuint fbo, const char *filename )
{
   GLfloat     *screenbuf;
   SDL_Surface *s;
   int          w, h;
 
   /* Allocate data. */
   w         = gl_screen.rw; /* TODO get true size. */
   h         = gl_screen.rh;
   screenbuf = malloc( sizeof( GLfloat ) * 1 * w * h );
   s         = SDL_CreateRGBSurface( 0, w, h, 24, RGBAMASK );
 
   /* Read pixels from buffer -- SLOW. */
   glBindFramebuffer( GL_FRAMEBUFFER, fbo );
   GLint value;
   glGetFramebufferAttachmentParameteriv( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
                                          GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE,
                                          &value );
   if ( value != GL_TEXTURE ) {
      WARN( "Trying to save depth of FBO with no depth attachment!" );
      free( screenbuf );
      glBindFramebuffer( GL_FRAMEBUFFER, gl_screen.current_fbo );
      return;
   }
   glPixelStorei( GL_PACK_ALIGNMENT, 1 ); /* Force them to pack the bytes. */
   glReadPixels( 0, 0, w, h, GL_DEPTH_COMPONENT, GL_FLOAT, screenbuf );
   glBindFramebuffer( GL_FRAMEBUFFER, gl_screen.current_fbo );
 
   /* Check to see if an error occurred. */
   gl_checkErr();
 
   /* Convert data. */
   Uint8 *d = s->pixels;
   for ( int i = 0; i < h; i++ ) {
      for ( int j = 0; j < w; j++ ) {
         float f = screenbuf[( h - i - 1 ) * w + j];
         Uint8 v = f * 255.;
         for ( int k = 0; k < 3; k++ ) {
            d[i * s->pitch + j * s->format->BytesPerPixel + k] = v;
         }
      }
   }
   free( screenbuf );
 
   /* Save PNG. */
   IMG_SavePNG( s, filename );
 
   /* Free memory. */
   SDL_FreeSurface( s );
}
 
/*
 *
 * G L O B A L
 *
 */
GLboolean gl_hasVersion( int major, int minor )
{
   if ( GLVersion.major >= major && GLVersion.minor >= minor )
      return GL_TRUE;
   return GL_FALSE;
}
 
#ifdef DEBUGGING
int gl_checkHandleError( const char *func, int line )
{
   (void)func;
   (void)line;
#if !DEBUG_GL
   const char *errstr;
   GLenum      err = glGetError();
 
   /* No error. */
   if ( err == GL_NO_ERROR )
      return 0;
 
   switch ( err ) {
   case GL_INVALID_ENUM:
      errstr = _( "GL invalid enum" );
      break;
   case GL_INVALID_VALUE:
      errstr = _( "GL invalid value" );
      break;
   case GL_INVALID_OPERATION:
      errstr = _( "GL invalid operation" );
      break;
   case GL_INVALID_FRAMEBUFFER_OPERATION:
      errstr = _( "GL invalid framebuffer operation" );
      break;
   case GL_OUT_OF_MEMORY:
      errstr = _( "GL out of memory" );
      break;
 
   default:
      errstr = _( "GL unknown error" );
      break;
   }
   WARN( _( "OpenGL error [%s:%d]: %s" ), func, line, errstr );
   return 1;
#endif /* !DEBUG_GL */
   return 0;
}
 
#if DEBUG_GL
static void GLAPIENTRY gl_debugCallback( GLenum source, GLenum type, GLuint id,
                                         GLenum severity, GLsizei length,
                                         const GLchar *message, const void *p )
{
   static int errors_seen = 0;
   (void)source;
   (void)id;
   (void)length;
   (void)p;
   const char *typestr;
 
   if ( ++errors_seen == 10 )
      WARN( _( "Too many OpenGL diagnostics reported! Suppressing further "
               "reports." ) );
   if ( errors_seen >= 10 )
      return;
 
   switch ( type ) {
   case GL_DEBUG_TYPE_ERROR:
      typestr = " GL_DEBUG_TYPE_ERROR";
      break;
   case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR:
      typestr = " GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR";
      break;
   case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:
      typestr = " GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR";
      break;
   case GL_DEBUG_TYPE_PORTABILITY:
      typestr = " GL_DEBUG_TYPE_PORTABILITY";
      break;
   case GL_DEBUG_TYPE_PERFORMANCE:
      typestr = " GL_DEBUG_TYPE_PERFORMANCE";
      break;
   case GL_DEBUG_TYPE_OTHER:
      typestr = " GL_DEBUG_TYPE_OTHER";
      break;
   case GL_DEBUG_TYPE_MARKER:     /* fallthrough */
   case GL_DEBUG_TYPE_PUSH_GROUP: /* fallthrough */
   case GL_DEBUG_TYPE_POP_GROUP:  /* fallthrough */
      return;
   default:
      typestr = "";
   }
   WARN( _( "[type = 0x%x%s], severity = 0x%x, message = %s backtrace:" ), type,
         typestr, severity, message );
   debug_logBacktrace();
}
#endif /* DEBUG_GL */
#endif /* DEBUGGING */

static int gl_setupAttributes( int fallback )
{
   SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, fallback ? 3 : 4 );
   SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, fallback ? 2 : 6 );
   SDL_GL_SetAttribute( SDL_GL_CONTEXT_PROFILE_MASK,
                        SDL_GL_CONTEXT_PROFILE_CORE );
   SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER,
                        1 ); /* Ideally want double buffering. */
   if ( conf.fsaa > 1 ) {
      SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, 1 );
      SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, conf.fsaa );
   }
   SDL_GL_SetAttribute( SDL_GL_FRAMEBUFFER_SRGB_CAPABLE, 1 );
#if DEBUG_GL
   SDL_GL_SetAttribute( SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG );
#endif /* DEBUG_GL */
 
   return 0;
}

int gl_setupFullscreen( void )
{
   int ok;
   int display_index = SDL_GetWindowDisplayIndex( gl_screen.window );
   if ( conf.fullscreen && conf.modesetting ) {
      SDL_DisplayMode target, closest;
      /* Try to use desktop resolution if nothing is specifically set. */
      if ( conf.explicit_dim ) {
         SDL_GetWindowDisplayMode( gl_screen.window, &target );
         target.w = conf.width;
         target.h = conf.height;
      } else
         SDL_GetDesktopDisplayMode( display_index, &target );
 
      if ( SDL_GetClosestDisplayMode( display_index, &target, &closest ) ==
           NULL )
         SDL_GetDisplayMode( display_index, 0,
                             &closest ); /* fall back to the best one */
 
      SDL_SetWindowDisplayMode( gl_screen.window, &closest );
   }
   ok = SDL_SetWindowFullscreen( gl_screen.window, gl_getFullscreenMode() );
   /* HACK: Force pending resize events to be processed, particularly on
    * Wayland. */
   SDL_PumpEvents();
   SDL_GL_SwapWindow( gl_screen.window );
   SDL_GL_SwapWindow( gl_screen.window );
   return ok;
}

static int gl_getFullscreenMode( void )
{
   if ( conf.fullscreen )
      return conf.modesetting ? SDL_WINDOW_FULLSCREEN
                              : SDL_WINDOW_FULLSCREEN_DESKTOP;
   return 0;
}

static int gl_createWindow( unsigned int flags )
{
   flags |= SDL_WINDOW_ALLOW_HIGHDPI;
   if ( !conf.notresizable )
      flags |= SDL_WINDOW_RESIZABLE;
   if ( conf.borderless )
      flags |= SDL_WINDOW_BORDERLESS;
 
   /* Create the window. */
   gl_screen.window =
      SDL_CreateWindow( APPNAME, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
                        MAX( RESOLUTION_W_MIN, conf.width ),
                        MAX( RESOLUTION_H_MIN, conf.height ), flags );
   if ( gl_screen.window == NULL ) {
      char buf[STRMAX];
      snprintf( buf, sizeof( buf ), _( "Unable to create window! %s" ),
                SDL_GetError() );
#if SDL_VERSION_ATLEAST( 3, 0, 0 )
      SDL_ShowSimpleMessageBox( SDL_MESSAGEBOX_ERROR,
                                _( "Naev Critical Error" ), buf,
                                gl_screen.window );
#endif /* SDL_VERSION_ATLEAST( 3, 0, 0 ) */
      ERR( "%s", buf );
   }
 
   /* We want to enforce minimum window size or a ton of things break. */
   SDL_SetWindowMinimumSize( gl_screen.window, RESOLUTION_W_MIN,
                             RESOLUTION_H_MIN );
 
   /* Set focus loss behaviour. */
   SDL_SetHint( SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS,
                conf.minimize ? "1" : "0" );
 
   /* Create the OpenGL context, note we don't need an actual renderer. */
   for ( int fallback = 0; fallback <= 1; fallback++ ) {
      gl_setupAttributes( fallback );
      gl_screen.context = SDL_GL_CreateContext( gl_screen.window );
      if ( gl_screen.context != NULL )
         break;
   }
   if ( !gl_screen.context ) {
      char buf[STRMAX];
      snprintf( buf, sizeof( buf ), _( "Unable to create OpenGL context! %s" ),
                SDL_GetError() );
#if SDL_VERSION_ATLEAST( 3, 0, 0 )
      SDL_ShowSimpleMessageBox( SDL_MESSAGEBOX_ERROR,
                                _( "Naev Critical Error" ), buf,
                                gl_screen.window );
#endif /* SDL_VERSION_ATLEAST( 3, 0, 0 ) */
      ERR( "%s", buf );
   }
 
   /* Save and store version. */
   SDL_GL_GetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, &gl_screen.major );
   SDL_GL_GetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, &gl_screen.minor );
   if ( gl_screen.major * 100 + gl_screen.minor * 10 > 320 )
      gl_screen.glsl = 100 * gl_screen.major + 10 * gl_screen.minor;
   else
      gl_screen.glsl = 150;
 
   /* Set Vsync. */
   if ( conf.vsync ) {
      int ret = SDL_GL_SetSwapInterval( 1 );
      if ( ret == 0 )
         gl_screen.flags |= OPENGL_VSYNC;
   } else {
      SDL_GL_SetSwapInterval( 0 );
   }
 
   /* Finish getting attributes. */
   gl_screen.current_fbo = 0; /* No FBO set. */
   for ( int i = 0; i < OPENGL_NUM_FBOS; i++ ) {
      gl_screen.fbo[i]     = GL_INVALID_VALUE;
      gl_screen.fbo_tex[i] = GL_INVALID_VALUE;
   }
   SDL_GL_GetAttribute( SDL_GL_DEPTH_SIZE, &gl_screen.depth );
   int srgb_capable;
   SDL_GL_GetAttribute( SDL_GL_FRAMEBUFFER_SRGB_CAPABLE, &srgb_capable );
   if ( !srgb_capable )
      WARN( _( "Unable to set framebuffer to SRGB!" ) );
   gl_activated = 1; /* Opengl is now activated. */
 
   return 0;
}

static int gl_getGLInfo( void )
{
   int doublebuf;
   SDL_GL_GetAttribute( SDL_GL_RED_SIZE, &gl_screen.r );
   SDL_GL_GetAttribute( SDL_GL_GREEN_SIZE, &gl_screen.g );
   SDL_GL_GetAttribute( SDL_GL_BLUE_SIZE, &gl_screen.b );
   SDL_GL_GetAttribute( SDL_GL_ALPHA_SIZE, &gl_screen.a );
   SDL_GL_GetAttribute( SDL_GL_DOUBLEBUFFER, &doublebuf );
   SDL_GL_GetAttribute( SDL_GL_MULTISAMPLESAMPLES, &gl_screen.fsaa );
   if ( doublebuf )
      gl_screen.flags |= OPENGL_DOUBLEBUF;
   if ( GLAD_GL_ARB_shader_subroutine && glGetSubroutineIndex &&
        glGetSubroutineUniformLocation && glUniformSubroutinesuiv )
      gl_screen.flags |= OPENGL_SUBROUTINES;
   /* Calculate real depth. */
   gl_screen.depth = gl_screen.r + gl_screen.g + gl_screen.b + gl_screen.a;
 
   /* Texture information */
   glGetIntegerv( GL_MAX_TEXTURE_SIZE, &gl_screen.tex_max );
   glGetIntegerv( GL_MAX_TEXTURE_IMAGE_UNITS, &gl_screen.multitex_max );
 
   /* Debug happiness */
   DEBUG( _( "OpenGL Drawable Created: %dx%d@%dbpp" ), gl_screen.rw,
          gl_screen.rh, gl_screen.depth );
   DEBUG( _( "r: %d, g: %d, b: %d, a: %d, db: %s, fsaa: %d, tex: %d" ),
          gl_screen.r, gl_screen.g, gl_screen.b, gl_screen.a,
          gl_has( OPENGL_DOUBLEBUF ) ? _( "yes" ) : _( "no" ), gl_screen.fsaa,
          gl_screen.tex_max );
   DEBUG( _( "VSync: %s" ), gl_has( OPENGL_VSYNC ) ? _( "yes" ) : _( "no" ) );
   DEBUG( _( "Renderer: %s" ), glGetString( GL_RENDERER ) );
   DEBUG( _( "Vendor: %s" ), glGetString( GL_VENDOR ) );
   DEBUG( _( "Version: %s" ), glGetString( GL_VERSION ) );
 
   /* Now check for things that can be bad. */
   if ( ( conf.fsaa > 1 ) && ( gl_screen.fsaa != conf.fsaa ) )
      WARN( _( "Unable to get requested FSAA level (%d requested, got %d)" ),
            conf.fsaa, gl_screen.fsaa );
 
   return 0;
}

static int gl_defState( void )
{
   glDisable( GL_DEPTH_TEST ); /* set for doing 2d */
   glEnable( GL_BLEND );       /* alpha blending ftw */
   glEnable(
      GL_LINE_SMOOTH ); /* We use SDF shaders for most shapes, but star trails &
                           map routes are thin & anti-aliased. */
#if DEBUG_GL
   glEnable( GL_DEBUG_OUTPUT ); /* Log errors immediately.. */
   glDebugMessageCallback( gl_debugCallback, 0 );
   glDebugMessageControl( GL_DONT_CARE, GL_DEBUG_TYPE_PERFORMANCE, GL_DONT_CARE,
                          0, NULL, GL_FALSE );
   glDebugMessageControl( GL_DONT_CARE, GL_DEBUG_TYPE_OTHER, GL_DONT_CARE, 0,
                          NULL, GL_FALSE );
#endif /* DEBUG_GL */
 
   /* Set the blending/shading model to use. */
   glBlendEquation( GL_FUNC_ADD );
   glBlendFuncSeparate( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE,
                        GL_ONE_MINUS_SRC_ALPHA );
 
   return 0;
}

static int gl_setupScaling( void )
{
   /* Get the basic dimensions from SDL2. */
   SDL_GetWindowSize( gl_screen.window, &gl_screen.w, &gl_screen.h );
   SDL_GL_GetDrawableSize( gl_screen.window, &gl_screen.rw, &gl_screen.rh );
   /* Calculate scale factor, if OS has native HiDPI scaling. */
   gl_screen.dwscale = (double)gl_screen.w / (double)gl_screen.rw;
   gl_screen.dhscale = (double)gl_screen.h / (double)gl_screen.rh;
 
   /* Combine scale factor from OS with the one in Naev's config */
   gl_screen.scale =
      fmax( gl_screen.dwscale, gl_screen.dhscale ) / conf.scalefactor;
   glLineWidth( 1. / gl_screen.scale );
   glPointSize( 1. / gl_screen.scale + 2.0 );
 
   /* New window is real window scaled. */
   gl_screen.nw = (double)gl_screen.rw * gl_screen.scale;
   gl_screen.nh = (double)gl_screen.rh * gl_screen.scale;
   /* Small windows get handled here. */
   if ( ( gl_screen.nw < RESOLUTION_W_MIN ) ||
        ( gl_screen.nh < RESOLUTION_H_MIN ) ) {
      double scalew, scaleh;
      if ( gl_screen.scale != 1. )
         WARN( _( "Screen size too small, upscaling..." ) );
      scalew = RESOLUTION_W_MIN / (double)gl_screen.nw;
      scaleh = RESOLUTION_H_MIN / (double)gl_screen.nh;
      gl_screen.scale *= MAX( scalew, scaleh );
      /* Rescale. */
      gl_screen.nw = (double)gl_screen.rw * gl_screen.scale;
      gl_screen.nh = (double)gl_screen.rh * gl_screen.scale;
   }
   /* Viewport matches new window size. */
   gl_screen.w = gl_screen.nw;
   gl_screen.h = gl_screen.nh;
   /* Set scale factors. */
   gl_screen.wscale  = (double)gl_screen.nw / (double)gl_screen.w;
   gl_screen.hscale  = (double)gl_screen.nh / (double)gl_screen.h;
   gl_screen.mxscale = (double)gl_screen.w / (double)gl_screen.rw;
   gl_screen.myscale = (double)gl_screen.h / (double)gl_screen.rh;
 
   return 0;
}

int gl_init( unsigned int extra_flags )
{
   unsigned int flags;
   GLuint       VaoId;
 
   /* Apply driver hacks and workarounds before we initialize the window. */
   gl_applyFixes();
 
   /* Defaults. */
   memset( &gl_screen, 0, sizeof( gl_screen ) );
   SDL_SetHint( "SDL_WINDOWS_DPI_SCALING", "1" );
   flags = SDL_WINDOW_OPENGL | gl_getFullscreenMode() | extra_flags;
 
   /* Initializes Video */
   if ( SDL_InitSubSystem( SDL_INIT_VIDEO ) < 0 ) {
      WARN( _( "Unable to initialize SDL Video: %s" ), SDL_GetError() );
      return -1;
   }
 
   /* Create the window. */
   gl_createWindow( flags );
 
   /* Apply the configured fullscreen display mode, if any. */
   gl_setupFullscreen();
 
   /* Load extensions. */
   if ( !gladLoadGLLoader( SDL_GL_GetProcAddress ) ) {
      char buf[STRMAX];
      snprintf( buf, sizeof( buf ), _( "Unable to load OpenGL using GLAD!" ) );
#if SDL_VERSION_ATLEAST( 3, 0, 0 )
      SDL_ShowSimpleMessageBox( SDL_MESSAGEBOX_ERROR,
                                _( "Naev Critical Error" ), buf,
                                gl_screen.window );
#endif /* SDL_VERSION_ATLEAST( 3, 0, 0 ) */
      ERR( "%s", buf );
   }
 
   /* We are interested in 3.1 because it drops all the deprecated stuff. */
   if ( !GLAD_GL_VERSION_3_2 )
      WARN( "Naev requires OpenGL %d.%d, but got OpenGL %d.%d!", 3, 2,
            GLVersion.major, GLVersion.minor );
 
   /* Some OpenGL options. */
   glClearColor( 0., 0., 0., 0. );
 
   /* Set default opengl state. */
   gl_defState();
 
   /* Handles resetting the viewport and scaling, rw/rh are set in createWindow.
    */
   gl_resize();
 
   /* Finishing touches. */
   glClear( GL_COLOR_BUFFER_BIT |
            GL_DEPTH_BUFFER_BIT ); /* must clear the buffer first */
   gl_checkErr();
 
   /* Initialize subsystems.*/
   gl_initTextures();
   gl_initVBO();
   gl_initRender();
 
   /* Get info about the OpenGL window */
   gl_getGLInfo();
 
   /* Modern OpenGL requires at least one VAO */
   glGenVertexArrays( 1, &VaoId );
   glBindVertexArray( VaoId );
 
   shaders_load();
 
   /* Set colourblind shader if necessary. */
   gl_colourblind();
 
   /* Set colourspace. */
   glEnable( GL_FRAMEBUFFER_SRGB );
 
   /* Load the gltf framework. */
   gltf_init();
 
   /* Cosmetic new line. */
   DEBUG_BLANK();
 
   return 0;
}

void gl_resize( void )
{
   gl_setupScaling();
   glViewport( 0, 0, gl_screen.rw, gl_screen.rh );
   gl_setDefViewport( 0, 0, gl_screen.nw, gl_screen.nh );
   gl_defViewport();
 
   /* Set up framebuffer. */
   for ( int i = 0; i < OPENGL_NUM_FBOS; i++ ) {
      if ( gl_screen.fbo[i] != GL_INVALID_VALUE ) {
         glDeleteFramebuffers( 1, &gl_screen.fbo[i] );
         glDeleteTextures( 1, &gl_screen.fbo_tex[i] );
         glDeleteTextures( 1, &gl_screen.fbo_depth_tex[i] );
      }
      gl_fboCreate( &gl_screen.fbo[i], &gl_screen.fbo_tex[i], gl_screen.rw,
                    gl_screen.rh );
      gl_fboAddDepth( gl_screen.fbo[i], &gl_screen.fbo_depth_tex[i],
                      gl_screen.rw, gl_screen.rh );
   }
 
   gl_checkErr();
}

void gl_viewport( int x, int y, int w, int h )
{
   mat4 proj = mat4_ortho( 0.,           /* Left edge. */
                           gl_screen.nw, /* Right edge. */
                           0.,           /* Bottom edge. */
                           gl_screen.nh, /* Top edge. */
                           -1.,          /* near */
                           1. );         /* far */
 
   /* Take into account possible translation. */
   gl_screen.x = x;
   gl_screen.y = y;
   mat4_translate_xy( &proj, x, y );
 
   /* Set screen size. */
   gl_screen.w = w;
   gl_screen.h = h;
 
   /* Take into account possible scaling. */
   if ( gl_screen.scale != 1. )
      mat4_scale( &proj, gl_screen.wscale, gl_screen.hscale, 1. );
 
   gl_view_matrix = proj;
}

void gl_setDefViewport( int x, int y, int w, int h )
{
   gl_view_x = x;
   gl_view_y = y;
   gl_view_w = w;
   gl_view_h = h;
}

void gl_defViewport( void )
{
   gl_viewport( gl_view_x, gl_view_y, gl_view_w, gl_view_h );
}

void gl_windowToScreenPos( int *sx, int *sy, int wx, int wy )
{
   wx /= gl_screen.dwscale;
   wy /= gl_screen.dhscale;
 
   *sx = gl_screen.mxscale * (double)wx - (double)gl_screen.x;
   *sy =
      gl_screen.myscale * (double)( gl_screen.rh - wy ) - (double)gl_screen.y;
}

void gl_screenToWindowPos( int *wx, int *wy, int sx, int sy )
{
   *wx = ( sx + (double)gl_screen.x ) / gl_screen.mxscale;
   *wy =
      (double)gl_screen.rh - ( sy + (double)gl_screen.y ) / gl_screen.myscale;
 
   *wx *= gl_screen.dwscale;
   *wy *= gl_screen.dhscale;
}

GLenum gl_stringToFilter( const char *s )
{
   if ( strcasecmp( s, "linear" ) == 0 )
      return GL_LINEAR;
   else if ( strcasecmp( s, "nearest" ) == 0 )
      return GL_NEAREST;
   WARN( _( "Unknown %s '%s'!" ), "OpenGL Filter", s );
   return 0;
}

GLenum gl_stringToClamp( const char *s )
{
   if ( strcasecmp( s, "clamp" ) == 0 )
      return GL_CLAMP_TO_EDGE;
   else if ( strcasecmp( s, "repeat" ) == 0 )
      return GL_REPEAT;
   else if ( strcasecmp( s, "mirroredrepeat" ) == 0 )
      return GL_MIRRORED_REPEAT;
   WARN( _( "Unknown %s '%s'!" ), "OpenGL Clamp", s );
   return 0;
}

GLenum gl_stringToBlendFunc( const char *s )
{
   if ( strcasecmp( s, "add" ) == 0 )
      return GL_FUNC_ADD;
   else if ( strcasecmp( s, "subrtract" ) == 0 )
      return GL_FUNC_SUBTRACT;
   else if ( strcasecmp( s, "reverse_subtract" ) == 0 )
      return GL_FUNC_REVERSE_SUBTRACT;
   else if ( strcasecmp( s, "min" ) == 0 )
      return GL_MIN;
   else if ( strcasecmp( s, "max" ) == 0 )
      return GL_MAX;
   WARN( _( "Unknown %s '%s'!" ), "OpenGL BlendFunc", s );
   return 0;
}

GLenum gl_stringToBlendFactor( const char *s )
{
   if ( strcasecmp( s, "zero" ) == 0 )
      return GL_ZERO;
   else if ( strcasecmp( s, "one" ) == 0 )
      return GL_ONE;
   else if ( strcasecmp( s, "src_color" ) == 0 )
      return GL_SRC_COLOR;
   else if ( strcasecmp( s, "one_minus_src_color" ) == 0 )
      return GL_ONE_MINUS_SRC_COLOR;
   else if ( strcasecmp( s, "src_alpha" ) == 0 )
      return GL_SRC_ALPHA;
   else if ( strcasecmp( s, "one_minus_src_alpha" ) == 0 )
      return GL_ONE_MINUS_SRC_ALPHA;
   else if ( strcasecmp( s, "dst_color" ) == 0 )
      return GL_DST_COLOR;
   else if ( strcasecmp( s, "one_minus_dst_color" ) == 0 )
      return GL_ONE_MINUS_DST_COLOR;
   else if ( strcasecmp( s, "dst_alpha" ) == 0 )
      return GL_DST_ALPHA;
   else if ( strcasecmp( s, "one_minus_dst_alpha" ) == 0 )
      return GL_ONE_MINUS_DST_ALPHA;
   else if ( strcasecmp( s, "src_alpha_saturate" ) == 0 )
      return GL_SRC_ALPHA_SATURATE;
   WARN( _( "Unknown %s '%s'!" ), "OpenGL BlendFactor", s );
   return 0;
}

void gl_colourblind( void )
{
   /* Load up shader uniforms. */
   glUseProgram( shaders.colourblind_sim.program );
   glUniform1i( shaders.colourblind_sim.type, conf.colourblind_type );
   glUniform1f( shaders.colourblind_sim.intensity, conf.colourblind_sim );
   glUseProgram( shaders.colourblind_correct.program );
   glUniform1i( shaders.colourblind_correct.type, conf.colourblind_type );
   glUniform1f( shaders.colourblind_correct.intensity,
                conf.colourblind_correct );
   glUseProgram( 0 );
 
   /* See if we have to correct. */
   if ( conf.colourblind_sim > 0. ) {
      LuaShader_t shader;
      if ( cb_simulate_pp != 0 )
         return;
      memset( &shader, 0, sizeof( LuaShader_t ) );
      shader.program            = shaders.colourblind_sim.program;
      shader.VertexPosition     = shaders.colourblind_sim.VertexPosition;
      shader.ClipSpaceFromLocal = shaders.colourblind_sim.ClipSpaceFromLocal;
      shader.MainTex            = shaders.colourblind_sim.MainTex;
      cb_simulate_pp = render_postprocessAdd( &shader, PP_LAYER_CORE, 99,
                                              PP_SHADER_PERMANENT );
   } else {
      if ( cb_simulate_pp != 0 )
         render_postprocessRm( cb_simulate_pp );
      cb_simulate_pp = 0;
   }
 
   /* See if we have to correct. */
   if ( conf.colourblind_correct > 0. ) {
      LuaShader_t shader;
      if ( cb_correct_pp != 0 )
         return;
      memset( &shader, 0, sizeof( LuaShader_t ) );
      shader.program        = shaders.colourblind_correct.program;
      shader.VertexPosition = shaders.colourblind_correct.VertexPosition;
      shader.ClipSpaceFromLocal =
         shaders.colourblind_correct.ClipSpaceFromLocal;
      shader.MainTex = shaders.colourblind_correct.MainTex;
      cb_correct_pp  = render_postprocessAdd( &shader, PP_LAYER_CORE, 100,
                                              PP_SHADER_PERMANENT );
   } else {
      if ( cb_correct_pp != 0 )
         render_postprocessRm( cb_correct_pp );
      cb_correct_pp = 0;
   }
}

void gl_exit( void )
{
   for ( int i = 0; i < OPENGL_NUM_FBOS; i++ ) {
      if ( gl_screen.fbo[i] != GL_INVALID_VALUE ) {
         glDeleteFramebuffers( 1, &gl_screen.fbo[i] );
         glDeleteTextures( 1, &gl_screen.fbo_tex[i] );
         glDeleteTextures( 1, &gl_screen.fbo_depth_tex[i] );
         gl_screen.fbo[i]           = GL_INVALID_VALUE;
         gl_screen.fbo_tex[i]       = GL_INVALID_VALUE;
         gl_screen.fbo_depth_tex[i] = GL_INVALID_VALUE;
      }
   }
 
   /* Exit the OpenGL subsystems. */
   gltf_exit();
   gl_exitRender();
   gl_exitVBO();
   gl_exitTextures();
 
   shaders_unload();
 
   /* Shut down the subsystem */
   SDL_QuitSubSystem( SDL_INIT_VIDEO );
}