Upload des buffers en plusieurs fois

**BioKore** · 10/02/2019, 22h28

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** · 10/02/2019, 23h22

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** · 10/02/2019, 23h42

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** · 11/02/2019, 01h47

Envoyé par dragonjoker59

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

**smarlytomtom** · 11/02/2019, 23h52

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** · 12/02/2019, 00h13

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** · 12/02/2019, 09h26

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 ?

Upload des buffers en plusieurs fois

OpenGL

Vue hybride

Discussions similaires

Partager

Partager