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 "conf.h"
#include "gui.h"
#include "log.h"
#include "ndata.h"
#include "nstring.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( &projection, x, y, 0. );
   mat4_scale( &projection, w, h, 1. );
 
   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( &projection, x, y, 0. );
   mat4_scale( &projection, w, h, 1. );
 
   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( &projection, x, y, 0. );
   if (a != 0.)
      mat4_rotate2d( &projection, a );
   mat4_scale( &projection, s*length, s, 1. );
 
   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_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 )
{
   // Half width and height
   double hw, hh;
   mat4 projection, tex_mat;
 
   glUseProgram(shaders.texture.program);
 
   /* Bind the texture. */
   glBindTexture( GL_TEXTURE_2D, 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( &projection, x, y, 0. );
     mat4_scale( &projection, w, h, 1. );
   }
   else {
     mat4_translate( &projection, x+hw, y+hh, 0. );
     mat4_rotate2d( &projection, angle );
     mat4_translate( &projection, -hw, -hh, 0. );
     mat4_scale( &projection, w, h, 1. );
   }
   glEnableVertexAttribArray( shaders.texture.vertex );
   gl_vboActivateAttribOffset( gl_squareVBO, shaders.texture.vertex,
         0, 2, GL_FLOAT, 0 );
 
   /* Set the texture. */
   tex_mat = (flags & OPENGL_TEX_VFLIP) ? mat4_ortho(-1, 1, 2, 0, 1, -1) : mat4_identity();
   mat4_translate( &tex_mat, tx, ty, 0. );
   mat4_scale( &tex_mat, tw, th, 1. );
 
   /* 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_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( &projection, x+hw, y+hh, 0. );
     mat4_scale( &projection, hw, hh, 1. );
   }
   else {
     mat4_translate( &projection, x+hw, y+hh, 0. );
     mat4_rotate2d( &projection, angle );
     mat4_scale( &projection, hw, hh, 1. );
   }
   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( &tex_mat, texture->srw+2.*sw, texture->srh+2.*sh, 1. );
   mat4_translate( &tex_mat, -sw, -sh, 0. );
 
   /* 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_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 )
{
   /* No interpolation. */
   if (tb == NULL) {
      gl_renderTexture( ta, x, y, w, h, tx, ty, tw, th, c, 0. );
      return;
   }
 
   /* Corner cases. */
   if (inter >= 1.) {
      gl_renderTexture( ta, x, y, w, h, tx, ty, tw, th, c, 0. );
      return;
   }
   else if (inter <= 0.) {
      gl_renderTexture( tb, x, y, w, h, tx, ty, tw, th, c, 0. );
      return;
   }
 
   mat4 projection, tex_mat;
 
   glUseProgram(shaders.texture_interpolate.program);
 
   /* Bind the textures. */
   glActiveTexture( GL_TEXTURE1 );
   glBindTexture( GL_TEXTURE_2D, tb->texture);
   glActiveTexture( GL_TEXTURE0 );
   glBindTexture( GL_TEXTURE_2D, ta->texture);
   /* Always end with TEXTURE0 active. */
 
   /* Must have colour for now. */
   if (c == NULL)
      c = &cWhite;
 
   /* Set the vertex. */
   projection = gl_view_matrix;
   mat4_translate( &projection, x, y, 0. );
   mat4_scale( &projection, w, h, 1. );
   glEnableVertexAttribArray( shaders.texture_interpolate.vertex );
   gl_vboActivateAttribOffset( gl_squareVBO, shaders.texture_interpolate.vertex, 0, 2, GL_FLOAT, 0 );
 
   /* Set the texture. */
   tex_mat = (ta->flags & OPENGL_TEX_VFLIP) ? mat4_ortho(-1, 1, 2, 0, 1, -1) : mat4_identity();
   mat4_translate( &tex_mat, tx, ty, 0. );
   mat4_scale( &tex_mat, tw, th, 1. );
 
   /* 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_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( &projection, gx + SCREEN_W*0.5, gy + SCREEN_H*0.5, 0. );
   mat4_scale( &projection, z, z, 1. );
   mat4_translate( &projection, -cx, cy, 0. );
   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( &projection, x, y, 0. );
   if (r != 0.)
      mat4_rotate2d( &projection, r );
   mat4_scale( &projection, w, h, 1. );
   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( &projection, cx, cy, 0. );
   mat4_scale( &projection, r, r, 1. );
 
   /* 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;
}