opengl_render.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include "naev.h"
 
#include "opengl_render.h"
 
#include "camera.h"
#include "gui.h"
#include "opengl.h"
 
#define OPENGL_RENDER_VBO_SIZE 256 
 
static gl_vbo *gl_renderVBO          = 0; 
gl_vbo        *gl_squareVBO          = 0;
static gl_vbo *gl_squareEmptyVBO     = 0;
gl_vbo        *gl_circleVBO          = 0;
static gl_vbo *gl_lineVBO            = 0;
static gl_vbo *gl_triangleVBO        = 0;
static int     gl_renderVBOtexOffset = 0; 
static int     gl_renderVBOcolOffset = 0; 
 
void gl_beginSolidProgram( mat4 projection, const glColour *c )
{
   glUseProgram( shaders.solid.program );
   glEnableVertexAttribArray( shaders.solid.vertex );
   gl_uniformColour( shaders.solid.colour, c );
   gl_uniformMat4( shaders.solid.projection, &projection );
}
 
void gl_endSolidProgram( void )
{
   glDisableVertexAttribArray( shaders.solid.vertex );
   glUseProgram( 0 );
   gl_checkErr();
}
 
void gl_beginSmoothProgram( mat4 projection )
{
   glUseProgram( shaders.smooth.program );
   glEnableVertexAttribArray( shaders.smooth.vertex );
   glEnableVertexAttribArray( shaders.smooth.vertex_colour );
   gl_uniformMat4( shaders.smooth.projection, &projection );
}
 
void gl_endSmoothProgram()
{
   glDisableVertexAttribArray( shaders.smooth.vertex );
   glDisableVertexAttribArray( shaders.smooth.vertex_colour );
   glUseProgram( 0 );
   gl_checkErr();
}

void gl_renderRect( double x, double y, double w, double h, const glColour *c )
{
   /* Set the vertex. */
   mat4 projection = gl_view_matrix;
   mat4_translate_scale_xy( &projection, x, y, w, h );
 
   gl_renderRectH( &projection, c, 1 );
}

void gl_renderRectEmpty( double x, double y, double w, double h,
                         const glColour *c )
{
   mat4 projection = gl_view_matrix;
   mat4_translate_scale_xy( &projection, x, y, w, h );
 
   gl_renderRectH( &projection, c, 0 );
}

void gl_renderRectH( const mat4 *H, const glColour *c, int filled )
{
   gl_beginSolidProgram( *H, c );
   if ( filled ) {
      gl_vboActivateAttribOffset( gl_squareVBO, shaders.solid.vertex, 0, 2,
                                  GL_FLOAT, 0 );
      glDrawArrays( GL_TRIANGLE_STRIP, 0, 4 );
   } else {
      gl_vboActivateAttribOffset( gl_squareEmptyVBO, shaders.solid.vertex, 0, 2,
                                  GL_FLOAT, 0 );
      glDrawArrays( GL_LINE_STRIP, 0, 5 );
   }
   gl_endSolidProgram();
}

void gl_renderCross( double x, double y, double r, const glColour *c )
{
   glUseProgram( shaders.crosshairs.program );
   glUniform1f( shaders.crosshairs.paramf, 1. ); /* No outline. */
   gl_renderShader( x, y, r, r, 0., &shaders.crosshairs, c, 1 );
}

void gl_renderTriangleEmpty( double x, double y, double a, double s,
                             double length, const glColour *c )
{
   mat4 projection = gl_view_matrix;
   mat4_translate_xy( &projection, x, y );
   if ( a != 0. )
      mat4_rotate2d( &projection, a );
   mat4_scale_xy( &projection, s * length, s );
 
   gl_beginSolidProgram( projection, c );
   gl_vboActivateAttribOffset( gl_triangleVBO, shaders.solid.vertex, 0, 2,
                               GL_FLOAT, 0 );
   glDrawArrays( GL_LINE_STRIP, 0, 4 );
   gl_endSolidProgram();
}
 
void gl_renderDepthRawH( GLuint depth, const mat4 *projection,
                         const mat4 *tex_mat )
{
   /* Depth testing is required for depth writing. */
   glEnable( GL_DEPTH_TEST );
   glDepthFunc( GL_ALWAYS );
   glColorMask( GL_FALSE, GL_FALSE, GL_FALSE,
                GL_FALSE ); /* Don't draw colour. */
 
   glUseProgram( shaders.texture_depth_only.program );
 
   /* Bind the texture_depth_only. */
   glBindTexture( GL_TEXTURE_2D, depth );
 
   /* Set the vertex. */
   glEnableVertexAttribArray( shaders.texture_depth_only.vertex );
   gl_vboActivateAttribOffset( gl_squareVBO, shaders.texture_depth_only.vertex,
                               0, 2, GL_FLOAT, 0 );
 
   /* Set shader uniforms. */
   gl_uniformMat4( shaders.texture_depth_only.projection, projection );
   gl_uniformMat4( shaders.texture_depth_only.tex_mat, tex_mat );
 
   /* Draw. */
   glDrawArrays( GL_TRIANGLE_STRIP, 0, 4 );
 
   /* Clear state. */
   glDisableVertexAttribArray( shaders.texture_depth_only.vertex );
   glColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );
   glDepthFunc( GL_LESS );
   glDisable( GL_DEPTH_TEST );
 
   /* anything failed? */
   gl_checkErr();
 
   glUseProgram( 0 );
}
 
void gl_renderDepthRaw( GLuint depth, uint8_t flags, double x, double y,
                        double w, double h, double tx, double ty, double tw,
                        double th, double angle )
{
   mat4 projection, tex_mat;
 
   /* Set the vertex. */
   projection = gl_view_matrix;
   if ( angle == 0. ) {
      mat4_translate_scale_xy( &projection, x, y, w, h );
   } else {
      double hw = w * 0.5;
      double hh = h * 0.5;
      mat4_translate_xy( &projection, x + hw, y + hh );
      mat4_rotate2d( &projection, angle );
      mat4_translate_scale_xy( &projection, -hw, -hh, w, h );
   }
 
   /* Set the texture. */
   tex_mat = ( flags & OPENGL_TEX_VFLIP )
                ? mat4_ortho( -1., 1., 2., 0., 1., -1. )
                : mat4_identity();
   mat4_translate_scale_xy( &tex_mat, tx, ty, tw, th );
 
   gl_renderDepthRawH( depth, &projection, &tex_mat );
}
 
void gl_renderTextureDepthRawH( GLuint texture, GLuint depth,
                                const mat4 *projection, const mat4 *tex_mat,
                                const glColour *c )
{
   /* Depth testing is required for depth writing. */
   glEnable( GL_DEPTH_TEST );
   glDepthFunc( GL_ALWAYS );
 
   glUseProgram( shaders.texture_depth.program );
 
   /* Bind the texture_depth. */
   glActiveTexture( GL_TEXTURE1 );
   glBindTexture( GL_TEXTURE_2D, depth );
   glActiveTexture( GL_TEXTURE0 );
   glBindTexture( GL_TEXTURE_2D, texture );
 
   /* Must have colour for now. */
   if ( c == NULL )
      c = &cWhite;
 
   /* Set the vertex. */
   glEnableVertexAttribArray( shaders.texture_depth.vertex );
   gl_vboActivateAttribOffset( gl_squareVBO, shaders.texture_depth.vertex, 0, 2,
                               GL_FLOAT, 0 );
 
   /* Set shader uniforms. */
   gl_uniformColour( shaders.texture_depth.colour, c );
   gl_uniformMat4( shaders.texture_depth.projection, projection );
   gl_uniformMat4( shaders.texture_depth.tex_mat, tex_mat );
   glUniform1i( shaders.texture_depth.depth, 1 );
 
   /* Draw. */
   glDrawArrays( GL_TRIANGLE_STRIP, 0, 4 );
 
   /* Clear state. */
   glDisableVertexAttribArray( shaders.texture_depth.vertex );
   glDepthFunc( GL_LESS );
   glDisable( GL_DEPTH_TEST );
 
   /* anything failed? */
   gl_checkErr();
 
   glUseProgram( 0 );
}
 
void gl_renderTextureDepthRaw( GLuint texture, GLuint depth, uint8_t flags,
                               double x, double y, double w, double h,
                               double tx, double ty, double tw, double th,
                               const glColour *c, double angle )
{
   mat4 projection, tex_mat;
 
   /* Set the vertex. */
   projection = gl_view_matrix;
   if ( angle == 0. ) {
      mat4_translate_scale_xy( &projection, x, y, w, h );
   } else {
      double hw = w * 0.5;
      double hh = h * 0.5;
      mat4_translate_xy( &projection, x + hw, y + hh );
      mat4_rotate2d( &projection, angle );
      mat4_translate_scale_xy( &projection, -hw, -hh, w, h );
   }
 
   /* Set the texture. */
   tex_mat = ( flags & OPENGL_TEX_VFLIP )
                ? mat4_ortho( -1., 1., 2., 0., 1., -1. )
                : mat4_identity();
   mat4_translate_scale_xy( &tex_mat, tx, ty, tw, th );
 
   gl_renderTextureDepthRawH( texture, depth, &projection, &tex_mat, c );
}

void gl_renderTextureRawH( GLuint texture, const mat4 *projection,
                           const mat4 *tex_mat, const glColour *c )
{
   glUseProgram( shaders.texture.program );
 
   /* Bind the texture. */
   glBindTexture( GL_TEXTURE_2D, texture );
 
   /* Must have colour for now. */
   if ( c == NULL )
      c = &cWhite;
 
   /* Set the vertex. */
   glEnableVertexAttribArray( shaders.texture.vertex );
   gl_vboActivateAttribOffset( gl_squareVBO, shaders.texture.vertex, 0, 2,
                               GL_FLOAT, 0 );
 
   /* Set shader uniforms. */
   gl_uniformColour( shaders.texture.colour, c );
   gl_uniformMat4( shaders.texture.projection, projection );
   gl_uniformMat4( shaders.texture.tex_mat, tex_mat );
 
   /* Draw. */
   glDrawArrays( GL_TRIANGLE_STRIP, 0, 4 );
 
   /* Clear state. */
   glDisableVertexAttribArray( shaders.texture.vertex );
 
   /* anything failed? */
   gl_checkErr();
 
   glUseProgram( 0 );
}

void gl_renderTextureRaw( GLuint texture, uint8_t flags, double x, double y,
                          double w, double h, double tx, double ty, double tw,
                          double th, const glColour *c, double angle )
{
   mat4 projection, tex_mat;
 
   /* Set the vertex. */
   projection = gl_view_matrix;
   if ( angle == 0. ) {
      mat4_translate_scale_xy( &projection, x, y, w, h );
   } else {
      double hw, hh; /* Half width and height. */
      hw = w * 0.5;
      hh = h * 0.5;
      mat4_translate_xy( &projection, x + hw, y + hh );
      mat4_rotate2d( &projection, angle );
      mat4_translate_scale_xy( &projection, -hw, -hh, w, h );
   }
 
   /* Set the texture. */
   tex_mat = ( flags & OPENGL_TEX_VFLIP )
                ? mat4_ortho( -1., 1., 2., 0., 1., -1. )
                : mat4_identity();
   mat4_translate_scale_xy( &tex_mat, tx, ty, tw, th );
 
   gl_renderTextureRawH( texture, &projection, &tex_mat, c );
}

void gl_renderTexture( const glTexture *texture, double x, double y, double w,
                       double h, double tx, double ty, double tw, double th,
                       const glColour *c, double angle )
{
   gl_renderTextureRaw( texture->texture, texture->flags, x, y, w, h, tx, ty,
                        tw, th, c, angle );
}

void gl_renderSDF( const glTexture *texture, double x, double y, double w,
                   double h, const glColour *c, double angle, double outline )
{
   (void)outline; /* TODO handle outline. */
   double hw, hh; /* Half width and height */
   double sw, sh;
   mat4   projection, tex_mat;
 
   glUseProgram( shaders.texturesdf.program );
 
   /* Bind the texture. */
   glBindTexture( GL_TEXTURE_2D, texture->texture );
 
   /* Must have colour for now. */
   if ( c == NULL )
      c = &cWhite;
 
   hw = w * 0.5;
   hh = h * 0.5;
 
   /* Set the vertex. */
   projection = gl_view_matrix;
   if ( angle == 0. ) {
      mat4_translate_scale_xy( &projection, x + hw, y + hh, hw, hh );
   } else {
      mat4_translate_xy( &projection, x + hw, y + hh );
      mat4_rotate2d( &projection, angle );
      mat4_scale_xy( &projection, hw, hh );
   }
   glEnableVertexAttribArray( shaders.texturesdf.vertex );
   gl_vboActivateAttribOffset( gl_circleVBO, shaders.texturesdf.vertex, 0, 2,
                               GL_FLOAT, 0 );
 
   /* Set the texture. */
   /* TODO we would want to pad the texture a bit to get nice marked borders,
    * but we have to actually pad the SDF first... */
   sw      = 0.; // 1./w;
   sh      = 0.; // 1./h;
   tex_mat = ( texture->flags & OPENGL_TEX_VFLIP )
                ? mat4_ortho( -1., 1., 2., 0., 1., -1. )
                : mat4_identity();
   mat4_scale_xy( &tex_mat, texture->srw + 2. * sw, texture->srh + 2. * sh );
   mat4_translate_xy( &tex_mat, -sw, -sh );
 
   /* Set shader uniforms. */
   gl_uniformColour( shaders.texturesdf.colour, c );
   gl_uniformMat4( shaders.texturesdf.projection, &projection );
   gl_uniformMat4( shaders.texturesdf.tex_mat, &tex_mat );
   glUniform1f( shaders.texturesdf.m,
                ( 2.0 * texture->vmax * ( w + 2. ) / texture->w ) );
 
   /* Draw. */
   glDrawArrays( GL_TRIANGLE_STRIP, 0, 4 );
 
   /* Clear state. */
   glDisableVertexAttribArray( shaders.texturesdf.vertex );
 
   /* anything failed? */
   gl_checkErr();
 
   glUseProgram( 0 );
}

void gl_renderTextureInterpolateRawH( GLuint ta, GLuint tb, double inter,
                                      const mat4 *projection,
                                      const mat4 *tex_mat, const glColour *c )
{
   /* Corner cases. */
   if ( inter >= 1. )
      return gl_renderTextureRawH( ta, projection, tex_mat, c );
   else if ( inter <= 0. )
      return gl_renderTextureRawH( tb, projection, tex_mat, c );
 
   /* Must have colour for now. */
   if ( c == NULL )
      c = &cWhite;
 
   glUseProgram( shaders.texture_interpolate.program );
 
   /* Bind the textures. */
   glActiveTexture( GL_TEXTURE1 );
   glBindTexture( GL_TEXTURE_2D, tb );
   glActiveTexture( GL_TEXTURE0 );
   glBindTexture( GL_TEXTURE_2D, ta );
   /* Always end with TEXTURE0 active. */
 
   /* Set the vertex. */
   glEnableVertexAttribArray( shaders.texture_interpolate.vertex );
   gl_vboActivateAttribOffset( gl_squareVBO, shaders.texture_interpolate.vertex,
                               0, 2, GL_FLOAT, 0 );
 
   /* Set shader uniforms. */
   glUniform1i( shaders.texture_interpolate.sampler1, 0 );
   glUniform1i( shaders.texture_interpolate.sampler2, 1 );
   gl_uniformColour( shaders.texture_interpolate.colour, c );
   glUniform1f( shaders.texture_interpolate.inter, inter );
   gl_uniformMat4( shaders.texture_interpolate.projection, projection );
   gl_uniformMat4( shaders.texture_interpolate.tex_mat, tex_mat );
 
   /* Draw. */
   glDrawArrays( GL_TRIANGLE_STRIP, 0, 4 );
 
   /* Clear state. */
   glDisableVertexAttribArray( shaders.texture_interpolate.vertex );
 
   /* anything failed? */
   gl_checkErr();
 
   glUseProgram( 0 );
}

void gl_renderTextureInterpolate( const glTexture *ta, const glTexture *tb,
                                  double inter, double x, double y, double w,
                                  double h, double tx, double ty, double tw,
                                  double th, const glColour *c )
{
   mat4 projection, tex_mat;
 
   /* Case no need for interpolation. */
   if ( tb == NULL )
      return gl_renderTexture( ta, x, y, w, h, tx, ty, tw, th, c, 0. );
   else if ( ta == NULL )
      return gl_renderTexture( tb, x, y, w, h, tx, ty, tw, th, c, 0. );
 
   projection = gl_view_matrix;
   mat4_translate_scale_xy( &projection, x, y, w, h );
   tex_mat = ( ta->flags & OPENGL_TEX_VFLIP )
                ? mat4_ortho( -1., 1., 2., 0., 1., -1. )
                : mat4_identity();
   mat4_translate_scale_xy( &tex_mat, tx, ty, tw, th );
 
   return gl_renderTextureInterpolateRawH( ta->texture, tb->texture, inter,
                                           &projection, &tex_mat, c );
}

void gl_gameToScreenCoords( double *nx, double *ny, double bx, double by )
{
   double cx, cy, gx, gy, z;
 
   /* Get parameters. */
   cam_getPos( &cx, &cy );
   z = cam_getZoom();
   gui_getOffset( &gx, &gy );
 
   /* calculate position - we'll use relative coords to player */
   *nx = ( bx - cx ) * z + gx + SCREEN_W * 0.5;
   *ny = ( by - cy ) * z + gy + SCREEN_H * 0.5;
}

mat4 gl_gameToScreenMatrix( mat4 lhs )
{
   double cx, cy, gx, gy, z;
   mat4   projection = lhs;
 
   /* Get parameters. */
   cam_getPos( &cx, &cy );
   z = cam_getZoom();
   gui_getOffset( &gx, &gy );
 
   mat4_translate_scale_xy( &projection, gx + SCREEN_W * 0.5,
                            gy + SCREEN_H * 0.5, z, z );
   mat4_translate_xy( &projection, -cx, cy );
   return projection;
}

void gl_screenToGameCoords( double *nx, double *ny, int bx, int by )
{
   double cx, cy, gx, gy, z;
 
   /* Get parameters. */
   cam_getPos( &cx, &cy );
   z = cam_getZoom();
   gui_getOffset( &gx, &gy );
 
   /* calculate position - we'll use relative coords to player */
   *nx = ( bx - SCREEN_W * 0.5 - gx ) / z + cx;
   *ny = ( by - SCREEN_H * 0.5 - gy ) / z + cy;
}

void gl_renderSprite( const glTexture *sprite, double bx, double by, int sx,
                      int sy, const glColour *c )
{
   double x, y, w, h, tx, ty, z;
 
   /* Translate coords. */
   z = cam_getZoom();
   gl_gameToScreenCoords( &x, &y, bx - sprite->sw * 0.5,
                          by - sprite->sh * 0.5 );
 
   /* Scaled sprite dimensions. */
   w = sprite->sw * z;
   h = sprite->sh * z;
 
   /* check if inbounds */
   if ( ( x < -w ) || ( x > SCREEN_W + w ) || ( y < -h ) ||
        ( y > SCREEN_H + h ) )
      return;
 
   /* texture coords */
   tx = sprite->sw * (double)( sx ) / sprite->w;
   ty = sprite->sh * ( sprite->sy - (double)sy - 1 ) / sprite->h;
 
   gl_renderTexture( sprite, x, y, w, h, tx, ty, sprite->srw, sprite->srh, c,
                     0. );
}

void gl_renderSpriteScale( const glTexture *sprite, double bx, double by,
                           double scalew, double scaleh, int sx, int sy,
                           const glColour *c )
{
   double x, y, w, h, tx, ty, z;
 
   /* Translate coords. */
   z = cam_getZoom();
   gl_gameToScreenCoords( &x, &y, bx - sprite->sw * 0.5,
                          by - sprite->sh * 0.5 );
 
   /* Scaled sprite dimensions. */
   w = sprite->sw * z * scalew;
   h = sprite->sh * z * scaleh;
 
   /* check if inbounds */
   if ( ( x < -w ) || ( x > SCREEN_W + w ) || ( y < -h ) ||
        ( y > SCREEN_H + h ) )
      return;
 
   /* texture coords */
   tx = sprite->sw * (double)( sx ) / sprite->w;
   ty = sprite->sh * ( sprite->sy - (double)sy - 1 ) / sprite->h;
 
   gl_renderTexture( sprite, x, y, w, h, tx, ty, sprite->srw, sprite->srh, c,
                     0. );
}

void gl_renderSpriteRotate( const glTexture *sprite, double bx, double by,
                            double angle, int sx, int sy, const glColour *c )
{
   double x, y, w, h, tx, ty, z;
 
   /* Translate coords. */
   z = cam_getZoom();
   gl_gameToScreenCoords( &x, &y, bx - sprite->sw * 0.5,
                          by - sprite->sh * 0.5 );
 
   /* Scaled sprite dimensions. */
   w = sprite->sw * z;
   h = sprite->sh * z;
 
   /* check if inbounds */
   if ( ( x < -w ) || ( x > SCREEN_W + w ) || ( y < -h ) ||
        ( y > SCREEN_H + h ) )
      return;
 
   /* texture coords */
   tx = sprite->sw * (double)( sx ) / sprite->w;
   ty = sprite->sh * ( sprite->sy - (double)sy - 1 ) / sprite->h;
 
   gl_renderTexture( sprite, x, y, w, h, tx, ty, sprite->srw, sprite->srh, c,
                     angle );
}

void gl_renderSpriteScaleRotate( const glTexture *sprite, double bx, double by,
                                 double scalew, double scaleh, double angle,
                                 int sx, int sy, const glColour *c )
{
   double x, y, w, h, tx, ty, z;
 
   /* Translate coords. */
   z = cam_getZoom();
   gl_gameToScreenCoords( &x, &y, bx - sprite->sw * 0.5,
                          by - sprite->sh * 0.5 );
 
   /* Scaled sprite dimensions. */
   w = sprite->sw * z * scalew;
   h = sprite->sh * z * scaleh;
 
   /* check if inbounds */
   if ( ( x < -w ) || ( x > SCREEN_W + w ) || ( y < -h ) ||
        ( y > SCREEN_H + h ) )
      return;
 
   /* texture coords */
   tx = sprite->sw * (double)( sx ) / sprite->w;
   ty = sprite->sh * ( sprite->sy - (double)sy - 1 ) / sprite->h;
 
   gl_renderTexture( sprite, x, y, w, h, tx, ty, sprite->srw, sprite->srh, c,
                     angle );
}

void gl_renderSpriteInterpolate( const glTexture *sa, const glTexture *sb,
                                 double inter, double bx, double by, int sx,
                                 int sy, const glColour *c )
{
   gl_renderSpriteInterpolateScale( sa, sb, inter, bx, by, 1., 1., sx, sy, c );
}

void gl_renderSpriteInterpolateScale( const glTexture *sa, const glTexture *sb,
                                      double inter, double bx, double by,
                                      double scalew, double scaleh, int sx,
                                      int sy, const glColour *c )
{
   double x, y, w, h, tx, ty, z;
 
   /* Translate coords. */
   gl_gameToScreenCoords( &x, &y, bx - scalew * sa->sw * 0.5,
                          by - scaleh * sa->sh * 0.5 );
 
   /* Scaled sprite dimensions. */
   z = cam_getZoom();
   w = sa->sw * z * scalew;
   h = sa->sh * z * scaleh;
 
   /* check if inbounds */
   if ( ( x < -w ) || ( x > SCREEN_W + w ) || ( y < -h ) ||
        ( y > SCREEN_H + h ) )
      return;
 
   /* texture coords */
   tx = sa->sw * (double)( sx ) / sa->w;
   ty = sa->sh * ( sa->sy - (double)sy - 1 ) / sa->h;
 
   gl_renderTextureInterpolate( sa, sb, inter, x, y, w, h, tx, ty, sa->srw,
                                sa->srh, c );
}

void gl_renderStaticSprite( const glTexture *sprite, double bx, double by,
                            int sx, int sy, const glColour *c )
{
   double x, y, tx, ty;
 
   x = bx;
   y = by;
 
   /* texture coords */
   tx = sprite->sw * (double)( sx ) / sprite->w;
   ty = sprite->sh * ( sprite->sy - (double)sy - 1 ) / sprite->h;
 
   /* actual blitting */
   gl_renderTexture( sprite, x, y, sprite->sw, sprite->sh, tx, ty, sprite->srw,
                     sprite->srh, c, 0. );
}

void gl_renderStaticSpriteInterpolate( const glTexture *sa, const glTexture *sb,
                                       double inter, double bx, double by,
                                       int sx, int sy, const glColour *c )
{
   gl_renderStaticSpriteInterpolateScale( sa, sb, inter, bx, by, 1., 1., sx, sy,
                                          c );
}

void gl_renderStaticSpriteInterpolateScale( const glTexture *sa,
                                            const glTexture *sb, double inter,
                                            double bx, double by, double scalew,
                                            double scaleh, int sx, int sy,
                                            const glColour *c )
{
   double x, y, w, h, tx, ty;
 
   x = bx;
   y = by;
 
   /* Scaled sprite dimensions. */
   w = sa->sw * scalew;
   h = sa->sh * scaleh;
 
   /* check if inbounds */
   if ( ( x < -w ) || ( x > SCREEN_W + w ) || ( y < -h ) ||
        ( y > SCREEN_H + h ) )
      return;
 
   /* texture coords */
   tx = sa->sw * (double)( sx ) / sa->w;
   ty = sa->sh * ( sa->sy - (double)sy - 1 ) / sa->h;
 
   gl_renderTextureInterpolate( sa, sb, inter, x, y, w, h, tx, ty, sa->srw,
                                sa->srh, c );
}

void gl_renderScaleSprite( const glTexture *sprite, double bx, double by,
                           int sx, int sy, double bw, double bh,
                           const glColour *c )
{
   double x, y, tx, ty;
 
   x = bx;
   y = by;
 
   /* texture coords */
   tx = sprite->sw * (double)( sx ) / sprite->w;
   ty = sprite->sh * ( sprite->sy - (double)sy - 1 ) / sprite->h;
 
   /* actual blitting */
   gl_renderTexture( sprite, x, y, bw, bh, tx, ty, sprite->srw, sprite->srh, c,
                     0. );
}

void gl_renderScale( const glTexture *texture, double bx, double by, double bw,
                     double bh, const glColour *c )
{
   double x, y, tx, ty;
 
   /* here we use absolute coords */
   x = bx;
   y = by;
 
   /* texture dimensions */
   tx = ty = 0.;
 
   /* Actual blitting. */
   gl_renderTexture( texture, x, y, bw, bh, tx, ty, texture->srw, texture->srh,
                     c, 0. );
}

void gl_renderScaleAspect( const glTexture *texture, double bx, double by,
                           double bw, double bh, const glColour *c )
{
   double scale;
   double nw, nh;
 
   scale = MIN( bw / texture->w, bh / texture->h );
 
   nw = scale * texture->w;
   nh = scale * texture->h;
 
   bx += ( bw - nw ) * 0.5;
   by += ( bh - nh ) * 0.5;
 
   gl_renderScale( texture, bx, by, nw, nh, c );
}

void gl_renderStatic( const glTexture *texture, double bx, double by,
                      const glColour *c )
{
   double x, y;
 
   /* here we use absolute coords */
   x = bx;
   y = by;
 
   /* actual blitting */
   gl_renderTexture( texture, x, y, texture->sw, texture->sh, 0., 0.,
                     texture->srw, texture->srh, c, 0. );
}

void gl_renderShader( double x, double y, double w, double h, double r,
                      const SimpleShader *shd, const glColour *c, int center )
{
   mat4 projection = gl_view_matrix;
   mat4_translate_xy( &projection, x, y );
   if ( r != 0. )
      mat4_rotate2d( &projection, r );
   mat4_scale_xy( &projection, w, h );
   glUniform2f( shd->dimensions, w, h );
   gl_renderShaderH( shd, &projection, c, center );
}

void gl_renderShaderH( const SimpleShader *shd, const mat4 *H,
                       const glColour *c, int center )
{
   glEnableVertexAttribArray( shd->vertex );
   gl_vboActivateAttribOffset( center ? gl_circleVBO : gl_squareVBO,
                               shd->vertex, 0, 2, GL_FLOAT, 0 );
 
   if ( c != NULL )
      gl_uniformColour( shd->colour, c );
 
   gl_uniformMat4( shd->projection, H );
 
   glDrawArrays( GL_TRIANGLE_STRIP, 0, 4 );
 
   glDisableVertexAttribArray( shd->vertex );
   glUseProgram( 0 );
   gl_checkErr();
}

void gl_renderCircle( double cx, double cy, double r, const glColour *c,
                      int filled )
{
   /* Set the vertex. */
   mat4 projection = gl_view_matrix;
   mat4_translate_scale_xy( &projection, cx, cy, r, r );
 
   /* Draw! */
   gl_renderCircleH( &projection, c, filled );
}

void gl_renderCircleH( const mat4 *H, const glColour *c, int filled )
{
   // TODO handle shearing and different x/y scaling
   GLfloat r = H->m[0][0] / gl_view_matrix.m[0][0];
 
   glUseProgram( shaders.circle.program );
   glUniform2f( shaders.circle.dimensions, r, r );
   glUniform1i( shaders.circle.parami, filled );
   gl_renderShaderH( &shaders.circle, H, c, 1 );
}

void gl_renderLine( double x1, double y1, double x2, double y2,
                    const glColour *c )
{
   double a = atan2( y2 - y1, x2 - x1 );
   double s = hypotf( x2 - x1, y2 - y1 );
 
   glUseProgram( shaders.sdfsolid.program );
   glUniform1f( shaders.sdfsolid.paramf, 1. ); /* No outline. */
   gl_renderShader( ( x1 + x2 ) * 0.5, ( y1 + y2 ) * 0.5, s * 0.5 + 0.5, 1.0, a,
                    &shaders.sdfsolid, c, 1 );
}

void gl_clipRect( int x, int y, int w, int h )
{
   double rx, ry, rw, rh;
   rx = ( x + gl_screen.x ) / gl_screen.mxscale;
   ry = ( y + gl_screen.y ) / gl_screen.myscale;
   rw = w / gl_screen.mxscale;
   rh = h / gl_screen.myscale;
   glScissor( rx, ry, rw, rh );
   glEnable( GL_SCISSOR_TEST );
}

void gl_unclipRect( void )
{
   glDisable( GL_SCISSOR_TEST );
   glScissor( 0, 0, gl_screen.rw, gl_screen.rh );
}

int gl_initRender( void )
{
   GLfloat vertex[10];
 
   /* Initialize the VBO. */
   gl_renderVBO = gl_vboCreateStream(
      sizeof( GLfloat ) * OPENGL_RENDER_VBO_SIZE * ( 2 + 2 + 4 ), NULL );
   gl_renderVBOtexOffset = sizeof( GLfloat ) * OPENGL_RENDER_VBO_SIZE * 2;
   gl_renderVBOcolOffset =
      sizeof( GLfloat ) * OPENGL_RENDER_VBO_SIZE * ( 2 + 2 );
 
   vertex[0]    = 0.;
   vertex[1]    = 0.;
   vertex[2]    = 1.;
   vertex[3]    = 0.;
   vertex[4]    = 0.;
   vertex[5]    = 1.;
   vertex[6]    = 1.;
   vertex[7]    = 1.;
   gl_squareVBO = gl_vboCreateStatic( sizeof( GLfloat ) * 8, vertex );
 
   vertex[0]    = -1.;
   vertex[1]    = -1.;
   vertex[2]    = 1.;
   vertex[3]    = -1.;
   vertex[4]    = -1.;
   vertex[5]    = 1.;
   vertex[6]    = 1.;
   vertex[7]    = 1.;
   gl_circleVBO = gl_vboCreateStatic( sizeof( GLfloat ) * 8, vertex );
 
   vertex[0]         = 0.;
   vertex[1]         = 0.;
   vertex[2]         = 1.;
   vertex[3]         = 0.;
   vertex[4]         = 1.;
   vertex[5]         = 1.;
   vertex[6]         = 0.;
   vertex[7]         = 1.;
   vertex[8]         = 0.;
   vertex[9]         = 0.;
   gl_squareEmptyVBO = gl_vboCreateStatic( sizeof( GLfloat ) * 8, vertex );
 
   vertex[0]  = 0.;
   vertex[1]  = 0.;
   vertex[2]  = 1.;
   vertex[3]  = 0.;
   gl_lineVBO = gl_vboCreateStatic( sizeof( GLfloat ) * 4, vertex );
 
   vertex[0]      = 0.5 * cos( 4. * M_PI / 3. );
   vertex[1]      = 0.5 * sin( 4. * M_PI / 3. );
   vertex[2]      = 0.5 * cos( 0. );
   vertex[3]      = 0.5 * sin( 0. );
   vertex[4]      = 0.5 * cos( 2. * M_PI / 3. );
   vertex[5]      = 0.5 * sin( 2. * M_PI / 3. );
   vertex[6]      = vertex[0];
   vertex[7]      = vertex[1];
   gl_triangleVBO = gl_vboCreateStatic( sizeof( GLfloat ) * 8, vertex );
 
   gl_checkErr();
 
   return 0;
}

void gl_exitRender( void )
{
   /* Destroy the VBO. */
   gl_vboDestroy( gl_renderVBO );
   gl_vboDestroy( gl_squareVBO );
   gl_vboDestroy( gl_circleVBO );
   gl_vboDestroy( gl_squareEmptyVBO );
   gl_vboDestroy( gl_lineVBO );
   gl_vboDestroy( gl_triangleVBO );
   gl_renderVBO = NULL;
}