Geometry shader, impossible de dessiner un rectangle

**LittleWhite** · 16/10/2021, 07h41

Je me suis peut être mal exprimé. Il n'y a pas de tampons automatique qui se modifie tout seul suivant tel ou tel paramètre.
Ce que je voulais dire, c'est qu'il existe plusieurs mécanismes (tampons ou autres) pour transférer des données du CPU au GPU. Et pour certains tampons, vous allez pouvoir spécifié un usage (streaming (mise à jour du contenu par le CPU souvent) ou fixe (mise à jour par le CPU rare)). Du coup, il ne faut pas avoir peur d'avoir des tampons que vous devez modifiés souvent. Par contre, il faut bien organisé son code pour diminuer ce comportement (mais cela fait parti du cadre des optimisations et vous ne devriez pas vous en soucier pour le moment).

**KevinduC** · 16/10/2021, 14h55

Est-ce que vous faites référence aux fonctions telles que glMapBuffer() ?

**LittleWhite** · 16/10/2021, 18h51

Oui, plus précisément, les options de glBufferData().
D'ailleurs, j'avais le mot stream en tête, mais il y a DYNAMIC, qui est pour les cas où l'on modifie les données très souvent.

**KevinduC** · 16/10/2021, 18h58

Aaaahhhh vous voulez parler de ça :

Code :

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

glBufferData(GL_ARRAY_BUFFER,arbres.positions.size()*sizeof(float)+arbres.attribNumtex.size()*sizeof(int),nullptr,GL_STREAM_DRAW);

**LittleWhite** · 16/10/2021, 20h15

Oui et avec ça, vous signaler à votre GPU ce que vous allez faire de votre tampon. Notamment, si vous allez le mettre à jour souvent, chose qui est possible et qui vous permet de faire des choses "dynamiques".

**KevinduC** · 22/10/2021, 20h09

Ok merci pour l'info

**KevinduC** · 25/10/2021, 17h25

Je me permets de relancer la discussion : Comment faire pour éviter que le GPU soit saturé en utilisation ? Il est utilisé à environ 80% et si je fais le rendu de mes arbres (Avec une technique d'instanciation cette fois) ça peut monter à près de 90% voire près de 100% si je rajoute des branches, ce qui fait ramer le programme.

**Mat.M** · 25/10/2021, 18h14

Envoyé par KevinduC

En fait je voudrais faire l'équivalent de ceci mais de manière optimisée :

vaste question que je me pose également.
Si vous avez 10000arbres ça fait beaucoup à afficher ; il y a la solution des quadtrees ou octrees c'est peut être une solution je ne l'ai pas encore creusée.

**KevinduC** · 25/10/2021, 23h06

Justement je n'en affiche que 363 pour le moment ...

J'essaie de n'afficher que les arbres les plus proches de la caméra en faisant appel à glMapBuffer() mais la fonction me renvoie systématiquement un pointeur null.

Est-ce qu'il y aurait qqchose de problématique dans ce code ?

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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
void tree::TreesArea::InitVBO(void)
{
    GLuint bufferVRAM;
 
    glGenVertexArrays(1,model.getVAO());
    glGenBuffers(1,&bufferVRAM);
 
    glBindVertexArray(*model.getVAO());
    glBindBuffer(GL_ARRAY_BUFFER,bufferVRAM);
 
    glBufferData(GL_ARRAY_BUFFER,model.getCoordVertex().size()*sizeof(float)+
                                 model.getCoordTex().size()*sizeof(float)+
                                 model.getNormals().size()*sizeof(float)+
                                 model.getNumtex().size()*sizeof(int)+
                                 positions.size()*sizeof(float)+
                                 scales.size()*sizeof(float)+
                                 rotates.size()*sizeof(float),nullptr,GL_DYNAMIC_DRAW);
 
    glBufferSubData(GL_ARRAY_BUFFER,0,model.getCoordVertex().size()*sizeof(float),&model.getCoordVertex()[0]);
    glBufferSubData(GL_ARRAY_BUFFER,model.getCoordVertex().size()*sizeof(float),model.getCoordTex().size()*sizeof(float),&model.getCoordTex()[0]);
    glBufferSubData(GL_ARRAY_BUFFER,model.getCoordVertex().size()*sizeof(float)+model.getCoordTex().size()*sizeof(float),model.getNormals().size()*sizeof(float),&model.getNormals()[0]);
    glBufferSubData(GL_ARRAY_BUFFER,model.getCoordVertex().size()*sizeof(float)+model.getCoordTex().size()*sizeof(float)+model.getNormals().size()*sizeof(float),model.getNumtex().size()*sizeof(int),&model.getNumtex()[0]);
    glBufferSubData(GL_ARRAY_BUFFER,model.getCoordVertex().size()*sizeof(float)+model.getCoordTex().size()*sizeof(float)+model.getNormals().size()*sizeof(float)+model.getNumtex().size()*sizeof(int),positions.size()*sizeof(float),&positions[0]);
    glBufferSubData(GL_ARRAY_BUFFER,model.getCoordVertex().size()*sizeof(float)+model.getCoordTex().size()*sizeof(float)+model.getNormals().size()*sizeof(float)+model.getNumtex().size()*sizeof(int)+positions.size()*sizeof(float),scales.size()*sizeof(float),&scales[0]);
    glBufferSubData(GL_ARRAY_BUFFER,model.getCoordVertex().size()*sizeof(float)+model.getCoordTex().size()*sizeof(float)+model.getNormals().size()*sizeof(float)+model.getNumtex().size()*sizeof(int)+positions.size()*sizeof(float)+scales.size()*sizeof(float),rotates.size()*sizeof(float),&rotates[0]);
	//Ecriture coordonnées de sommets, coordonnées de texture, normales, index de texture, positions, échelles et angles de rotation
 
    glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,3*sizeof(float),(void*)0);
    glEnableVertexAttribArray(0);
 
    glVertexAttribPointer(1,2,GL_FLOAT,GL_FALSE,2*sizeof(float),(void*)(model.getCoordVertex().size()*sizeof(float)));
    glEnableVertexAttribArray(1);
 
    glVertexAttribPointer(2,3,GL_FLOAT,GL_FALSE,3*sizeof(float),(void*)(model.getCoordVertex().size()*sizeof(float)+model.getCoordTex().size()*sizeof(float)));
    glEnableVertexAttribArray(2);
 
    glVertexAttribIPointer(3,1,GL_INT,sizeof(int),(void*)(model.getCoordVertex().size()*sizeof(float)+model.getCoordTex().size()*sizeof(float)+model.getNormals().size()*sizeof(float)));
    glEnableVertexAttribArray(3);
 
    glVertexAttribPointer(4,3,GL_FLOAT,GL_FALSE,3*sizeof(float),(void*)(model.getCoordVertex().size()*sizeof(float)+model.getCoordTex().size()*sizeof(float)+model.getNormals().size()*sizeof(float)+model.getNumtex().size()*sizeof(int)));
    glEnableVertexAttribArray(4);
 
    glVertexAttribPointer(5,1,GL_FLOAT,sizeof(float),GL_FALSE,(void*)(model.getCoordVertex().size()*sizeof(float)+model.getCoordTex().size()*sizeof(float)+model.getNormals().size()*sizeof(float)+model.getNumtex().size()*sizeof(int)+positions.size()*sizeof(float)));
    glEnableVertexAttribArray(5);
 
    glVertexAttribPointer(6,1,GL_FLOAT,sizeof(float),GL_FALSE,(void*)(model.getCoordVertex().size()*sizeof(float)+model.getCoordTex().size()*sizeof(float)+model.getNormals().size()*sizeof(float)+model.getNumtex().size()*sizeof(int)+positions.size()*sizeof(float)+scales.size()*sizeof(float)));
    glEnableVertexAttribArray(6);
 
    glVertexAttribDivisor(4,1);
    glVertexAttribDivisor(5,1);
    glVertexAttribDivisor(6,1);
 
	//Config attributs
 
    glBindBuffer(GL_ARRAY_BUFFER,0);
    glBindVertexArray(0);
}
 
void tree::TreesArea::Draw(glm::mat4 &modelMat,glm::mat4 &viewMat,glm::mat4 &projectionMat,const glm::vec2 &posCam,const float distMax)
{
    glUseProgram(shader);
 
    glUniformMatrix4fv(glGetUniformLocation(shader,"projection"),1,false,glm::value_ptr(projectionMat));
    glUniformMatrix4fv(glGetUniformLocation(shader,"modele"),1,false,glm::value_ptr(modelMat));
    glUniformMatrix4fv(glGetUniformLocation(shader,"vue"),1,false,glm::value_ptr(viewMat));
	//Envoi matrices au vertex shader
 
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D,model.getTexWood());
 
    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D,model.getTexLeaf());
 
    glUniform1i(glGetUniformLocation(shader,"texWood"),0);
    glUniform1i(glGetUniformLocation(shader,"texLeaf"),1);
	//Envoi texture au fragment shader
 
    glBindVertexArray(*model.getVAO());
	//Bindage VAO
 
    CamCulling(posCam,distMax);
	//Culling (Inopérant pour le moment)
 
    glDrawArraysInstanced(GL_TRIANGLES,0,model.getCoordVertex().size()/3,positions.size());
	//Rendu
 
    glBindVertexArray(0);
    glActiveTexture(GL_TEXTURE0);
}
 
void tree::TreesArea::CamCulling(const glm::vec2 &posCam,const float distMax)
{
    float *dataGPU=(float*)glMapBuffer(GL_ARRAY_BUFFER,GL_READ_WRITE);
	//Récup contenu données (C'est là qu'il y a un problème visiblement)
 
    const unsigned int taille=model.getCoordVertex().size()*sizeof(float)+
                              model.getCoordTex().size()*sizeof(float)+
                              model.getNormals().size()*sizeof(float)+
                              model.getNumtex().size()*sizeof(int)+
                              positions.size()*sizeof(float)+
                              scales.size()*sizeof(float)+
                              rotates.size()*sizeof(float);
 
    //for(int i=0;i<positions.size();i++)
    for(int i=0;i<taille;i++)
    {
        //std::cout << dataGPU[i] << std::endl;
    }
 
    std::cout << dataGPU << std::endl;		//Affiche systématiquement "0"
 
    glUnmapBuffer(GL_ARRAY_BUFFER);
}

Edit : J'ai résolu ce problème, il faut appeler glBindBuffer() et non glBindVertexArray() avant glMapBuffer() mais ce n'est pas gagné pour autant car je n'arrive pas à retrouver les coordonnées des positions des arbres avec ce code :

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
void tree::TreesArea::CamCulling(const glm::vec2 &posCam,const float distMax)
{
    glBindBuffer(GL_ARRAY_BUFFER,*model.getBufferVRAM());
 
    float *dataGPU=(float*)glMapBuffer(GL_ARRAY_BUFFER,GL_WRITE_ONLY);
 
    float *ptr=dataGPU+(model.getCoordVertex().size()*sizeof(float)+
                        model.getCoordTex().size()*sizeof(float)+
                        model.getNormals().size()*sizeof(float)+
                        model.getNumtex().size()*sizeof(int));
 
    for(int i=0;i<positions.size();i++)
    {
        std::cout << ptr[i] << std::endl;		//Je n'obtiens pas les bonnes valeurs ici
    }
    std::cout << std::endl;
 
    glUnmapBuffer(GL_ARRAY_BUFFER);
 
    glBindBuffer(GL_ARRAY_BUFFER,0);
}

Pourtant, dans le VBO les coordonnées des positions des instances sont situées juste après le tableau d'index de textures. Au passage puisque j'en parle ce tableau d'index de textures est constitué d'entiers et non de flottants, alors est-ce qu'il est vraiment judicieux de déclarer "dataGPU" comme un pointeur sur float ?
Je voudrais préciser au passage que j'ai fait une erreur dans le rendu :

Code :

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

glDrawArraysInstanced(GL_TRIANGLES,0,model.getCoordVertex().size()/3,positions.size());

C'est en réalité :

Code :

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

glDrawArraysInstanced(GL_TRIANGLES,0,model.getCoordVertex().size()/3,positions.size()/3);

Car il y a trois coordonnées par position d'arbre dans le tableau "positions"

**LittleWhite** · 26/10/2021, 19h46

L'affichage dans une console, c'est ultra lent. Donc, tant que vous faites des std::cout dans votre boucle de rendu, vous pouvez oublier les performances*.
De plus, votre boucle pour afficher les positions, elle est fausse. Vous calculez un décalage dans le tampon, de la taille de vos quatre tampons. Et après, vous affichez (sur la console) N floats. Pour moi, vous vous trouvez après la fin de votre tampon.
Aussi, on ne voit pas comment vous copiez les données dans le tampon GPU

.

* Pour le débogage, utilisez des outils dédiés, comme celui de NVIDIA, comme Nsight ( https://developer.download.nvidia.co...ging_Intro.htm ).

**KevinduC** · 26/10/2021, 19h51

C'est parce qu'il y a dans l'ordre :

- Les coordonnées de sommets
- Les coordonnées de texture
- Les normales
- Les index de texture (Selon s'il s'agit d'une texture d'écorce ou de feuille)
- Les positions des instances
- Les échelles des instances
- Les angles de rotation des instances

Ce décalage sert à obtenir l'adresse à partir de laquelle on peut accéder au premier élément du tableau "position" qui contient la position de chaque instance et pour cela j'ajoute à la valeur de mon pointeur la taille des tableaux qui précèdent "position".

Edit : J'ai résolu ce problème finalement : Il faut déclarer un pointeur de type void* :

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
void tree::TreesArea::CamCulling(const glm::vec2 &posCam,const float distMax)
{
    glBindBuffer(GL_ARRAY_BUFFER,*model.getBufferVRAM());
 
    void *dataGPU=glMapBuffer(GL_ARRAY_BUFFER,GL_WRITE_ONLY);
 
    void *ptr=dataGPU+(model.getCoordVertex().size()*sizeof(float)+
                       model.getCoordTex().size()*sizeof(float)+
                       model.getNormals().size()*sizeof(float)+
                       model.getNumtex().size()*sizeof(int));
 
    for(int i=0;i<3;i++)
    {
        std::cout << ((float*)ptr)[i] << std::endl;
    }
    std::cout << std::endl;
 
    glUnmapBuffer(GL_ARRAY_BUFFER);
 
    glBindBuffer(GL_ARRAY_BUFFER,0);
}

Ça veut dire qu'il faut faire un transtypage lors de l'utilisation du pointeur.
J'ai bien les coordonnées de mes instances.

**LittleWhite** · 26/10/2021, 20h43

Hum, j'avais un doute sur cette possibilité. Avez-vous retrouvé vos performances ? Autrement, généralement, on fait de l'entrelaçage. Dans le sens, on a dans le tampon :

sommet1, texcoord1, normale1, sommet2, textcoord2, normale2, sommet3...

J'aurais pensé que cela puisse être mieux pour les caches, mais il ne faut pas pré-optimisé. Sinon, le tampon d'indice est généralement séparé.

**KevinduC** · 26/10/2021, 21h02

Pour le moment plus je mets d'arbres moins il y a de performance.

Edit : J'ai réussi à faire fonctionner le culling, il ne faut pas oublier de redéfinir la taille des tableaux d'attributs :

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
void tree::TreesArea::CamCulling(const glm::vec2 &posCam,const float distMax)
{
    glBindBuffer(GL_ARRAY_BUFFER,*model.getBufferVRAM());
 
    void *dataVRAM=glMapBuffer(GL_ARRAY_BUFFER,GL_WRITE_ONLY);			//Adresse début des données
 
    void *ptr=dataVRAM+(model.getCoordVertex().size()*sizeof(float)+	//Adresse début des attributs d'instances
                        model.getCoordTex().size()*sizeof(float)+
                        model.getNormals().size()*sizeof(float)+
                        model.getNumtex().size()*sizeof(int));
 
    std::vector<float> positions2,scales2,rotates2;				//Tableaux pour copies provisoires
 
    for(int i=0,j=0;i<positions.size();i+=3,j++)
    {
        const glm::vec3 pos=glm::vec3(positions[i],positions[i+1],positions[i+2]);
        const float distCam=sqrt(pow(posCam.x-pos.x,2.0f)+pow(posCam.y-pos.y,2.0f));
 
        const float scl=scales[j];
        const float rot=rotates[j];
 
        if(distCam<=distMax)				//On ne récupère que les attributs des arbres proches de la caméra
        {
            positions2.push_back(pos.x);
            positions2.push_back(pos.y);
            positions2.push_back(pos.z);
 
            scales2.push_back(scl);
            rotates2.push_back(rot);
        }
    }
 
    std::vector<float> majData=positions2;		//Fusion des tableaux en un seul
 
    for(int i=0;i<scales2.size();i++)
    {
        majData.push_back(scales2[i]);
    }
 
    for(int i=0;i<rotates2.size();i++)
    {
        majData.push_back(rotates2[i]);
    }
 
    nbTrees=positions2.size()/3;			//Mise à jour nombre d'instances
 
    memcpy(ptr,(void*)(&majData[0]),majData.size()*sizeof(float));		//Copie des nouveaux attributs en mémoire
 
    glUnmapBuffer(GL_ARRAY_BUFFER);
 
    glBindVertexArray(*model.getVAO());
 
    glVertexAttribPointer(5,1,GL_FLOAT,sizeof(float),GL_FALSE,(void*)(model.getCoordVertex().size()*sizeof(float)+model.getCoordTex().size()*sizeof(float)+model.getNormals().size()*sizeof(float)+model.getNumtex().size()*sizeof(int)+positions2.size()*sizeof(float)));
    glEnableVertexAttribArray(5);
 
    glVertexAttribPointer(6,1,GL_FLOAT,sizeof(float),GL_FALSE,(void*)(model.getCoordVertex().size()*sizeof(float)+model.getCoordTex().size()*sizeof(float)+model.getNormals().size()*sizeof(float)+model.getNumtex().size()*sizeof(int)+positions2.size()*sizeof(float)+scales2.size()*sizeof(float)));
    glEnableVertexAttribArray(6);
	//Redéfinition des tailles des tableaux d'attributs
 
    glBindVertexArray(0);
 
    glBindBuffer(GL_ARRAY_BUFFER,0);
}

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
void tree::TreesArea::Draw(glm::mat4 &modelMat,glm::mat4 &viewMat,glm::mat4 &projectionMat,const glm::vec2 &posCam,const float distMax)
{
    glUseProgram(shader);
 
    glUniformMatrix4fv(glGetUniformLocation(shader,"projection"),1,false,glm::value_ptr(projectionMat));
    glUniformMatrix4fv(glGetUniformLocation(shader,"modele"),1,false,glm::value_ptr(modelMat));
    glUniformMatrix4fv(glGetUniformLocation(shader,"vue"),1,false,glm::value_ptr(viewMat));
 
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D,model.getTexWood());
 
    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D,model.getTexLeaf());
 
    glUniform1i(glGetUniformLocation(shader,"texWood"),0);
    glUniform1i(glGetUniformLocation(shader,"texLeaf"),1);
 
    glBindVertexArray(*model.getVAO());
 
    glDrawArraysInstanced(GL_TRIANGLES,0,model.getCoordVertex().size()/3,nbTrees);
 
    glBindVertexArray(0);
    glActiveTexture(GL_TEXTURE0);
 
    CamCulling(posCam,distMax);
}

Ce n'est que la moitié du travail car il faut aussi afficher les billboards et de plus je ne sais pas comment créer ces derniers de sorte à ce qu'ils soient assez ressemblants à la version 3D

**LittleWhite** · 27/10/2021, 19h03

Pour les performances, vous devriez pencher du côté de la notion d'OpenGL zero overhead (exemple : https://www.geeks3d.com/20140321/ope...iver-overhead/ ). Sinon, vous devriez peut être utiliser un profileur.
Finalement, pour les billboard, il faut le faire que pour les arbres qui sont vraiment loin (qui ne font que 10 pixels de hauteur à l'écran

).

**KevinduC** · 27/10/2021, 19h16

Un profileur ? C'est quoi ?

**LittleWhite** · 27/10/2021, 19h24

C'est comme un débogueur de performances

. Il va surveiller/enregistrer le comportement de l'application afin de vous indiquer quelles sont les parties qui prennent le plus de temps à s'exécuter (quelles sont les fonctions où le CPU passe le plus de temps).

**KevinduC** · 27/10/2021, 19h26

C'est un logiciel ?
Sinon lorsque je vois mes programmes ramer comme ça alors que mon PC supporte GTA V je me demande où est le problème: Je suis sur OpenGL 3, j'utilise les VBO, l'instanciation ... et malgré cela le programme est lent par intermittences, il tombe à 5 FPS environ

**LittleWhite** · 27/10/2021, 19h29

Cela peut être un programme externe, comme des morceaux de code à ajouter à votre projet. Les deux existent.

**KevinduC** · 27/10/2021, 20h21

Je remarque que le programme est plus rapide si je fais un rendu normal sans instanciation. Vous êtes sûr que l'instanciation c'est vraiment efficace ?

Edit : J'essaie de voir ce qu'il se passe si je réduis le nombre de sommets dans mon mesh mais lors d'un énième essai mon PC a soudain fait un BSOD avec comme erreur "KMODE EXCEPTION NOT HANDLED", est-ce que ça aurait un rapport avec le GPU saturé selon vous ?

**Kannagi** · 28/10/2021, 04h03

Envoyé par KevinduC

C'est un logiciel ?
Sinon lorsque je vois mes programmes ramer comme ça alors que mon PC supporte GTA V je me demande où est le problème: Je suis sur OpenGL 3, j'utilise les VBO, l'instanciation ... et malgré cela le programme est lent par intermittences, il tombe à 5 FPS environ

Bah c'est le soucis d'OpenGL , il y'a 10 000 façon de faire , et souvent il y'en a qu'une seule qui est bonne.

La seconde GTA 5 n'utilise pas OpenGL 3 , mais il supporte Vulkan (et donc doit sûrement tourner sur DX 12 ) , qui sont des API bien plus adapté pour nos CG actuel.
Sinon OpenGL est lent , et les CG actuel ne le supporte plus donc y'a toujours une conversion , et il est probable que avec le temps OpenGL sera une surcouche de Vulkan.

Geometry shader, impossible de dessiner un rectangle

OpenGL

Discussions similaires

Partager

Partager