ShadersPassColor

#define GLFW_INCLUDE_GLCOREARB      // сообщаем, что хотим использовать Core функционал

#include <iostream>
#include <GLFW/glfw3.h>

using namespace std;


/* выполняется, если произошла ошибка в работе GLFW */
void errorCallback(int errorCode, const char* errorDescription);

/* начальные установки для OpenGL */
void setupGL();

/* компилирует шейдер */
GLuint compileShader(const GLchar ** source, GLenum type);

/* создает шейдерную программу */
GLuint createProgram(const GLchar ** vertexShaderSource, const GLchar ** fragmentShaderSource);

/* генерирует и биндит Vertex Array Object */
void generateAndBindVao();

/* прорисовывает объекты */
void render();


GLFWwindow *window = nullptr;           // указатель на объект окна
int windowWidth = 500;                  // высота окна
int windowHeight = 500;                 // ширина окна
const char* title = "First Triangle";   // заглавие окна
GLFWmonitor* monitor = nullptr;         // указатель на объект монитора
GLFWwindow* share = nullptr;            // указатель на объект окна для совмесного использования
const int logSize = 256;                // размер лога
const float pointSize = 10.0f;          // размер отображаемой точки

const GLchar* vertexZeroSource[] =
{
    "#version 410                                               \n"
    "                                                           \n"
    "void main(void)                                            \n"
    "{                                                          \n"
    "   gl_Position = vec4(0.0, 0.0, 0.0, 1.0);                 \n"
    "}                                                          \n"
};

const GLchar* vertexTriangleSource[] =
{
    "#version 410                                               \n"
    "                                                           \n"
    "void main(void)                                            \n"
    "{                                                          \n"
    "   switch (gl_VertexID)                                    \n"
    "   {                                                       \n"
    "       case 0:                                             \n"
    "           gl_Position = vec4(0.0, 0.5, 0.0, 1.0);         \n"
    "           break;                                          \n"
    "       case 1:                                             \n"
    "           gl_Position = vec4(0.5, -0.4, 0.0, 1.0);        \n"
    "           break;                                          \n"
    "       case 2:                                             \n"
    "           gl_Position = vec4(-0.5, -0.4, 0.0, 1.0);       \n"
    "           break;                                          \n"
    "   }                                                       \n"
    "                                                           \n"
    "}                                                          \n"
};

const GLchar* vertexTriangleColorSource[] =
{
    "#version 410                                               \n"
    "                                                           \n"
    "out vec4 colorFromVertex;                                  \n"
    "                                                           \n"
    "void main(void)                                            \n"
    "{                                                          \n"
    "   switch (gl_VertexID)                                    \n"
    "   {                                                       \n"
    "       case 0:                                             \n"
    "           gl_Position = vec4(0.0, 0.5, 0.0, 1.0);         \n"
    "           colorFromVertex = vec4(1.0, 0.0, 0.0, 1.0);     \n"
    "           break;                                          \n"
    "       case 1:                                             \n"
    "           gl_Position = vec4(0.5, -0.4, 0.0, 1.0);        \n"
    "           colorFromVertex = vec4(0.0, 1.0, 0.0, 1.0);     \n"
    "           break;                                          \n"
    "       case 2:                                             \n"
    "           gl_Position = vec4(-0.5, -0.4, 0.0, 1.0);       \n"
    "           colorFromVertex = vec4(0.0, 0.0, 1.0, 1.0);     \n"
    "           break;                                          \n"
    "   }                                                       \n"
    "}                                                          \n"
};

const GLchar* fragmentColorSource[] =
{
    "#version 410                                               \n"
    "                                                           \n"
    "in vec4 colorFromVertex;                                   \n"
    "                                                           \n"
    "out vec4 color;                                            \n"
    "                                                           \n"
    "void main(void)                                            \n"
    "{                                                          \n"
    "   color = colorFromVertex;                                \n"
    "}                                                          \n"
};

const GLchar* fragmentWhiteSource[] =
{
    "#version 410                                               \n"
    "                                                           \n"
    "out vec4 color;                                            \n"
    "                                                           \n"
    "void main(void)                                            \n"
    "{                                                          \n"
    "   color = vec4(1.0, 1.0, 1.0, 1.0);                       \n"
    "}                                                          \n"
};

int main(int argc, const char * argv[])
{
    /* регистрируем колбек для вывода ошибок */
    glfwSetErrorCallback(errorCallback);

    /* инициализация GLFW */
    if(!glfwInit())
    {
        /* завершаем приложение с неудачный статусом выполнения,
         если не удалось инициализировать GLFW */
        exit(EXIT_FAILURE);
    }

    /* подсказки для GLFW */
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);                  // какую версию OpenGL использовать
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);                  // младшая версия
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);  // какой профиль использовать (Core Profile или Compatibility Profile)
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);            // использовать ли Forward Compatibility

    /* пытаемся создать объект окна */
    window = glfwCreateWindow(windowWidth, windowHeight, title, monitor, share);

    if(!window)
    {
        /* завершаем работу GLFW */
        glfwTerminate();

        /* выход из программы с неудачный статусом выполнения */
        exit(EXIT_FAILURE);
    }

    /* делаем начальные настройки */
    setupGL();

    /* основной цикл приложения, выполняется пока окно не будет закрыто */
    while(!glfwWindowShouldClose(window))
    {
        /* прорисовываем объекты */
        render();

        /* меняем местами передний и задний буфферы */
        glfwSwapBuffers(window);

        /* опрос событий */
        glfwPollEvents();
    }

    /* завершаем работу GLFW */
    glfwTerminate();

    /* выход из программы с удачный статусом выполнения */
    exit(EXIT_SUCCESS);
}

void errorCallback(int errorCode, const char* errorDescription)
{
    /* вывод сообщения ошибки в поток ошибок */
    fputs(errorDescription, stderr);
    fputs("\n", stderr);
}

void setupGL()
{
    /* устанавливаем размер точки */
    glPointSize(pointSize);

    /* устанавливаем цвет очистки экнана */
    glClearColor(0.5f,0.5f,0.5f,1.0f);

    /* создаем шейдернуую программу */
    GLuint program = createProgram(vertexTriangleColorSource, fragmentColorSource);

    /* используем созданную программу */
    glUseProgram(program);

    /* генерируем и биндим VAO */
    generateAndBindVao();
}

void compileShader(const GLuint shader, const GLchar ** source)
{
    /* указываем исходник для шейдера */
    glShaderSource(shader, 1, source, NULL);

    /* компилируем шейдер */
    glCompileShader(shader);

    GLint status;        // статус компиляции
    GLchar log[logSize];    // лог компиляции

    /* получаем статус компиляции шейдера */
    glGetShaderiv(shader, GL_COMPILE_STATUS, &status);

    /* проверяем статус компиляции */
    if (status == GL_FALSE)
    {
        /* если компиляция не удалась, то выводим сообщение об ошибку */
        fputs("ERROR: Program compiling failed!", stderr);
        fputs("\n", stderr);
    }

    /* получаем лог шейдера */
    glGetShaderInfoLog(shader, logSize, NULL, log);

    /* выводим лог */
    fputs(log, stdout);
}

GLuint createProgram(const GLchar ** vertexShaderSource, const GLchar ** fragmentShaderSource)
{
    /* создаем вершинный и фрагментный шейдеры */
    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);

    /* компилируем вершинный и фрагментный шейдеры */
    compileShader(vertexShader, vertexShaderSource);
    compileShader(fragmentShader, fragmentShaderSource);

    /* создаем шейдерную программу */
    GLuint program = glCreateProgram();

    /* прикрепляем шейдеры к программе */
    glAttachShader(program, vertexShader);
    glAttachShader(program, fragmentShader);

    /* линкуем программу */
    glLinkProgram(program);

    GLint status;        // статус линковки
    GLchar log[logSize];    // лог линковки

    /* получаем статус линковки шейдера */
    glGetProgramiv(program, GL_LINK_STATUS, &status);

    /* проверяем статус линковки */
    if (status == GL_FALSE)
    {
        /* если линковка не удалась, то выводим сообщение об ошибку */
        fputs("ERROR: Program linking failed!", stderr);
        fputs("\n", stderr);
    }

    /* получаем лог программы */
    glGetProgramInfoLog(program, logSize, NULL, log);

    /* выводим лог */
    fputs(log, stderr);

    /* удаляем шейдеры */
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    return program;
}

void generateAndBindVao()
{
    GLuint vao; // Vartex Array Object

    /* генерируем VAO */
    glGenVertexArrays(1, &vao);

    /* биндим VAO */
    glBindVertexArray(vao);
}

void render()
{
    /* очищаем буффер цвета */
    glClear(GL_COLOR_BUFFER_BIT);

    /* прорисовываем объект */
    glDrawArrays(GL_TRIANGLES, 0, 3);
}