Discussion :

[Vinc35]

Bonjour,

Je voulais savoir quelle etait exactement la difference entre ces 2 fonctions :

glGenBuffers et glGenBuffersARB (j'ai pris comme exemple glGenBuffers, mais le probleme est le meme pour d'autres fonction comme glBufferData(ARB), ...)

Pour moi, l'extention ARB signifie que l'on utilise une fonction qui n'est pas encore incluse dans la version finale d'OpenGL, mais encore en developpement. Je pensai aussi que avec OpenGL 2.0 il n'y avait plus de raison d'utiliser glGenBuffersARB.

Or, le SDK Cuda 1.1 est sortit recement (le 20/11/2007) et dedans il y a un projet qui m'interresse particulierement, permettant de simuler un ocean. Dedans, j'y trouve a la fois des glGenBuffers et des glGenBuffersARB.
Pourquoi NVidia, dans son SDK utilise les 2 fonctions ??? Je n'y vois pas d'interet, mais je me dis qu'ils doivent savoir ce qu'ils font et qu'il y a donc un interet a appeler glGenBuffersARB.

voici les 2 morceaux de code ou l'on trouve glGenBuffers et glGenBuffersARB :


Création d'un VBO :

Code :

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

1
2
3
4
5
6
7
8
9
10
void createVBO(GLuint* vbo, int size)
{
    // create buffer object
    glGenBuffers(1, vbo);
    glBindBuffer(GL_ARRAY_BUFFER, *vbo);
    glBufferData(GL_ARRAY_BUFFER, size, 0, GL_DYNAMIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
 
    CUT_CHECK_ERROR_GL();
}

Création d'un VBO pour les indices :

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 createMeshIndexBuffer(GLuint *id, int w, int h)
{
    int size = ((w*2)+1)*(h-1)*sizeof(GLuint);
 
    // create index buffer
    glGenBuffersARB(1, id);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, *id);
    glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER, size, 0, GL_STATIC_DRAW);
 
    // fill with indices for rendering mesh as triangle strips
    GLuint *indices = (GLuint *) glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY);
    if (!indices) {
        return;
    }
 
    for(int y=0; y<h-1; y++) {
        for(int x=0; x<w; x++) {
            *indices++ = y*w+x;
            *indices++ = (y+1)*w+x;
        }
        *indices++ = 0xffffffff;    // restart strip
    }
 
    glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}

Si vous pouviez m'eclairer sur ce point

Merci

[shenron666]

aucune différence
normalement on utilisera glGenBuffersARB
c'est plus une question de notation

Pour moi, l'extention ARB signifie que l'on utilise une fonction qui n'est pas encore incluse dans la version finale d'OpenGL, mais encore en developpement. Je pensai aussi que avec OpenGL 2.0 il n'y avait plus de raison d'utiliser glGenBuffersARB.

c'est l'inverse
ARB signifie que l'extension a été ratifiée par l'ARB et éventuellement qu'elle fait partie d'une version opengl
EXT est plus flou
NV pour les extensions spécifiques nVidia
ATI pour ATI
et il y en a beaucoup comme ça
les extension ARB sont des extensions validées (tout comme EXT normalement)

Or, le SDK Cuda 1.1 est sortit recement (le 20/11/2007) et dedans il y a un projet qui m'interresse particulierement, permettant de simuler un ocean. Dedans, j'y trouve a la fois des glGenBuffers et des glGenBuffersARB.
Pourquoi NVidia, dans son SDK utilise les 2 fonctions ??? Je n'y vois pas d'interet, mais je me dis qu'ils doivent savoir ce qu'ils font et qu'il y a donc un interet a appeler glGenBuffersARB.

je pense qu'il s'agit d'une erreur
il suffirait que 2 personnes ont écrit chacune un bout de code en n'utilisant pas la même convention et hop, "problème"

Création d'un VBO pour les indices :

Code :

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

1
2
3
4
5
6
7
8
void createMeshIndexBuffer(GLuint *id, int w, int h)
{
    int size = ((w*2)+1)*(h-1)*sizeof(GLuint);
 
    // create index buffer
    glGenBuffersARB(1, id);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, *id);
    glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER, size, 0, GL_STATIC_DRAW);

pas très cohérent d'utiliser des fonctions "ARB" et d'autres "non ARB"
surtout au sein d'une même extension, en l'occurence les VBO

[Laurent Gomila]

aucune différence

Au résultat oui, mais pas au niveau du code. La version prefixée par ARB n'existe pas, il faut la charger dynamiquement via les extensions (fait automatiquement si on utilise GLEW par exemple). De plus, la version sans prefixe ne sera pas déclarée si on ne dispose pas d'en-têtes OpenGL 1.5 (pour cet exemple-ci), ce qui n'est par exemple pas le cas sous Windows.

[Vinc35]

Ok, je vois mieux la difference.

Merci

Donc au final, je ne ma casse pas la tete et je prends les fonctions sans ARB ? (je travaille en OpenGl 2.1.1)

[acx01b]

je pense que le plus simple est d'utiliser glew et donc les fonctions qui y sont déclarées (une seule version de glew: le premier lien sous google) comme ça si ton programme marche pas les gens sauront quoi faire pour le compiler (aller sur le site de glew)

[Groove]

"Pour moi, l'extention ARB signifie que l'on utilise une fonction qui n'est pas encore incluse dans la version finale d'OpenGL, mais encore en developpement. Je pensai aussi que avec OpenGL 2.0 il n'y avait plus de raison d'utiliser glGenBuffersARB."

C'est exactement ca. Quand, il y a un espace de nom ARB, EXT, etc. Ce n'est qu'une extension. Pas la spec finale. Une feature évolue de propriétaire à plusieurs niveaux de validation (EXT puis ARB suivant le nombre de membre de l'ARB qui valide l'extension). Cependant, toutes les extensions ARB ne sont pas incluse dans les specs d'OpenGL, par exemple GL_ARB_vertex_program ou GL_ARB_texture_rectangle. Il y en a bien d'autres.

aucune différence
normalement on utilisera glGenBuffersARB
c'est plus une question de notation


c'est l'inverse
ARB signifie que l'extension a été ratifiée par l'ARB et éventuellement qu'elle fait partie d'une version opengl
EXT est plus flou
NV pour les extensions spécifiques nVidia
ATI pour ATI
et il y en a beaucoup comme ça
les extension ARB sont des extensions validées (tout comme EXT normalement)


je pense qu'il s'agit d'une erreur
il suffirait que 2 personnes ont écrit chacune un bout de code en n'utilisant pas la même convention et hop, "problème"


pas très cohérent d'utiliser des fonctions "ARB" et d'autres "non ARB"
surtout au sein d'une même extension, en l'occurence les VBO

[tyler_durden99]

glGenBuffers est une commande generique d'openGL alors que glGenBuffersARB est une extension qui permet d'uploader les vertex (entre autre) sur la mémoire de la carte graphique ce qui permet de grandement accelerer la manipulation des vertex, je fais réference au VBO.

ces commandes ne se limitent pas au vertex on peu aussi gerer des tableau de normales, de couleurs.

[jolgeirr]

du coup, autant on peut savoir facilement, avec les versions ARB, si c'est supporte ou pas, autant la, vu que c'est a priori directement integre a la version d'OpenGL, comment ca se passe lorsqu'on essaye de lancer ca sur une machine qui ne le gere pas?

par exemple: pour les VBO, c'est facile de savoir si c'est supporte ou pas quand on check la string d'extensions et qu'on va chercher a la main les pointeurs sur fonctions des glGenBuffersARB et autres, mais dans le cas de, par exemple, OpenGL 2.0, on peut utiliser directement glGenBuffers sans se soucier de si ca marchera ou pas? il faut quand meme verifier dans la string d'extensions si l'extension vertex buffer object est supportee? il y a une fallback prevue si ca ne l'est pas?

bref, est-ce que c'est safe d'appeler glGenBuffers, du moment qu'on utilise une version d'OpenGL ou ca a ete integre? et si oui, quel est le comportement si jamais les VBO ne sont pas supportes?