OpenGL Test

//The headers
#include "SDL.h"
#include "SDL_opengl.h"

//Screen attributes
const int SCREEN_WIDTH = 640;
const int SCREEN_HEIGHT = 480;
float time;

//Event handler
SDL_Event event;

//Scary shit
PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObjectARB = NULL;
PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB = NULL;
PFNGLSHADERSOURCEARBPROC glShaderSourceARB = NULL;
PFNGLCOMPILESHADERARBPROC glCompileShaderARB = NULL;
PFNGLATTACHOBJECTARBPROC glAttachObjectARB = NULL;
PFNGLLINKPROGRAMARBPROC glLinkProgramARB = NULL;
PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB = NULL;
PFNGLUNIFORM2FARBPROC glUniform2fARB = NULL;
PFNGLUNIFORM1FARBPROC glUniform1fARB = NULL;
PFNGLVERTEXATTRIBPOINTERARBPROC glVertexAttribPointerARB = NULL;
PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocationARB = NULL;
//PFNGLENABLEVERTEXATTRIBARRAYARBPROC glEnableVertexAttribArrayARB = NULL;
//PFNGLDISABLEVERTEXATTRIBARRAYARBPROC glDisableVertexAttribArrayARB = NULL;

extern PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObjectARB;
extern PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB;
extern PFNGLSHADERSOURCEARBPROC glShaderSourceARB;
extern PFNGLCOMPILESHADERARBPROC glCompileShaderARB;
extern PFNGLATTACHOBJECTARBPROC glAttachObjectARB;
extern PFNGLLINKPROGRAMARBPROC glLinkProgramARB;
extern PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB;
extern PFNGLUNIFORM2FARBPROC glUniform2fARB;
extern PFNGLUNIFORM1FARBPROC glUniform1fARB;
extern PFNGLVERTEXATTRIBPOINTERARBPROC glVertexAttribPointerARB;
extern PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocationARB;
//extern PFNGLENABLEVERTEXATTRIBARRAYARBPROC glEnableVertexAttribArrayARB;
//extern PFNGLDISABLEVERTEXATTRIBARRAYARBPROC glDisableVertexAttribArrayARB;

//Shader stuff
GLenum shader_vert = 0;
GLenum shader_frag = 0;
GLenum shader_prog = 0;
//GLenum shader_buff = 0;
GLint uniform_location;
GLint uniform_time;
//GLint buffer;

char* shader_vert_source =
    "attribute vec3 position;"
    "void main() {"
    "   gl_Position = vec4(position, 1.0);"
    "}";

char* shader_frag_source =
    "uniform float time;"
    "uniform vec2 resolution;"
    "void main(void) {"
    "   vec2 position = -1.0 + 2.0 * gl_FragCoord.xy / resolution.xy;"
    "   float red = abs(sin(position.x * position.y + time / 5.0));"
    "   float green = abs(sin(position.x * position.y + time / 4.0));"
    "   float blue = abs(sin(position.x * position.y + time / 3.0));"
    "   gl_FragColor = vec4(red, green, blue, 1.0);"
    "}";

//The timer
class Timer
{
    private:
    //The clock time when the timer started
    int startTicks;

    public:
    //Initializes variables
    Timer();

    //The various clock actions
    void start();

    //Gets the timer's time
    int get_ticks();
};

bool init_GL()
{
    //Set clear color
    glClearColor(0, 0, 0, 0);

    //Set projection
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, -1, 1);

    //Initialize modelview matrix
    glMatrixMode(GL_MODELVIEW);
    glEnable(GL_TEXTURE_2D);
    glLoadIdentity();

    //If there was any errors
    if (glGetError() != GL_NO_ERROR)
    {
        return false;
    }

    //If everything initialized
    return true;
}

bool init()
{
    //Initialize SDL
    if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
    {
        return false;
    }

    //Create Window
    if (SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, 32, SDL_HWSURFACE | SDL_GL_DOUBLEBUFFER | SDL_OPENGL) == NULL)
    {
        return false;
    }

    //Initialize OpenGL
    if (!init_GL())
    {
        return false;
    }

    //Set caption
    SDL_WM_SetCaption("OpenGL Test", NULL);

    glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC) SDL_GL_GetProcAddress("glCreateProgramObjectARB");
    glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC) SDL_GL_GetProcAddress("glCreateShaderObjectARB");
    glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC) SDL_GL_GetProcAddress("glShaderSourceARB");
    glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC) SDL_GL_GetProcAddress("glCompileShaderARB");
    glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC) SDL_GL_GetProcAddress("glAttachObjectARB");
    glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC) SDL_GL_GetProcAddress("glLinkProgramARB");
    glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC) SDL_GL_GetProcAddress("glUseProgramObjectARB");
    glUniform2fARB = (PFNGLUNIFORM2FARBPROC) SDL_GL_GetProcAddress("glUniform2fARB");
    glUniform1fARB = (PFNGLUNIFORM1FARBPROC) SDL_GL_GetProcAddress("glUniform1fARB");
    glVertexAttribPointerARB = (PFNGLVERTEXATTRIBPOINTERARBPROC) SDL_GL_GetProcAddress("glVertexAttribPointerARB");
    glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC) SDL_GL_GetProcAddress("glGetUniformLocationARB");
    //glEnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARBPROC) SDL_GL_GetProcAddress("glEnableVertexAttribArrayARB");
    //glDisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARBPROC) SDL_GL_GetProcAddress("glDisableVertexAttribArrayARB");

    shader_prog = glCreateProgramObjectARB();
    shader_vert = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
    shader_frag = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
    //shader_buff = glCreateShaderObjectARB(GL_PIXEL_PACK_BUFFER_ARB);

    int len = 0;
    len = strlen(shader_vert_source);
    glShaderSourceARB(shader_vert, 1, (const GLcharARB**)&shader_vert_source, &len);
    len = strlen(shader_frag_source);
    glShaderSourceARB(shader_frag, 1, (const GLcharARB**)&shader_frag_source, &len);

    glCompileShaderARB(shader_vert);
    glCompileShaderARB(shader_frag);
    glAttachObjectARB(shader_prog, shader_vert);
    glAttachObjectARB(shader_prog, shader_frag);
    glLinkProgramARB(shader_prog);

    return true;
}

Timer::Timer()
{
    //Initialize the variables
    startTicks = 0;
}

void Timer::start()
{
    //Get the current clock time
    startTicks = SDL_GetTicks();
}

int Timer::get_ticks()
{
    //Return the current time minus the start time
    return SDL_GetTicks() - startTicks;
}

int main (int argc, char *argv[])
{
    //Quit flag
    bool quit = false;

    //Initialize
    if (!init())
    {
        return 1;
    }

    //The frame rate regulator
    Timer fps;

    //Wait for user exit
    while (!quit)
    {
        //Start the frame timer
        fps.start();

        //While there are events to handle
        while (SDL_PollEvent(&event))
        {
            if (event.type == SDL_QUIT)
            {
                quit = true;
            }
        }

        //Clear the screen
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        //Render single quad on the screen
        glLoadIdentity();
        glUseProgramObjectARB(shader_prog);

        glUniform1fARB(glGetUniformLocationARB(shader_prog, "time"), time++ / 100);
        glUniform2fARB(glGetUniformLocationARB(shader_prog, "resolution"), (float)SCREEN_WIDTH, (float)SCREEN_HEIGHT);

        //glNormalPointer(shader_buff, 0, (char *) buffer);
        //glVertexAttribPointerARB(vertex_position, 2, GL_FLOAT, GL_FALSE, 0, 0);
        //glEnableVertexAttribArrayARB(vertex_position);
        glRects(-1, -1, 1, 1);
        //glDisableVertexAttribArrayARB(vertex_position);

        //Update screen
        SDL_GL_SwapBuffers();

        //Cap the frame rate
        if (fps.get_ticks() < 1000 / 60)
        {
            SDL_Delay((1000 / 60) - fps.get_ticks());
        }
    }

    //Clean up
    SDL_Quit();

    return 0;
}