SDLTest1

#include "stdio.h"
#include "stdlib.h"

#include "GL/glew.h"
#include "SDL.h"

const int WIDTH = 640;
const int HEIGHT = 480;
const int SLEEP = 10;

SDL_Window* p_Window;
SDL_GLContext p_Context;
bool gl_running;

SDL_Event event;

GLuint g_shVert;
GLuint g_shFrag;
GLuint g_shProg;

GLuint g_vao;
GLuint g_vbo;

bool init_context()
{
    if(SDL_Init(SDL_INIT_EVERYTHING) == -1)
    {
        fprintf(stderr, "Unable to init SDL: %s\n", SDL_GetError());
        return false;
    }

    unsigned int flags = SDL_WINDOW_OPENGL|SDL_WINDOW_SHOWN;

    SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);

    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4);

    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);

    p_Window = SDL_CreateWindow("OpenGL 3.2 Test", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, WIDTH, HEIGHT, flags);

    if(!p_Window)
    {
        fprintf(stderr, "Unable to create SDL Window: %s\n", SDL_GetError());
        return false;
    }

    p_Context = SDL_GL_CreateContext(p_Window);

    if(!p_Context)
    {
        fprintf(stderr, "Could not create OpenGL 3.2 context: %s\n", SDL_GetError());
        return false;
    }

    SDL_GL_SetSwapInterval(1);

    return true;
}

void create_shaders()
{
    char shErr[1024];
    int errlen;
    GLint res;

    const char* vert_src =
                        "#version 330\n"
                        "in vec2 position;\n"
                        "void main()\n"
                        "{\n"
                        "   gl_Position = vec4(position.x, position.y, 0.0f, 1.0f);\n"
                        "}";

    const char* frag_src =
                        "#version 330\n"
                        "out vec4 out_Col;\n"
                        "void main()\n"
                        "{\n"
                        "   out_Col = vec4(1.0f, 0.25f, 0.75f, 1.0f);\n"
                        "}";

    g_shVert = glCreateShader(GL_VERTEX_SHADER);
    g_shFrag = glCreateShader(GL_FRAGMENT_SHADER);
    g_shProg = glCreateProgram();

    glShaderSource(g_shVert, 1, &vert_src, NULL);
    glShaderSource(g_shFrag, 1, &frag_src, NULL);

    glCompileShader(g_shVert);
    glCompileShader(g_shFrag);

    glGetShaderiv(g_shVert, GL_COMPILE_STATUS, &res);
    if(res == GL_FALSE)
    {
        fprintf(stderr, "Failed to compile vertex shader.\n");
        glGetShaderInfoLog(g_shVert, 1024, &errlen, shErr);
        printf("%s\n", shErr);
        return;
    }

    glGetShaderiv(g_shFrag, GL_COMPILE_STATUS, &res);
    if(res == GL_FALSE)
    {
        fprintf(stderr, "Failed to compile fragment shader.\n");
        glGetShaderInfoLog(g_shFrag, 1024, &errlen, shErr);
        printf("%s\n", shErr);
        return;
    }

    glAttachShader(g_shProg, g_shVert);
    glAttachShader(g_shProg, g_shFrag);

    glDeleteShader(g_shVert);
    glDeleteShader(g_shFrag);

    glLinkProgram(g_shProg);
    glGetProgramiv(g_shProg, GL_LINK_STATUS, &res);
    if(res == GL_FALSE)
        fprintf(stderr, "Failed to link program.\n");

    glUseProgram(g_shProg);
}

void create_vao()
{
    const float trian[6] =
        {
            -0.25f, -0.25f,
            0.50f, -0.25f,
            0.50f, 0.50f
        };

    glGenVertexArrays(1, &g_vao);
    glBindVertexArray(g_vao);

    glGenBuffers(1, &g_vbo);
    glBindBuffer(GL_ARRAY_BUFFER, g_vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(float)*6, trian, GL_STATIC_DRAW);
    glVertexAttribPointer((GLuint)0, 2, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(0);
}

bool init_opengl()
{
    GLenum err;
    if((err = glewInit()) != GLEW_OK)
    {
        fprintf(stderr, "Could not init GLEW:%s\n", glewGetErrorString(err));
        return false;
    }

    create_shaders();
    create_vao();

    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    glClearDepth(1.0f);

    glViewport(0, 0, WIDTH, HEIGHT);

    return true;
}

void render()
{
    glDrawArrays(GL_TRIANGLES, 0, 3);
}

void check_events()
{
    while(SDL_PollEvent(&event))
    {
        switch(event.type)
        {
            case SDL_KEYDOWN:
                                if((SDLK_ESCAPE) == (event.key.keysym.sym))
                                    gl_running = false;
                                break;
            case SDL_QUIT:
                                    gl_running = false;
                                break;
        }
    }
}

void run()
{
    gl_running = true;
    while(gl_running == true)
    {
        check_events();

        render();

        SDL_GL_SwapWindow(p_Window);

        SDL_Delay(SLEEP);
    }
}



void release()
{
    SDL_GL_DeleteContext(p_Context);
    SDL_DestroyWindow(p_Window);
    SDL_Quit();
}

int main(int argc, char* argv[])
{
    if(init_context() == false)
        return 1;

    if(init_opengl() == false)
    {
        release();
        return 1;
    }

    run();

    release();

    return 0;
}