Примеры из SuperBible под Qt 5.3

[__Heaven__]

Люблю книжки от Питерского БХВ. Почитаю, спасибо.

[Igors]

А что будет с "атрибутами" (в первую очередь с нормалями и UV) для созданных вертексов? Они интерполируются автоматычно или как?

Посмотрел, подход "сам создаешь вертекс - вот и остальное все сам создавай", а в конце-концов переменные (хранящие нормали и UV) используются во фрагментном шейдере.

Что хотелось бы видеть: реальную модель (пусть очень маленькую, хоть кубик) и отследить как проходят исходные данные через pipeline. Сейчас уязвимое место - 3 координаты высосанные из пальца(?), а что делать в общем (нормальном) случае - хз. Если нужна модель (в виде массивов в cpp) - я найду

[__Heaven__]

Я буквально только вчера в википедии узнал, что есть UV.
Боюсь, что не смогу ответить на этот вопрос. По крайней мере, пока.
Вы собираетесь работать с текстурой?

[Igors]

Я буквально только вчера в википедии узнал, что есть UV.

Поверьте, точно есть 

Вы собираетесь работать с текстурой?

Ну хорошо хоть не сказали "для КЭ моделей текстура не нужна!". А серьезно - любой 3D объект как минимум имеет:

- вертексы и полигоны (могут иметь цвет для каждого)
- вертексные нормали (не путать с "нормали к граням")
- UV координаты (редко но может быть неск наборов)
- материал (набор параметров + часто текстуры)

Это практический стандарт, и как бы Вы ни крутились - рано или поздно жизнь заставит все это иметь (обычно рано). Поэтому избегать этого не нужно, да и зачем, смысла нет.

[__Heaven__]

Поверьте, точно есть 

Я имел в виду, "что это есть такое"

Ну хорошо хоть не сказали "для КЭ моделей текстура не нужна!".

До сих пор не пригодилась. Мне для отображения объема достаточно использовать один цвет.
Возможно, при выводе данных понадобится.
Спорить на эту тему не стану, у меня опыта маловато в этой области.

[__Heaven__]

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

Книжечка старой оказалась.
Автор пишет, что существует 2 вида шейдеров: вершинный и фрагментный, возможно в будущем добавятся ещё какие-нибудь

[8Observer8]

Посмотрел в документации Qt. Кроме вершинного и фрагментного появилось ещё 4. И всего в нашем распоряжении:

Код

C++ (Qt)
QOpenGLShader::Vertex
QOpenGLShader::Fragment
QOpenGLShader::Geometry
QOpenGLShader::TessellationControl
QOpenGLShader::TessellationEvaluation
QOpenGLShader::Compute
 

Надеюсь, они описаны в SuperBible. Я пока в этой книге не научился ориентироваться.

В книгу Борескова тоже заглядываю. Может там за GLSL как-то схватиться можно будет.

[__Heaven__]

Раскрашиваем фрагмент в зависимости от позиции:

Код

C++ (Qt)
#include "fragcolorfrompos.h"
#include <QOpenGLShader>
#include <QOpenGLShaderProgram>
#include <QOpenGLVertexArrayObject>
#include <QPainter>
 
FragColorFromPos::FragColorFromPos(QWidget *parent) :
    QGLWidget(parent)
{
    setWindowTitle("Fragment color from position");
    startTimer(1000);
    interpolate = false;
}
 
void FragColorFromPos::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(sin(gl_FragCoord.x * 0.25) * 0.5 + 0.5,                   \n"
            "                 cos(gl_FragCoord.y * 0.25) * 0.5 + 0.5,                   \n"
            "                 sin(gl_FragCoord.x * 0.15) * cos(gl_FragCoord.y * 0.1),   \n"
            "                 1.0);                                                     \n"
            "}                                                                          \n";
    QOpenGLShader* fs = new QOpenGLShader(QOpenGLShader::Fragment);
    fs->compileSourceCode(fs_source);
 
    QOpenGLShader* vs = new QOpenGLShader(QOpenGLShader::Vertex);
    vs->compileSourceCode(vs_source);
 
    nonInterpolateProgram = new QOpenGLShaderProgram(this);
    nonInterpolateProgram->addShader(vs);
    nonInterpolateProgram->addShader(fs);
    nonInterpolateProgram->link();
 
 
    const char * vsInterpolate_source =
        "#version 420 core                                                          \n"
        "                                                                           \n"
        "out vec4 vs_color; \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"
        "    const vec4 colors[] = vec4[](vec4(1.0, 0.0, 0.0, 1.0),                 \n"
        "                                 vec4(0.0, 1.0, 0.0, 1.0),                 \n"
        "                                 vec4(0.0, 0.0, 1.0, 1.0));                \n"
        "                                                                           \n"
        "    gl_Position = vertices[gl_VertexID];                                   \n"
        "    vs_color = colors[gl_VertexID];                                        \n"
        "}                                                                          \n";
 
    const char * fsInterpolate_source =
        "#version 420 core                                                          \n"
        "                                                                           \n"
        "in vec4 vs_color;                                                          \n"
        "out vec4 color;                                                            \n"
        "                                                                           \n"
        "void main(void)                                                            \n"
        "{                                                                          \n"
        "    color = vs_color;                                                      \n"
        "}                                                                          \n";
    fs->compileSourceCode(fsInterpolate_source);
 
    vs->compileSourceCode(vsInterpolate_source);
 
 
    interpolateProgram = new QOpenGLShaderProgram(this);
    interpolateProgram->addShader(vs);
    interpolateProgram->addShader(fs);
 
    QOpenGLVertexArrayObject* vao = new QOpenGLVertexArrayObject(this);
    vao->bind();
    nonInterpolateProgram->bind();
}
 
void FragColorFromPos::paintGL()
{
    glClear(GL_COLOR_BUFFER_BIT);
    glDrawArrays(GL_TRIANGLES, 0, 3);
}
 
void FragColorFromPos::resizeGL(int w, int h)
{
    glViewport(0, 0, w, h);
}
 
void FragColorFromPos::timerEvent(QTimerEvent *)
{
    interpolate = !interpolate;
    if (interpolate)
        interpolateProgram->bind();
    else
        nonInterpolateProgram->bind();
    updateGL();
}
 

[__Heaven__]

Только что заметил, что имена шейдеров я перепутал (interpolate), но суть остается той же.

[8Observer8]

Красиво! Но меня GLSL вгоняет в тоску. Вообще не понимаю. Например:
1) Что это означает: "out vec4 vs_color;" Как я понял, это массив, элементы, которого это тоже массив из 4 элементов. Каждый элемент означает цвет: red, green, glue, и коэффициент альфа. И теперь этот массив цветов вершин доступен другим шейдерам с помощью ключевого слова "out". И теперь шейдер фрагментов получает его на вход "in vec4 vs_color;", инициализирует переменную "color = vs_color;" и эту переменную делает доступной для других шейдеров: "out vec4 color;" Вопрос: зачем её делают открытой, то есть выходной (out) если она без типа, а значит она служебная (глобальная), как gl_Position
2) Вот эта строчка непонятна: "gl_Position = vertices[gl_VertexID];" Получается, что справа мы получаем элемент массива. Что этот элемент из себя представляет (предполагаю, что элемент массива - это вектор координат одной из вершин)? Что такое gl_VertexID я так и не понял. Слева вообще непонятная переменная gl_Position. Где она объявлена? Что ей присваивается на самом деле?
3) Почему для координат используется 4 числа?

[__Heaven__]

Я пробую изучать котроль версий, так что если кто-то желает... https://github.com/dsbabkov/sb6.git

Красиво! Но меня GLSL вгоняет в тоску. Вообще не понимаю. Например:
1) Что это означает: "out vec4 vs_color;" Как я понял, это массив, элементы, которого это тоже массив из 4 элементов. Каждый элемент означает цвет: red, green, glue, и коэффициент альфа. И теперь этот массив цветов вершин доступен другим шейдерам с помощью ключевого слова "out". И теперь шейдер фрагментов получает его на вход "in vec4 vs_color;", инициализирует переменную "color = vs_color;" и эту переменную делает доступной для других шейдеров: "out vec4 color;" Вопрос: зачем её делают открытой, то есть выходной (out) если она без типа, а значит она служебная (глобальная), как gl_Position
2) Вот эта строчка непонятна: "gl_Position = vertices[gl_VertexID];" Получается, что справа мы получаем элемент массива. Что этот элемент из себя представляет (предполагаю, что элемент массива - это вектор координат одной из вершин)? Что такое gl_VertexID я так и не понял. Слева вообще непонятная переменная gl_Position. Где она объявлена? Что ей присваивается на самом деле?
3) Почему для координат используется 4 числа?

1) vec4 это float[4]. out это вывод из вершинного шейдера во фрагментный, из фрагментного на экран (в данном примере).

Код:

out vec4 color

Переменная color не без типа и она не служебная.
2) gl_Position - служебная переменная. Её тип vec4. vertices - массив vec4

Код:

const vec4 vertices[] = vec4[](vec4( 0.25, -0.25, 0.5, 1.0)
vec4(-0.25, -0.25, 0.5, 1.0),
vec4( 0.25,  0.25, 0.5, 1.0));

В данном случае размер массива 3 (точки). Для каждой точки определены координаты x, y, z и w.
gl_VertexID - некая служебная переменная, подвергаемая инкременту. Начало и конец задаётся с помощью

Код

C++ (Qt)
glDrawArrays(GL_TRIANGLES, 0, 3);

В данном случае от 0 инкрементируя 3 раза, то есть от 0 до 2.
3) http://stackoverflow.com/questions/2422750/in-opengl-vertex-shaders-what-is-w-and-why-do-i-divide-by-it

[__Heaven__]

меня GLSL вгоняет в тоску. Вообще не понимаю

Не хватайтесь вы за GLSL.
Хорошие картинки для desktop можно рисовать и с устаревшими OpenGL функциями.
Рекомендую к прочтению первых четырёх-пяти глав 3его издания, что на русском языке.
Так хотя бы появится какое-то базовое представление.
Мне очень помогло. Сейчас я не знаю, как бы без этих знаний воспринимал данные примерчики.
В 6 издании, я заметил, материал как-то менее разжеван по сравнению с 3.

Далее, чувствую, пойдут умножения матриц на вектора - там точно будет тёмный лес.

[8Observer8]

Спасибо, за подробный ответ! Буду по мере сил пытаться вникать в ваши примеры и изучу первые пять глав из 3-ого издания.

1) Каковы функции шейдеров? Из книжки я, как пользователь, ничего не понял. Если я хочу сделать квартиру (для начала, без мебели) по которой я могу ходить и смотреть планировку, каковы будут функции каждого из шейдеров?
2) Можно сказать, что управление камерой можно возложить на какой-то из шейдеров?

P.S. Вот статья попалась, вроде неплохая: http://habrahabr.ru/post/206156/ (посмотрел статью, ничего непонятно, оставлю на будущее)

[__Heaven__]

1) Каковы функции шейдеров? Из книжки я, как пользователь, ничего не понял. Если я хочу сделать квартиру (для начала, без мебели) по которой я могу ходить и смотреть планировку, каковы будут функции каждого из шейдеров?
2) Можно сказать, что управление камерой можно возложить на какой-то из шейдеров?

1) Функции шейдеров следуют из их названий. Вершинный заведует вершинами, фрагментный - фрагментами. Если вы хотите нарисовать коробку, предположим из прямоугольных фрагментов, то вам необходимо в вершинном шейдере задать вершины каждого прямоугольника, то есть по 4 вершины на каждый фрагмент. В коробке 6 сторон (прямоугольных фрагментов), значит коробка состоит из 6*4=24 вершин. То есть в каждом её углу имеется 3 вершины с одинаковыми координатами. Вершинный шейдер назначает координаты вершин. Далее фрагментный шейдер рисует между группами по 4 вершины так называемый GL_QUAD определённого цвета. (тут могу ошибаться)
2) как таковой камеры, наверное, в OpenGL не существует. Можно передать в вершинный шейдер матрицу преобразований, которая будет умножаться на координаты вершин в результате чего будет получена желаемая трансляция, поворот и увеличение. Грубо говоря, вы вращаете мир вокруг своего экрана.

Начните с 3 издания. Там всё это очень доступно описано.

[8Observer8]

__Heaven__, большое спасибо!