__Heaven__, в вас отличный стиль оформления примеров! Я просто добавляю ваши новые классы к вашему проекту (всё, как вы задумали). Огромное спасибо за проделанную работу

Я же правильно понимаю, что при обычном рисовании треугольников через glBegin мы получаем нормали перпендикулярно поверхности примитива?
Если правильно, то получается, зачем мне менять нормали поверхностей тетраэдра, из которых состоит модель. А точнее даже треугольников, из которых состоит оболочка этой модели.
Пока что я рассматриваю OpenGL как инструмент простейшего отображения в пространстве, а не инструмент для получения красивых картинок игрового качества. Для КЭ можно вообще не использовать освещение если вы отобразите сетку поверх модели.

Ну да, в том и идея. Меня раздражает иметь несколько открытых проектов. Мне легче закомментировать класс в main.

И без vao работает. Что это такое и зачем это надо?

C++ (Qt)
    QOpenGLVertexArrayObject* vao = new QOpenGLVertexArrayObject(this);
    vao->bind();
 

vao и vbo - это штучки для засылки данных на видеокарту, чтобы они там сидели. Заслав раз можно просто их юзать снова и снова, что существенно быстрее. Иначе при каждом рисовании происходит перегонка данных CPU -> GPU

Оригинальные примеры без vao не работают. Предполагаю, что эта вещь тоже как-то автоматом создаётся.
Правильно ли я понимаю, что vao это тоже, что и glList?

Прикручиваем геометрический шейдер

C++ (Qt)
#include "tessellatedgstri.h"
#include <QOpenGLShader>
#include <QOpenGLShaderProgram>
#include <QOpenGLVertexArrayObject>
 
TessellatedGsTri::TessellatedGsTri(QWidget *parent) :
    QGLWidget(parent)
{
    setWindowTitle("Tessellated Geometry Shader Triangle");
}
 
void TessellatedGsTri::initializeGL()
{
    glClearColor(0.0f, 0.25f, 0.0f, 1.0f);
    const char * vs_source =
        "#version 420 core                                                 \n"
        "                                                                  \n"
        "void main(void)                                                   \n"
        "{                                                                 \n"
        "    const vec4 vertices[] = vec4[](vec4( 0.25, -0.25, 0.5, 1.0),  \n"
        "                                   vec4(-0.25, -0.25, 0.5, 1.0),  \n"
        "                                   vec4( 0.25,  0.25, 0.5, 1.0)); \n"
        "                                                                  \n"
        "    gl_Position = vertices[gl_VertexID];                          \n"
        "}                                                                 \n";
 
    const char * fs_source =
        "#version 420 core                             \n"
        "                                              \n"
        "out vec4 color;                               \n"
        "                                              \n"
        "void main(void)                               \n"
        "{                                             \n"
        "    color = vec4(0.0, 0.8, 1.0, 1.0);         \n"
        "}                                             \n";
 
    const char * tcs_source =
        "#version 420 core                                                                 \n"
        "                                                                                  \n"
        "layout (vertices = 3) out;                                                        \n"
        "                                                                                  \n"
        "void main(void)                                                                   \n"
        "{                                                                                 \n"
        "    if (gl_InvocationID == 0)                                                     \n"
        "    {                                                                             \n"
        "        gl_TessLevelInner[0] = 5.0;                                               \n"
        "        gl_TessLevelOuter[0] = 5.0;                                               \n"
        "        gl_TessLevelOuter[1] = 5.0;                                               \n"
        "        gl_TessLevelOuter[2] = 5.0;                                               \n"
        "    }                                                                             \n"
        "    gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;     \n"
        "}                                                                                 \n";
 
    const char * tes_source =
        "#version 420 core                                                                 \n"
        "                                                                                  \n"
        "layout (triangles, equal_spacing, cw) in;                                         \n"
        "                                                                                  \n"
        "void main(void)                                                                   \n"
        "{                                                                                 \n"
        "    gl_Position = (gl_TessCoord.x * gl_in[0].gl_Position) +                       \n"
        "                  (gl_TessCoord.y * gl_in[1].gl_Position) +                       \n"
        "                  (gl_TessCoord.z * gl_in[2].gl_Position);                        \n"
        "}                                                                                 \n";
 
    static const char * gs_source =
            "#version 420 core                                                                  \n"
            "                                                                                   \n"
            "layout (triangles) in;                                                             \n"
            "layout (points, max_vertices = 3) out;                                             \n"
            "                                                                                   \n"
            "void main(void)                                                                    \n"
            "{                                                                                  \n"
            "    int i;                                                                         \n"
            "                                                                                   \n"
            "    for (i = 0; i < gl_in.length(); i++)                                           \n"
            "    {                                                                              \n"
            "        gl_Position = gl_in[i].gl_Position;                                        \n"
            "        EmitVertex();                                                              \n"
            "    }                                                                              \n"
            "}                                                                                  \n";
 
    QOpenGLShader* fs = new QOpenGLShader(QOpenGLShader::Fragment, this);
    fs->compileSourceCode(fs_source);
 
    QOpenGLShader* vs = new QOpenGLShader(QOpenGLShader::Vertex, this);
    vs->compileSourceCode(vs_source);
 
    QOpenGLShader* tcs = new QOpenGLShader(QOpenGLShader::TessellationControl, this);
    tcs->compileSourceCode(tcs_source);
 
    QOpenGLShader* tes = new QOpenGLShader(QOpenGLShader::TessellationEvaluation, this);
    tes->compileSourceCode(tes_source);
 
    QOpenGLShader* gs = new QOpenGLShader(QOpenGLShader::Geometry, this);
    gs->compileSourceCode(gs_source);
 
    program = new QOpenGLShaderProgram(this);
    program->addShader(vs);
    program->addShader(tcs);
    program->addShader(tes);
    program->addShader(gs);
    program->addShader(fs);
    program->link();
 
    glPointSize(5.0f);
 
    QOpenGLVertexArrayObject* vao = new QOpenGLVertexArrayObject(this);
    vao->bind();
    program->bind();
}
 
void TessellatedGsTri::paintGL()
{
    glClear(GL_COLOR_BUFFER_BIT);
    glDrawArrays(GL_PATCHES, 0, 3);
}
 
void TessellatedGsTri::resizeGL(int w, int h)
{
    glViewport(0, 0, w, h);
}
 

По-моему, это единственная книга на русском по GLSL: http://www.ozon.ru/context/detail/id/2619774/

Вот здесь можно скачать книгу и диск к книге: http://www.twirpx.com/file/1134216/

Из содержания: