Comportement bizarre d'une méthode

Version imprimable

Bonsoir tout le monde,

j'ai un petit souci concernant le passage d'un tableau en paramètre dans une méthode pour un usage externe (en dehors de la méthode main), le contenu de cette méthode se comporte bizarrement, et j'avoue que ça me laisse songeur si je dois poster ce problème dans la rubrique (OpenGL) ou (C++ débutant) vu que je me sens vraiment impliqué par la seconde. Voici le code pour que vous puissiez bien comprendre :

Code:

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
 
void methodeA(const float (&vertices)[6])
{
	GLuint vao;
    GLuint vbo;
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);
 
    glGenBuffers(1, &vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
 
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(0);
 
    glBindVertexArray(0);
}
 
 
void methodeB()
{
    const float vertices[]={0.0f,  0.5f,0.5f, -0.5f,-0.5f, -0.5f};
 
    GLuint vao;
    GLuint vbo;
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);
 
    glGenBuffers(1, &vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
 
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(0);
 
    glBindVertexArray(0);
}
 
 
void methodeC(const float vertices[])
{
	GLuint vao;
    GLuint vbo;
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);
 
    glGenBuffers(1, &vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
 
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(0);
 
    glBindVertexArray(0);
}
 
 
void methodeD(const float* vertices)
{
	GLuint vao;
    GLuint vbo;
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);
 
    glGenBuffers(1, &vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
 
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(0);
 
    glBindVertexArray(0);
}
 
int main()
{
 
    /************************CODE**********************************/
 
     const float vertices[]={0.0f,  0.5f,0.5f, -0.5f,-0.5f, -0.5f};
 
     methodeA(vertices);  //Fonctionne correctement (passage par référence)
     methodeB();          //Fonctionne correctement (vertices à l'intérieur de la méthode)
     methodeC(vertices);  //Ne fonctionne pas (passage par copie tableau normal array[])
     methodeD(vertices);  //Ne fonctionne pas (passage par copie tableau pointeur array*)
 
    /************************CODE***********************************/
 
	return 0;
}

Pour mieux comprendre mon problème, j'ai essayé 4 méthodes pour gérer les (VAOs/VBOs) et dessiner un triangle, seul la 1ere et la 2eme ont fonctionné, et j'ignore pourquoi ce n'est pas le cas deux autres. qu'est ce qui ne va pas d'après vous avec ces deux dernières ? Merci pour votre aide :P

Salut!

Pour commencer, en C++ on n'utilisera pas les tableaux statiques (ou dynamiques) du C.
On utilisera std::array pour les tableaux statiques (ou std::vector pour les tableaux dynamiques), ce sont des classes qui facilitent plusieurs choses, et l'une de ces choses est leur passage en tant que paramètre.

Ensuite, tes méthodes C et D sont en fait la même chose, car un tableau statique C est passé en paramètre d'une fonction en tant que pointeur, et ce que tu écrives void foo(const float p[]), void foo(const float p[10]) ou void foo(const float * p).
Et ton problème se situe là, en fait.
Car sizeof(p) renvoie alors la taille d'un pointeur, qui vaut 4 sur un programme compilé en 32 bits, et 8 sur un programme compilé en 64bits.
Du coup tu ne copies pas toutes les données de ton buffer, mais uniquement les 4 (ou 8) premiers octets (ce qui, tu l'auras remarqué, ne correspond pas du tout à la taille de ton buffer).

Donc, au final, j'utiliserais un équivalent de ta méthode A, avec un std::vector (parce que généralement on ne connait pas à l'avance la taille du buffer) :
Code:

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 #include <vector> // Les includes OpenGL que tu utilises GLuint prepareVbo(std::vector<float> const & vertices) { // Remarque que j'initialise le VBO en dehors du VAO, c'est uniquement parce que je trouve cela plus propre. GLuint vbo; glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(float), vertices.data(), GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); return vbo; } GLuint prepareVao(GLuint vbo) { // Là, dans le code d'initialisation du VAO, on ne trouve donc que ce qui sert à initialiser le VAO. GLuint vao; glGenVertexArrays(1, &vao); glBindVertexArray(vao); glBindBuffer(GL_ARRAY_BUFFER, vbo); glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(0); glBindVertexArray(0); return vao; } int main(int argc, char const * argv[]) { // Initialisation std::vector<float> vertices { { 0.0f, 0.5f, 0.5f, -0.5f, -0.5f, -0.5f } }; GLuint vbo = prepareVbo(vertices); GLuint vao = prepareVao(vbo); // // ... Rendu ... // // Nettoyage (que tu ne pouvais pas avoir dans ton code, ce qui était pour le moins sale.) glDeleteVertexArrays(1, &vao); glDeleteBuffers(1, &vbo); return 0; }

07/08/2017, 12h27
guatto

Merci dragonjoker59, c'est en effet la solution idéale.