Discussion :

[Aratox]

Bonjour,

J'ai besoin de passer un tableau de 256 entiers dans la mémoire global de mes shader et je n'y parvient pas.

J'ai tenté d'utiliser un Uniform Buffer Object.

EDIT : Voir la totalité 2 post plus bas

Voila mon code c++ (résumé)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
PFNGLGETUNIFORMBLOCKINDEXPROC glGetUniformBlockIndex = 0;
PFNGLUNIFORMBLOCKBINDINGPROC glUniformBlockBinding = 0;
glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC) ctx->getProcAddress("glGetUniformBlockIndex"); // Ok : non nul
glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC) ctx->getProcAddress("glUniformBlockBinding"); // Ok : non nul
...
// p est mon ShaderProgram (il est compilé et linké)
GLuint uniformIndex = glGetUniformBlockIndex(p.programId(), "perm0");
...
QGLBuffer ubo((QGLBuffer::Type)GL_UNIFORM_BUFFER); // Création du buffer
ubo.create(); // Retourne true
ubo.bind(); // Retourne true
ubo.allocate(256 * sizeof (GLint));
ubo.release();
...
GLint perm[256];
initRandomPerm(perm, 256);
ubo.bind(); // Retourne true
ubo.write(0, perm, 256 * sizeof (GLint));
glUniformBlockBinding(p.programId(), uniformIndex, 0);
ubo.release();
// ici je dessine des rectangles...

Et voila le code de mon fichier vertex

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
#version 140
in vec2 vertex;
 
uniform perm0
{
    int perm[256];
};
 
void main(void)
{
    ...
    int gi0 = perm[(ii + perm[jj]) % 256] % 8; // A partir d'ici je ne peux pas verifier mais d'après le résultat qui est de couleur uniforme, perm ne contient pas les bonnes valeurs
    ...
}

Je n'ai plus aucune piste pour résoudre mon problème.
Un peu d'aide serait la bienvenue.

A+

[LastSpear]

Bonjours,


Tu n'a pas fais attention à l'alignement des donnés ... il faut spécifié le std140 sur l'uniforme dans le shader, et tu crée un tableau en C non pas de 256 int mais de 1024 int, dont tu vient modifié simplement les indice 0, 4, 8, ... , 4*N pour que les valeur qui devait être à l'indice N dans le shader.

[Aratox]

Salut,
Ok pour le std140, par contre l'histoire de 4 je comprends pas d’où sa sort... Et d’ailleurs si je veux maintenant envoyer des vec4 il faut aussi les dupliquer 4 fois ?
J'ai fait un projet minimal pour essayer de faire fonctionner (au moins une fois) un UBO.
Mais c'est pas encore sa.

glwidget.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#ifndef GLWIDGET_H
#define GLWIDGET_H
 
#include <QtOpenGL/QGLWidget>
#include <QtOpenGL/QGLShaderProgram>
#include <QtOpenGL/QGLBuffer>
 
class GLWidget : public QGLWidget
{
    Q_OBJECT
 
public:
    GLWidget(QWidget *parent = 0);
    ~GLWidget();
 
protected:
    void initializeGL();
    void resizeGL(int w, int h);
    void paintGL();
 
private:
    QGLShaderProgram *_shader;
    QGLBuffer _uniformBuffer;
};
 
#endif // GLWIDGET_H

glwidget.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#include "glwidget.h"
#include <QDebug>
 
GLWidget::GLWidget(QWidget *parent)
    : QGLWidget(parent),
      _uniformBuffer((QGLBuffer::Type)GL_UNIFORM_BUFFER)
{
}
 
GLWidget::~GLWidget()
{
    delete _shader;
}
 
void GLWidget::initializeGL()
{
    _shader = new QGLShaderProgram(context(), this);
    _shader->addShaderFromSourceFile(QGLShader::Vertex, ":/glsl.vert");
    _shader->addShaderFromSourceFile(QGLShader::Fragment, ":/glsl.frag");
    _shader->bindAttributeLocation("vertex", 0);
    _shader->link();
    _shader->bind();
 
 
    const QGLContext *ctx = context();
    PFNGLGETUNIFORMBLOCKINDEXPROC glGetUniformBlockIndex = 0;
    PFNGLUNIFORMBLOCKBINDINGPROC glUniformBlockBinding = 0;
    glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC) ctx->getProcAddress("glGetUniformBlockIndex");
    glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC) ctx->getProcAddress("glUniformBlockBinding");
    if (glGetUniformBlockIndex == 0 || glUniformBlockBinding == 0)
        qDebug("ERROR getProcAddress");
 
    GLuint uniformIndex = glGetUniformBlockIndex(_shader->programId(), "test");
    qDebug() << uniformIndex << (glGetError() == GL_NO_ERROR);
 
    static GLfloat const triangleColors[] = {
        1.0f, 0.0f, 0.0f, 1.0f,
        0.0f, 1.0f, 0.0f, 1.0f,
        0.0f, 0.0f, 1.0f, 1.0f
    };
    _uniformBuffer.create();
    _uniformBuffer.bind();
    _uniformBuffer.allocate(triangleColors, 3 * 4 * sizeof (GLfloat));
    glUniformBlockBinding(_shader->programId(), uniformIndex, 0);
    _uniformBuffer.release();
}
 
void GLWidget::resizeGL(int w, int h)
{
    glViewport(0, 0, w, h);
}
 
void GLWidget::paintGL()
{
    glClear(GL_COLOR_BUFFER_BIT);
 
    static GLfloat const triangleVertices[] = {
        0.0,    1.0,   0.0,    1.0,
        -1.0,   0.0,   0.0,    1.0,
        1.0,   -1.0,   0.0,    1.0,
    };
    _shader->setAttributeArray(0, triangleVertices, 4);
 
    _shader->enableAttributeArray(0);
    glDrawArrays(GL_TRIANGLES, 0, 3);
    _shader->disableAttributeArray(0);
}

glsl.vert

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#version 150
in vec4 vertex;
 
layout(std140) uniform test
{
    vec4 vertexColor[3];
};
 
out vec4 color;
 
void main(void)
{
    gl_Position = vertex;
 
    int i = int(vertex.x) + 1;
    color = vertexColor[i];
}

glsl.frag

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
#version 150
in vec4 color;
 
out vec4 fragColor;
 
void main(void)
{
    fragColor = color;
}

[LastSpear]

En vérité, c'est que les cartes graphiques utilisent essentiellement des registres 128bit pour pouvoir faire des opération vectoriel le plus rapidement possible. Donc il faut impérativement aligné sur 128bit les informations dans un uniform buffer. Mais pour des vec4, ce sont 4 float donc 4x32 bit = 128 bit, donc c'est alignement est respecté et le souci disparait tout simplement.

Voici ci dessous 3 exemples de tableau dans un uniform buffer avec des int, des vec2 et vec4 pour bien montré ce qu'est l'alignement.

Tableau d'integer

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
// GLSL
layout(std140) uniform test
{
    int IntegerArray[2];
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
// chaque lignes représente une zone de 128 bits de l'uniform buffer
 IntegerArray[0] | unused 32 bit | unused 32 bit | unused 32 bit
 IntegerArray[1] | unused 32 bit | unused 32 bit | unused 32 bit

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
// C/C++
int Array[2 * 4];

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
// chaque lignes représente une zone de 128 bits de l'uniform buffer
 Array[0] | Array[1] | Array[2] | Array[3]
 Array[4] | Array[5] | Array[6] | Array[7]

Vouala pourquoi lorsque tu créé un tableau d'intèger, il en faut 4x plus, et il faudra utilisé que les multiple de 4. Parce que la dans cet exemple, on voit bienque Array[1], Array[2], Array[3], Array[5], Array[6], Array[7] ne serviront pas.


Tableau de vec2

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
// GLSL
layout(std140) uniform test
{
    vec2 Vector2Array[2];
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
// chaque lignes représente une zone de 128 bits de l'uniform buffer
 Vector2Array[0].x | Vector2Array[0].y | unused 32 bit | unused 32 bit
 Vector2Array[1].x | Vector2Array[1].y | unused 32 bit | unused 32 bit

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
// C/C++
float2 Array[2 * 2];

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
// chaque lignes représente une zone de 128 bits de l'uniform buffer
 Array[0].x | Array[0].y | Array[1].x | Array[1].y
 Array[2].x | Array[2].y | Array[3].x | Array[3].y

Là il en faut 2x plus, et il faudra utilisé que les multiple de 2. Parce que la dans cet exemple, on voit bienque Array[1] et Array[3] ne serviront pas.

Tableau de vec4

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
// GLSL
layout(std140) uniform test
{
    vec4 Vector4Array[2];
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
// chaque lignes représente une zone de 128 bits de l'uniform buffer
 Vector4Array[0].x | Vector4Array[0].y | Vector4Array[0].z | Vector4Array[0].w
 Vector4Array[1].x | Vector4Array[1].y | Vector4Array[1].z | Vector4Array[1].w

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
// C/C++
float4 Array[2];

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
// chaque lignes représente une zone de 128 bits de l'uniform buffer
 Array[0].x | Array[0].y | Array[0].z | Array[0].w
 Array[1].x | Array[1].y | Array[1].z | Array[1].w

Là, plus besoin de se soucier d'alignement, car la taille des float4 est de 128 bit.

EXPLICITATION de float2 et float4

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
class float2
{
public:
    float x, y ;
 
};
 
class float4
{
public:
    float x, y, z, w ;
 
};

En espérant avoir aidé.

[Aratox]

Merci beaucoup pour cette explication très détaillée ! J'en demandais pas tant
Par contre, malheureusement, le code que j'ai posté ne fonctionne pas, en tout cas sur ma carte graphique...
Si quelqu'un qui utilise Qt pourrait voir si sa fonctionne chez lui ?
Histoire de savoir si c'est une question de code ou de hardware.

[LittleWhite]

Bonjour,

Merci beaucoup pour cette explication très détaillée ! J'en demandais pas tant
Par contre, malheureusement, le code que j'ai posté ne fonctionne pas, en tout cas sur ma carte graphique...
Si quelqu'un qui utilise Qt pourrait voir si sa fonctionne chez lui ?
Histoire de savoir si c'est une question de code ou de hardware.

Pour le test, pouvez vous donner le projet dans une archive avec le .pro, s'il vous plait.