TBO teapot example

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define GL_GLEXT_PROTOTYPES 1
#include <GL/gl.h>
#include <GL/glut.h>

static const char Vertex_src[] =
    "void main(void)"
    "{"
    "  gl_Position = ftransform();"
    "}";

static const char Fragment_src[] =
    "uniform samplerBuffer tex;"
    ""
    "void main(void)"
    "{"
    "  gl_FragColor = texelFetch( tex, 0 );"
    "}";


void keybd ( unsigned char, int, int )
{
    exit ( 0 ) ;
}


void reshape(int wid, int ht)
{
    glViewport(0, 0, wid, ht);
}

void showGLerror ()
{
    GLenum err ;

    while ( (err = glGetError()) != GL_NO_ERROR )
        fprintf ( stderr, "OpenGL Error: %s\n", gluErrorString ( err ) )  ;
}

void display ( void )
{
    static float a = 0.0f ;

    a += 0.3f ;

    glMatrixMode      ( GL_PROJECTION ) ;
    glLoadIdentity    () ;
    glFrustum         ( -1.0f, 1.0f,
                -1.0f / (640.0f/480.0f), 1.0f / (640.0f/480.0f),
                3.0f, 10.0f) ;

    glMatrixMode      ( GL_MODELVIEW ) ;
    glLoadIdentity    () ;
    glTranslatef      ( 0.0, 0.0, -5.0 ) ;
    glRotatef         ( a, 0.2, 0.7, 0 ) ;

    glEnable          ( GL_DEPTH_TEST ) ;
    glEnable          ( GL_CULL_FACE  ) ;
    glCullFace        ( GL_FRONT ) ;

    glClearColor      ( 0.0f, 0.0f, 0.0f, 1.0f ) ;
    glClear           ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ) ;

    glutSolidTeapot   ( 1.0f ) ;

    glutSwapBuffers   () ;
    glutPostRedisplay () ;

    showGLerror () ;
}

void showShaderInfo ( const char *what, GLuint handle )
{
    int len = 0 ;

    glGetObjectParameterivARB ( handle, GL_OBJECT_INFO_LOG_LENGTH_ARB, &len ) ;

    if ( len > 0 )
    {
        int trueLen ;
        char *s = new char [ len ] ;

        glGetInfoLogARB ( handle, len, &trueLen, s ) ;

        if ( trueLen > 0 & &s [ 0 ] != '\0' )
            fprintf ( stderr, "%s:\n%s\n", what, s ) ;

        delete [] s ;
    }
}

GLuint compileShader ( const char *src, GLenum type )
{
    const char *type_str = type == GL_VERTEX_SHADER ? "vertex" : "fragment";

    GLuint handle = glCreateShader( type ) ;

    glShaderSource ( handle, 1, &src, 0 ) ;
    glCompileShader( handle ) ;

    GLint compiled ;
    glGetShaderiv( handle, GL_COMPILE_STATUS, &compiled ) ;

    if ( !compiled )
    {
        showShaderInfo ( type_str, handle ) ;
        fprintf ( stderr, "Failed to compile %s shader.\n", type_str );
        exit ( 1 ) ;
    }

    return handle ;
}

GLuint linkShaders ( GLuint vsHandle, GLuint fsHandle )
{
    GLint  linked ;
    GLuint handle = glCreateProgram() ;

    glAttachShader            ( handle, vsHandle ) ;
    glAttachShader            ( handle, fsHandle ) ;
    glLinkProgram             ( handle ) ;
    glGetProgramiv            ( handle, GL_LINK_STATUS, & linked ) ;

    if ( !linked )
    {
        showShaderInfo ( "Linking", handle ) ;
        fprintf ( stderr, "Failed to link shader program.\n" ) ;
        exit ( 1 ) ;
    }

    return handle ;
}

void init()
{
    // The color to put in the buffer object
    const GLfloat color[4] = { 1, 1, 0, 1 };     // Yellow
    //const GLfloat color[4] = { 1, 0, 0, 1 };     // Red
    //const GLfloat color[4] = { 0, 1, 1, 1 };     // Cyan

    const size_t  size = sizeof( color );

    // Generate and fill buffer object
    GLuint buffer;

    glGenBuffers   ( 1, &buffer );
    glBindBuffer   ( GL_TEXTURE_BUFFER, buffer );
    glBufferData   ( GL_TEXTURE_BUFFER, size, NULL, GL_STATIC_DRAW );  // Alloc
    glBufferSubData( GL_TEXTURE_BUFFER, 0, size, color );              // Fill

    // Generate texture "wrapper" around buffer object
    GLuint tex;

    glGenTextures  ( 1, &tex );
    glActiveTexture( GL_TEXTURE0 );
    glBindTexture  ( GL_TEXTURE_BUFFER, tex );
    glTexBuffer    ( GL_TEXTURE_BUFFER, GL_RGBA32F, buffer );
}


int main ( int argc, char **argv )
{
    // Init GL context
    glutInit            ( &argc, argv ) ;
    glutInitDisplayMode ( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE ) ;
    glutInitWindowSize  ( 500, 500 ) ;
    glutCreateWindow    ( "Shader Test" ) ;
    glutDisplayFunc     ( display  ) ;
    glutKeyboardFunc    ( keybd    ) ;
    glutReshapeFunc     ( reshape  ) ;

    // Create buffer object and its texture buffer object wrapper
    init();

    // Load and compile shaders
    printf( "Compiling vertex shader...\n" );
    GLuint vsHandle = compileShader ( Vertex_src, GL_VERTEX_SHADER  );
    printf( "Compiling fragment shader...\n" );
    GLuint fsHandle = compileShader ( Fragment_src, GL_FRAGMENT_SHADER);

    // Link shaders
    printf( "Linking...\n" );
    GLuint handle   = linkShaders ( vsHandle, fsHandle ) ;

    // Activate shader
    glUseProgram( handle ) ;

    // Draw with shader
    glutMainLoop () ;
    return 0 ;
}