Discussion :

[Lung]

J'ai essayé de reproduire l'exemple du tutoriel, mais j'ai un problème de traduction au niveau de l'appel à glVertexPointer.
Voici mon 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
 
 CubeArray: Array[0..47] of GLfloat;
 IndiceArray: Array[0..35] of GLuint;
 CubeBuffers: Array[0..1] of GLuint;
 
...
 
   glVertexPointer: procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: GLvoid);   stdcall;
   glColorPointer: procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: GLvoid);   stdcall;
   glEnableClientState: procedure(_array: GLenum);   stdcall;
   glDrawElements: procedure(mode: GLenum; count: GLsizei; _type: GLenum; const indices: GLvoid);   stdcall;
   glDisableClientState: procedure(_array: GLenum);   stdcall;
 
...
 
   glGenBuffers(2, @CubeBuffers);
 
   glBindBuffer(GL_ARRAY_BUFFER, CubeBuffers[0]);
   glBufferData(GL_ARRAY_BUFFER, SizeOf(CubeArray), @CubeArray, GL_STATIC_DRAW);
 
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, CubeBuffers[1]);
   glBufferData(GL_ELEMENT_ARRAY_BUFFER, SizeOf(IndiceArray), @IndiceArray, GL_STATIC_DRAW);
end;
 
procedure TFormGL.AffVBO;
const
   GL_COLOR_ARRAY = $8076;
   GL_VERTEX_ARRAY = $8074;
begin
   // Utilisation des données des buffers
   glBindBuffer(GL_ARRAY_BUFFER, CubeBuffers[0]);
   // glVertexPointer(3, GL_FLOAT, 6 * sizeof(float), ((float*)NULL + (3)));
   glVertexPointer(3, GL_FLOAT, 6 * SizeOf(Double), nil);      // <--- ERREUR :  violation d'accès ici !
   // glColorPointer(3, GL_FLOAT, 6 * sizeof(float), 0);
   glColorPointer(3, GL_FLOAT, 6 * SizeOf(Double), nil);
 
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, CubeBuffers[1]);
 
   // Activation d'utilisation des tableaux
   glEnableClientState(GL_VERTEX_ARRAY);
   glEnableClientState(GL_COLOR_ARRAY);
 
   // Rendu de notre géométrie
   glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_INT, nil);
 
   glDisableClientState(GL_COLOR_ARRAY);
   glDisableClientState(GL_VERTEX_ARRAY);
end;

J'obtiens une violation d'accès à l'appel de glVertexPointer, parce que je ne sais pas ce qu'il faut mettre en dernier paramètre.
Comment traduire ((float*)NULL + (3)) ?

[kremvax]

glVertexPointer(3, GL_FLOAT, 6 * SizeOf(Double), nil);

Le 3e paramètre de glVertexPointer doit représenter l'espace mémoire qui sépare 2 vertices dans le VBO. Ici je suppose que tu as 3 coordonnées spatiales en GLfloat et 3 coordonnées RGB en GLfloat également. Es-tu sûr que "SizeOf(Double)" équivaut à "SizeOf(GLfloat)"?

A part ça, la ligne suivante risque de donner un résultat inattendu à mon avis, il faut spécifier un offset (4e paramètre)

Qu'est-ce que ça donne si tu remplaces ces quelques lignes par :

Code :

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

1
2
3
4
5
 
   // Utilisation des données des buffers
   glBindBuffer(GL_ARRAY_BUFFER, CubeBuffers[0]);
   glVertexPointer(3, GL_FLOAT, 6 * SizeOf(GLfloat), 0);
   glColorPointer(3, GL_FLOAT, 6 * SizeOf(GLfloat), 3*SizeOf(GLfloat));

PS : en C++ je vois souvent le petit hack suivant pour le 4e paramètre de glVertexPointer :
#define BUFFER_OFFSET(i) ((char*)NULL + (i))
puis glVertexPointer(blablabla, BUFFER_OFFSET(0));
Je ne sais pas exactement à quoi ça rime, mais peut-être que le même genre de chose est nécessaire sous Delphi?

[Lung]

Es-tu sûr que "SizeOf(Double)" équivaut à "SizeOf(GLfloat)"?

Maintenant, que tu le dis, j'ai un doute.

Qu'est-ce que ça donne si tu remplaces ces quelques lignes par :

Code :

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

1
2
3
4
5
 
   // Utilisation des données des buffers
   glBindBuffer(GL_ARRAY_BUFFER, CubeBuffers[0]);
   glVertexPointer(3, GL_FLOAT, 6 * SizeOf(GLfloat), 0);
   glColorPointer(3, GL_FLOAT, 6 * SizeOf(GLfloat), 3*SizeOf(GLfloat));

Je teste ce soir, et je te redis.
Par contre, pourquoi mettre 0 en dernier paramètre de glVertexPointer ?
Je crois que j'avais testé, et le compilateur me disait que c'était implicitement converti à nil.

PS : en C++ je vois souvent le petit hack suivant pour le 4e paramètre de glVertexPointer :
#define BUFFER_OFFSET(i) ((char*)NULL + (i))
puis glVertexPointer(blablabla, BUFFER_OFFSET(0));
Je ne sais pas exactement à quoi ça rime, mais peut-être que le même genre de chose est nécessaire sous Delphi?

Bin, je veux bien créer une constante si besoin, mais je comprend pas la signification de ((char*)NULL + (i)).
Comment une constante peut être un pointeur de je sais pas quoi ?

[kremvax]

Maintenant, que tu le dis, j'ai un doute.


Je teste ce soir, et je te redis.
Par contre, pourquoi mettre 0 en dernier paramètre de glVertexPointer ?
Je crois que j'avais testé, et le compilateur me disait que c'était implicitement converti à nil.


Bin, je veux bien créer une constante si besoin, mais je comprend pas la signification de ((char*)NULL + (i)).
Comment une constante peut être un pointeur de je sais pas quoi ?

j'ai lu trop rapidement, apparemment dans le VBO c'es t d'abord les couleurs ensuite les positions, donc il faudrait faire :

Code :

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

1
2
3
4
5
 
   // Utilisation des données des buffers
   glBindBuffer(GL_ARRAY_BUFFER, CubeBuffers[0]);
   glVertexPointer(3, GL_FLOAT, 6 * SizeOf(GLfloat), 3*SizeOf(GLfloat));
   glColorPointer(3, GL_FLOAT, 6 * SizeOf(GLfloat), 0);

En fait les fonctions type glVertexPointer demandent un pointeur sur GLvoid en 4e paramètre (ça me parait assez bizarre, mais pourquoi pas). "0" c'est pour lui dire de lire depuis le début de la portion de VBO en cours de lecture. La macro "((char*)NULL + (i))" permet de "transformer" un index en pointeur. Après, peut-être que ça marche différemment sous Delphi.

[Lung]

J'obtiens ça :

Code :

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

glVertexPointer(3, GL_FLOAT, 6 * SizeOf(GL_FLOAT), 3 * SizeOf(GL_FLOAT));

"Types incompatibles : 'Integer' et 'Pointer'".

Code :

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

glColorPointer(3, GL_FLOAT, 6 * SizeOf(GL_FLOAT), 0);

"Constante 0 convertie en NIL".

En fait les fonctions type glVertexPointer demandent un pointeur sur GLvoid en 4e paramètre (ça me parait assez bizarre, mais pourquoi pas). "0" c'est pour lui dire de lire depuis le début de la portion de VBO en cours de lecture. La macro "((char*)NULL + (i))" permet de "transformer" un index en pointeur. Après, peut-être que ça marche différemment sous Delphi.

Merci pour tes explications.
Je commence à mieux comprendre.
Puisque c'est un problème de syntaxe, je vais poster dans le forum Delphi.

[Paul TOTH]

mais non

glVertexPointer() permet d'indiquer à OpenGL l'adresse de ton buffer de vertices

personnellement je déclare la fonction comme ceci :

Code delphi :

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

1
2
 
procedure glVertexPointer(components,format,skip:integer;const vertex); stdcall external OpenGL;

et l'utilise comme ça :

Code delphi :

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

1
2
3
4
5
6
7
8
9
10
 
  TVertex3f=record
    x,y,z : Single;
  end;
  ...
    FVertices : array of TVertex3f;
  ...
begin
  glVertexPointer(SizeOf(TVertex3f) div SizeOf(Single), GL_FLOAT, SizeOf(TVertex3f), FVertices[0]);
end;

c'est à dire : Nombre de composantes (3), type de composants (FLOAT = Single), Espacement entre les valeurs, et pointeur vers la première valeur.

Pour ce qui est de l'espacement, il permet d'utiliser une structure complexe :

Code delphi :

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

1
2
3
4
5
6
7
8
9
10
11
 
type
  TVertex=record
   x,y,z: Single;
   color: TColor;
  end;
 
begin
// ici on a toujours 3 float mais les éléments ne se suivent pas directement en mémoire
  glVertexPointer(3, GL_FLOAT, SizeOf(TVertex), FVertices[0]);
end;

EDIT: NB - je ne connais pas glGenBuffers et glBindBuffer...qui semblent utiliser des buffers côté OpenGL...

[Paul TOTH]

ok, ben en cherchant un peu on trouve les explications et en français dans le texte

[kremvax]

En effet, un champ "record" se rapprocherait plus des implémentations que je vois en C avec des structures.

Une petite chose :

J'obtiens ça :

Code :

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

glVertexPointer(3, GL_FLOAT, 6 * SizeOf(GL_FLOAT), 3 * SizeOf(GL_FLOAT));

GL_FLOAT est une constante définie dans opengl, à ne pas confondre avec GLfloat qui est un type (regarde plus haut dans ton programme, tu l'utilises : "CubeArray: Array[0..47] of GLfloat;".
Dans le "SizeOf", c'est le type qu'il faudrait utiliser.

EDIT: NB - je ne connais pas glGenBuffers et glBindBuffer...qui semblent utiliser des buffers côté OpenGL...

En effet ici les buffers sont stockés dans la mémoire vidéo donc on n'y accède pas si simplement. Le 4e paramètre ne doit pas pointer vers un espace de la mémoire centrale, mais doit indiquer la position dans le buffer "bindé" par opengl, en partant de 0.

Pour le 4e argument qui est à l'origine de l'erreur de compil visiblement, il faudrait faire en delphi cette macro
#define BUFFER_OFFSET(i) ((char*)NULL + (i))
qui consiste à "caster" un nombre en pointeur.

Tu as une doc d'opengl pour delphi? peut-être que ça aiderait.

[shenron666]

la doc opengl est la même pour tous, ce sont les binding qui sont parfois un peu différents mais c'est juste une question de typage
tu peux regarder les docs officielles :
glGenBuffers
glBindBuffer
et en bonus, pour accéder aux buffers, on fait ce qu'on appelle un (memory) mapping :
glMapBuffer

en espérant que cela puisse t'aider

[Paul TOTH]

ok, donc il suffit de caster l'entier 3*SizeOf(Single) en pointer...

Code :

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

pointer(3*SizeOf(Single))

le code C est un mélange de cast et d'opération...sous Delphi on aurait

Code :

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

1
2
3
4
5
6
7
 
var
  p : ^Single;
begin
  p := nil; // (char *)NULL; 
  inc(p,3);
end;

(corrigé car le pointeur étant typé, l'incrément est de la taille du type et non de 1)

[Lung]

ok, donc il suffit de caster l'entier 3*SizeOf(Single) en pointer...

Code :

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

pointer(3*SizeOf(Single))

Code :

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

glVertexPointer(3, GL_FLOAT, 6 * SizeOf(GLfloat), Pointer(3 * SizeOf(GLfloat)));

J'obtiens toujours une violation d'accès.

Pas moyen de faire fonctionner cette API.

[shenron666]

Code :

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

glVertexPointer(3, GL_FLOAT, 6 * SizeOf(GLfloat), Pointer(3 * SizeOf(GLfloat)));

J'obtiens toujours une violation d'accès.

Pas moyen de faire fonctionner cette API.

attends, mais c'est quoi ce

Code :

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

Pointer(3 * SizeOf(GLfloat))

c'est un pointeur sur l'emplacement en mémoire où se truvent tes données
là tu lui indique en gros que tes données ser trouve en "3 * sizeof(float)" et si on considère un float sur 4 octets, tes données se trouvent à l'adresse 0x0000000D ?

tu stockes bien tes données dans une zone mémoire
c'est le pointeur sur cette zone mémoire que tu dois lui indiquer

n'hésites pas à consulter la doc de l'API :

void glVertexPointer( GLint size,
GLenum type,
GLsizei stride,
const GLvoid * pointer);

Parameters

pointer
Specifies a pointer to the first coordinate of the first vertex in the array. The initial value is 0.

[kremvax]

attends, mais c'est quoi ce

Code :

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

Pointer(3 * SizeOf(GLfloat))

c'est un pointeur sur l'emplacement en mémoire où se truvent tes données
là tu lui indique en gros que tes données ser trouve en "3 * sizeof(float)" et si on considère un float sur 4 octets, tes données se trouvent à l'adresse 0x0000000D ?

tu stockes bien tes données dans une zone mémoire
c'est le pointeur sur cette zone mémoire que tu dois lui indiquer

Dans le cas d'un VBO que l'on a bindé via "glBindBuffer", c'est bel et bien l'adresse dans le VBO qu'il faut indiquer... adresse qui commence à 0 en début de buffer. Si je me trompe pas, en indiquant un emplacement en mémoire centrale, on perdrait tout l'intérêt du vbo. Donc je sais pas ce qu'il faut écrire en delphi, mais en C++ un truc comme ((char*)NULL + (3 * sizeof(GLfloat))) fait bien ce qu'il faut.

[shenron666]

Dans le cas d'un VBO que l'on a bindé via "glBindBuffer", c'est bel et bien l'adresse dans le VBO qu'il faut indiquer...

Au temps pour moi, c'est vrai que dans le cas des VBO ce n'est pas l'adresse absolue mais un offset relatif à 0 qui est le début du VBO
l'adresse des données étant fournie par glBufferData
désolé

une question cependant, glVertexPointer est une procédure valide ?
ce n'est peut-etre pas un paramètre de le fonction mais l'appel à la fonction elle même qui n'est pas valide (en C appeler une fonction via un pointeur sur fonction non valide provoque ce genre d'effet)

[Lung]

une question cependant, glVertexPointer est une procédure valide ?
ce n'est peut-etre pas un paramètre de le fonction mais l'appel à la fonction elle même qui n'est pas valide (en C appeler une fonction via un pointeur sur fonction non valide provoque ce genre d'effet)

Effectivement, c'est une piste.
Je vais essayer de charger cette fonction dynamiquement.

[Lung]

J'ai chargé dynamiquement toutes ces fonctions de OpenGL32.dll, et ca ne plante plus !


Note pour plus tard : toujours charger dynamiquement les fonctions OpenGL.

Maintenant, j'ai un écran gris, mais j'ai pas eu le temps de tester plus.
Je continu ...

[shenron666]

c'est déjà mieux qu'un plantage
on attend du nouveau alors

[Lung]

Bon, cétait juste un problème de glPushMatrix.
Maintenant, le cube s'affiche bien.


Maintenant, problème suivant :
Comment peut-on plaquer une texture sur un objet stocké dans un VBO ?
Le tutoriel n'en parle pas.
Je suppose que c'est pas glTexCoord2f qu'il faut employer.

[kremvax]

Si tu as tes coordonnées UV dans le VBO, tu dois appeler "glEnableClientState(GL_TEXTURE_COORD_ARRAY);" (comme tu le fais déjà pour GL_VERTEX_ARRAY), ainsi que "glTexCoordPointer(...);" (fonction analogue à glVertexPointer), et bien sûr binder ta texture avant d'afficher le VBO "glBindTexture(GL_TEXTURE_2D, texId);"

Une fois l'affichage terminé, tu peux désactiver GL_TEXTURE_COORD_ARRAY (glDisableClientState).