sdl-opengl-glcxx-glm/app.cc

#include <SDL.h>
#include <stdio.h>
#include "glcxx.hpp"
#include "GL3/gl3w.h"
#include <iostream>
#include "glm/glm.hpp"
#include "glm/gtc/matrix_transform.hpp"

using namespace std;

std::shared_ptr<glcxx::Program> program;
std::shared_ptr<glcxx::Buffer> cube_buffer;
std::shared_ptr<glcxx::Array> cube_array;
static struct
{
    GLint ambient;
    GLint specular;
    GLint shininess;
    GLint tex;
    GLint projection;
    GLint modelview;
} uniforms;
glm::mat4 modelview;
glm::mat4 projection;
std::shared_ptr<glcxx::Texture> texture;
GLubyte texture_data[16][16][4];

#define WIDTH   800
#define HEIGHT  800

bool init(void)
{
    glClearColor (0.0, 0.0, 0.0, 0.0);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_CULL_FACE);
#if 0
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
#endif
    glViewport(0, 0, WIDTH, HEIGHT);
    try
    {
        program = glcxx::Program::create(
            glcxx::Shader::create_from_file(GL_VERTEX_SHADER, "cube.v.glsl"),
            glcxx::Shader::create_from_file(GL_FRAGMENT_SHADER, "cube.f.glsl"),
            "position", 0,
            "normal", 1,
            "tex_coord", 2);
        uniforms.ambient = program->get_uniform_location("ambient");
        uniforms.specular = program->get_uniform_location("specular");
        uniforms.shininess = program->get_uniform_location("shininess");
        uniforms.tex = program->get_uniform_location("tex");
        uniforms.projection = program->get_uniform_location("projection");
        uniforms.modelview = program->get_uniform_location("modelview");

        cube_buffer = glcxx::Buffer::create(GL_ARRAY_BUFFER, GL_STATIC_DRAW,
                                            {-1, -1, 1,  0, 0, 1,  0, 0,
                                              1, -1, 1,  0, 0, 1,  1, 0,
                                              1,  1, 1,  0, 0, 1,  1, 1,
                                             -1,  1, 1,  0, 0, 1,  0, 1});
        cube_array = glcxx::Array::create();
        cube_array->bind();
        cube_buffer->bind();
        glEnableVertexAttribArray(0);
        glEnableVertexAttribArray(1);
        glEnableVertexAttribArray(2);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), NULL);
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void *)(3 * sizeof(GLfloat)));
        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void *)(6 * sizeof(GLfloat)));

        projection = glm::perspective((float)(60.0 * M_PI / 180.0), (float)WIDTH / (float)HEIGHT, 0.1f, 1000.0f);

        for (int i = 0; i < 16; i++)
        {
            for (int j = 0; j < 16; j++)
            {
                if (((j / 2) & 1) == ((i / 2) & 1))
                {
                    texture_data[i][j][0] = 255;
                    texture_data[i][j][1] = 255;
                    texture_data[i][j][2] = 255;
                    texture_data[i][j][3] = 255;
                }
                else
                {
                    texture_data[i][j][0] = 100;
                    texture_data[i][j][1] = 100;
                    texture_data[i][j][2] = 100;
                    texture_data[i][j][3] = 100;
                }
            }
        }

        texture = glcxx::Texture::create();
        glActiveTexture(GL_TEXTURE0);
        texture->bind(GL_TEXTURE_2D);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, &texture_data[0][0][0]);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    }
    catch (glcxx::Error & e)
    {
        cerr << "glcxx error: " << e.what() << endl;
        return false;
    }
    return true;
}

static void draw_cube()
{
    static const struct
    {
        int counts;
        float axis[3];
    } rotations[] = {
        {0, {0, 0, 0}},
        {1, {1, 0, 0}},
        {2, {1, 0, 0}},
        {3, {1, 0, 0}},
        {1, {0, 1, 0}},
        {3, {0, 1, 0}},
    };

    glm::mat4 modelview_backup = modelview;

    program->use();
    cube_array->bind();

    glUniform4f(uniforms.ambient, 0.2, 0.2, 0.2, 0.2);
    glUniform4f(uniforms.specular, 1.0, 1.0, 1.0, 1.0);
    glUniform1f(uniforms.shininess, 150.0);
    glUniform1i(uniforms.tex, 0);
    glUniformMatrix4fv(uniforms.projection, 1, GL_FALSE, &projection[0][0]);

    for (int i = 0; i < sizeof(rotations) / sizeof(rotations[0]); i++)
    {
        if (rotations[i].counts > 0)
        {
            modelview = glm::rotate(modelview_backup,
                                    (float)(M_PI / 2.0 * rotations[i].counts),
                                    glm::vec3(rotations[i].axis[0],
                                              rotations[i].axis[1],
                                              rotations[i].axis[2]));
        }
        glUniformMatrix4fv(uniforms.modelview, 1, GL_FALSE, &modelview[0][0]);
        glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
    }

    modelview = modelview_backup;
}

void display(SDL_Window * window)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    modelview = glm::lookAt(glm::vec3(-1, -8, 7),
                            glm::vec3(0, 0, 0),
                            glm::vec3(0, 0, 1));
    modelview = glm::rotate(modelview, (float)(SDL_GetTicks() / 1000.0), glm::vec3(0, 0, 1));
    modelview = glm::translate(modelview, glm::vec3(3, 0, 0));

    draw_cube();

    SDL_GL_SwapWindow(window);
}

static SDL_Event UpdateEvent;

static Uint32 UpdateCallback(Uint32 interval, void * param)
{
    SDL_PushEvent(&UpdateEvent);
    return interval;
}

int main(int argc, char *argv[])
{
    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER))
    {
        printf("Failed to initialize SDL!\n");
        return 1;
    }

    atexit(SDL_Quit);

    SDL_Window * window = SDL_CreateWindow(argv[0],
                                           SDL_WINDOWPOS_UNDEFINED,
                                           SDL_WINDOWPOS_UNDEFINED,
                                           WIDTH,
                                           HEIGHT,
                                           SDL_WINDOW_OPENGL);
    if (!window)
    {
        printf("Failed to create window!\n");
        SDL_Quit();
        return 2;
    }

    SDL_GLContext gl_context = SDL_GL_CreateContext(window);

    if (gl3wInit())
    {
        cerr << "Failed to initialize GL3W" << endl;
        return 2;
    }
    if (!gl3wIsSupported(3, 0))
    {
        cerr << "OpenGL 3.0 is not supported!" << endl;
        return 2;
    }

    if (!init())
    {
        return 2;
    }

    UpdateEvent.type = SDL_USEREVENT;
    UpdateEvent.user.code = 0;
    SDL_AddTimer(25, UpdateCallback, NULL);
    display(window);
    SDL_Event event;
    while (SDL_WaitEvent(&event))
    {
        if (event.type == SDL_QUIT)
            break;
        else if (event.type == SDL_KEYDOWN)
        {
            if (event.key.keysym.sym == SDLK_ESCAPE)
                break;
            if (event.key.keysym.sym == SDLK_RETURN)
                display(window);
        }
        else if (event.type == SDL_USEREVENT)
        {
            display(window);
        }
    }
}