Discussion :

[BioKore]

Bonsoir à tous,

Étant en train de réaliser quelques tutos OpenGL, je demande s'il est possible de charger les bufferData d'une même VAO en plusieurs fois.
Un exemple étant plus parlant, est-il possible de faire :

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
void Mesh::bindVertices()
{
	glGenVertexArrays(1, &m_vao);
	glGenBuffers(1, &m_vbo);
	glGenBuffers(1, &m_ebo);
 
	glBindVertexArray(vao);
		glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
			glBufferData(GL_ARRAY_BUFFER, m_vertex.size() * sizeof(glm::vec3), &m_vertex[0], GL_STATIC_DRAW);
			glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
			glEnableVertexAttribArray(0);
 
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ebo);
			glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_vertexIndex.size() * sizeof(GLfloat), &m_vertexIndex[0], GL_STATIC_DRAW);
 
	glBindVertexArray(0);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}
 
 
void OtherClass::bindNormals(GLuint *vao)
{
	glGenBuffers(1, &m_nbo);
 
	glBindVertexArray(*vao);
		glBindBuffer(GL_ARRAY_BUFFER, m_nbo);
			glBufferData(GL_ARRAY_BUFFER, m_normal.size() * sizeof(glm::vec3), &m_normal[0], GL_STATIC_DRAW);
			glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
			glEnableVertexAttribArray(1);
 
	glBindVertexArray(0);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
}
 
void Renderer::mainLoop()
{
	//[...]
 
	m_mesh.bindVertices();
	m_otherObject.bindNormals(m_mesh.getVaoPtr());
 
	while(1)	// main loop
	{
		m_shader.activate();
		glBindVertexArray(m_mesh.getVao());
			glDrawElements(GL_TRIANGLES, m_mesh.getElementSize(), GL_UNSIGNED_INT, 0);
		glBindVertexArray(0);
	};
 
}

Dans le cas ci-dessus, est-ce que, au final, les normales uploadées lors de l'appel à la fonction membre "bindNormals()" seront bien prises en compte ?
En gros, est-ce que l'on peut découper ce chargement des données en X fois ?


Merci d'avance.



EDIT : si je pose cette question, c'est parce que je dois savoir si j'organise mon code de manière à tout charger d'un coup, ou si je peux me permettre de fragmenter ces chargements dans leur classe respective.

[dragonjoker59]

Salut !

Un VAO n'enregistre pas les données des buffers, il enregistre les états de binding et d'attribut de sommet.
C'est une des raisons pour laquelle j'exécre les tutoriels OpenGL, qui couplent très souvent l'initialisation des buffers avec l'initialisation du VAO.
Je préfère écrire ceci, de mon côté :

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
Mesh::Mesh( /* Les params de ton ctor */)
	: m_vbo{ GL_INVALID_INDEX }
	, m_nbo{ GL_INVALID_INDEX }
	, m_ebo{ GL_INVALID_INDEX }
	, m_vao{ GL_INVALID_INDEX }
{
	// Le contenu de ton ctor.
}
 
void Mesh::initialiseEbo()
{
	glGenBuffers(1, &m_ebo);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ebo);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_vertexIndex.size() * sizeof(GLfloat), m_vertexIndex.data(), GL_STATIC_DRAW);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}
 
void Mesh::initialiseVbo()
{
	glGenBuffers(1, &m_vbo);
	glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
	glBufferData(GL_ARRAY_BUFFER, m_vertex.size() * sizeof(glm::vec3), m_vertex.data(), GL_STATIC_DRAW);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
}
 
void Mesh::initialiseNbo()
{
	glGenBuffers(1, &m_nbo);
	glBindBuffer(GL_ARRAY_BUFFER, m_nbo);
	glBufferData(GL_ARRAY_BUFFER, m_normal.size() * sizeof(glm::vec3), m_normal.data(), GL_STATIC_DRAW);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
}
 
void Mesh::initialiseVao()
{
	glGenVertexArrays(1, &m_vao);
	glBindVertexArray(m_vao);
 
	if ( m_vbo != GL_INVALID_INDEX )
	{
		glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
		glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
		glEnableVertexAttribArray(0);
	}
 
	if ( m_nbo != GL_INVALID_INDEX )
	{
		glBindBuffer(GL_ARRAY_BUFFER, m_nbo);
		glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
		glEnableVertexAttribArray(1);
	}
 
	if ( m_ebo != GL_INVALID_INDEX )
	{
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ebo);
	}
 
	glBindVertexArray(0);
	return vao;
}
 
void Renderer::mainLoop()
{
	//[...]
 
	m_mesh.initialiseVbo();
	m_mesh.initialiseNbo(); // Ou pas, s'il n'y en a pas besoin
	m_mesh.initialiseEbo();
	m_mesh.initialiseVao();
 
	while(1)	// main loop
	{
		m_shader.activate();
		glBindVertexArray(m_mesh.getVao());
		glDrawElements(GL_TRIANGLES, m_mesh.getElementSize(), GL_UNSIGNED_INT, 0);
		glBindVertexArray(0);
	};
 
}

Ensuite, ce que tu veux faire n'a pas de sens (ou en tout cas ton exemple n'a pas de sens):
Compléter un VAO pour utiliser, lors du rendu d'un mesh, les normales d'un autre mesh ? Ca ne rime à rien.

En tout cas, ce n'est pas faisable en l'état, car un VAO ne peut être initialisé qu'une seule fois.

EDIT:

Si c'est pour splitter, crée une classe GpuBuffer à laquelle tu donnes des données
Crée une classe VertexLayout, qui te permet de définir l'organisation des données d'un sommet.
Et ensuite tu crées ton mesh avec des GpuBuffers, et un VertexLayout, et il se débrouille pour créer le VAO qui va bien.
C'est le SRP : "Single Responsibility Principle", qui dit qu'une fonction/classe ne doit faire qu'une seule chose, pour faire cette chose correctement.

[BioKore]

Merci pour ce retour, qui réponds tout à fait à ma question initiale ainsi que celle qui suivait !
Le code que tu présente ici, correspond donc exactement à ce que je souhaite faire justement.

Donc la VAO ne peut être initialisée qu'une seule fois, ok. J'imagine que dans le cas où l'on devait modifier / ajouter des choses dans la VAO, il s'agirait alors de "tout" réinitialiser ?

Enfin, concernant la forme du code présenté, il s'agissait simplement de bien faire comprendre que les deux initialisations étaient faites vraiment de manière séparée. En réalité, ce qui est présenté sous forme de "normales" représente plutôt les textures. Je dois maintenant me pencher sur le fonctionnement des textures, mais j'imagine que le fonctionnement est à peu près similaire.

Je te remercie pour ce retour.


J'ajouterais ceci : le VAO ne peut être initialisé qu'une fois, j'ai compris, mais les VBO peuvent être modifiés eux non (via glBufferSubData() si je me souviens bien, même si ce n'est pas vraiment une fonction dédiée à ça à la base) ?

[dragonjoker59]

Un VAO n'enregistre pas les données des buffers

[smarlytomtom]

Tu peux toujours changer les pointeurs de ton VAO ! Ce sont les buffers qui stockent tes données. le VAO lui retiens des pointeurs vers les buffers qui contiennent les données .

[dragonjoker59]

Coin ?
Sachant que l'on ne peut initialiser le VAO qu'une seule et unique fois, on ne peut pas changer "les pointeurs du VAO" (d'ailleurs tu veux dire quoi par là ? Les données des buffers ?)

[smarlytomtom]

Ce n'est donc pas possible ? Si on à un vbo1 et un vbo2 on ne peut pas faire :

Code :

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

1
2
3
4
5
6
 
glBindVertexArray(vao);
 
glBindBuffer(GL_ARRAY_BUFFER, vbo1);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
glEnableVertexAttribArray(0);

Et plus loin dans le code se dire qu'on veut utiliser vbo2 dans notre VAO et faire

Code :

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

1
2
3
4
5
 
glBindVertexArray(vao);
 
glBindBuffer(GL_ARRAY_BUFFER, vbo2);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);

Ce n'est pas possible ?

[dragonjoker59]

Ben non, c'est ce que je dis depuis le début.

EDIT:

Mais plus je relis la spéc, plus je me pose la question, il faudrait tester, pour savoir

[smarlytomtom]

Je ne trouve pas ça très clair non plus...
Le wiki officiel (https://www.khronos.org/opengl/wiki/...x_Array_Object) nous dit :

A VAO must be bound when calling any of those functions, and any changes caused by these function will be captured by the VAO.

Ce qui redis ce que nous avons dit plus haut, il retient l'état. Hors si on se trouve dans un cas ou l'on n'utilise pas de VAO mais que l'on utilise les pointer d'attribut alors on peut les changer comme on le souhaite à chaque draw call (lors de l'utilisation de buffer sans vertex array). Ici la citation nous dis que le VAO doit être bind pour enregistrer les changements, ce qui semble signifier que cela va au-delà de la phase d'initialisation. Je ferai le test quand j'aurai le temps .

[BioKore]

Mais par contre, on peut avoir plusieurs VAO non ? par exemple, une par modèle ?

Car tout charger dans le même VAO c'est bien, mais du coup, obliger de le recharger à chaque fois qu'un modèle est supprimé ou ajouté...

[dragonjoker59]

Oui, on peut avoir plusieurs, aucun soucis

[BioKore]

Bonjour à tous,

Alors c'est bon, j'ai pu me créer une classe Scene dans laquelle je peux charger Shader, Camera et Model. La classe Model charge les Mesh grâce à un "Parser" de mon cru. C'est donc largement optimisable, mais j'ai au moins une organisation qui ressemble plus à ce que j'attendais.
Étant donné que je pars du principe qu'un objet de classe Model peut contenir plusieurs Mesh (cette fonctionnalité reste à implémenter mais ça devrais se faire aisément), c'est donc cette classe qui s'occupe de charger la VAO. Cependant, je me demande si, finalement, initialiser la VAO dans la classe Scene serait une meilleur idée.

De même, je dois me faire une meilleur idée de la manière dont sont faits les modèles généralement (les fichiers *.obj et *.mtl). J'ai l'impression que c'est très hétéroclite à ce niveau. Tout ça pour savoir si je dois charger les matériaux dans Mesh ou dans Model.

Encore un petit pas et je pourrais enfin, je l'espère, me pencher sur les sujets concernant les matériaux justement et la lumière.

Que pensez-vous de cette dernière organisation (sachant que je souhaite conserver quelque chose de simple) ?

[smarlytomtom]

Réponse un peu tardive désolé...
Je ferais l'initialisation du VAO dans la classe Mesh (un VAO par mesh) puis je mettrais plusieurs mesh dans le Model comme tu le décris. Je ne vois pas l'avantage de réaliser le chargement dans ta classe Scene.

Après tu peux également créer une classe statique qui te permet d'initialiser et manipuler tes VAO et VBO. Dans ce cas ta classe Mesh peut devenir une simple structure qui conserve simplement les ID de tes VAO, VBO, ...etc. Je pense que c'est un choix de conception et que tu dois avant tout faire les choses de la manière qui te semble la plus appropriée pour toi. Chacun ses préférences et si tu remarques que ça ne marche pas aussi bien que tu le souhaites, tu peux toujours revenir en arrière et penser le tout autrement !

Bonne continuation !

[BioKore]

Bonjour, et merci pour ce retour, même tardif.

En ce qui concerne le sujet initial, je compte réaliser un fonctionnement totalement différent. Ayant différents projets parallèles, la solution trouvée pour l'un de mes projets semble pouvoir répondre à cette question concernant les initialisation : un ECS.

Grace à l'ECS, la question ne se pose plus, c'est un service qui va s'occuper de réaliser les initialisations. De cette manière, je suis sure que tous les éléments possédant des VBO seront initialisés en même temps. Ca me permet même de définir aisément si je veux un VAO par Mesh ou un VAO global... Je pourrais même faire un VAO par type d'objet ssi je le souhaite.

Bien entendu, tout cela reste à implémenter et à tester sur ce sujet ; je me replongerais dedans dès que j'aurais finalisé un "Pattern" ECS fiable. Je reviendrais faire part de mes résultats.

Merci encore.