Discussion :

[Djakisback]

Salut,
J'aimerais savoir s'il est possible (et surtout comment ) récupérer les coordonnées de vertices et d'autres informations stockés dans une display list.
L'idée étant de pouvoir compiler/décompiler à la volée (très ponctuellement, d'où l'utilisation de lists et non de vertex arrays ou autres).

Merci d'avance

[dragonjoker59]

A ma connaissance non, par contre avec les vertex buffer object, tu peux mapper ton buffer ou une partie (donc ponctuellement) vers la ram pour le modifier.

[LittleWhite]

Bonjour,

Je tiens à rappeler, que les display list tendent à être obsolètes maintenant. Donc il faut mieux utiliser les buffers (VBO ... je crois) qui laisse comme le dit dragonjoker59, la liberté de mapper nos données dans la carte graphique.
Sinon, non je n'ai pas connaissance d'une telle méthode, et je n'en vois pas l'utilité.

[Djakisback]

Merci pour vos réponses
Je continue de chercher mais ne trouve pas grand chose sur le sujet, ça ne doit pas être faisable.

Je pourrais effectivement utiliser des VBO (que je ne connais pas bien) mais c'est à partir de GL2 non ? Remarque c'est pas très grave, en revanche dans mon souvenir ce n'est pas implémenté dans GL ES ? Je vais vérifier tout cela (et jeter un coup d'oeil au tuto de Raptor).

LittleWhite, l'idée est par exemple de compiler/décompiler des mesh dans un éditeur de scène en temps réel (enfin dans mon cas, c'est le but), avec un schéma de ce type :
décompilation->modification d'une forme (vertices, couleurs) à la souris ou autre->recompilation

[LittleWhite]

D'accord ... faudra nous montrer (si possible) le resultat
J'ai un collegue qui le faisait en temps que projet de fin d'annee ... des voxels et tout (on peut creuser dans l'objet ...) mais c'etait finalement trop lent.

(Arrete de raconter sa vie)

Donc, oui il vous faut des buffers. Je ne suis pas sur du nom (meme si je pense a ce que cela s'appelle VBO), cela regrouppe les fonctions suivantes:

http://www.opengl.org/sdk/docs/man/x...lientState.xml
http://www.opengl.org/sdk/docs/man/x...texPointer.xml
http://www.opengl.org/sdk/docs/man/x...DrawBuffer.xml

glVertexPointer is available only if the GL version is 1.1 or greater.

Et cela existe sous OpenGL ES 1.1 (c'est la seule methode pour dessiner des trucs de toute facon )

[LittleWhite]

Le nom c'est VAO (Vertex Array Object et non VBO Vertex Buffer Objects)

Effectivement, les VBO, sont une technique qui sauvegarde tout l'objet dans la carte après avoir copié les informations. C'est mieux pour les objets statique je crois. (Qui ne se déforme pas)

[dragonjoker59]

Les VAO ne servent finalement qu'à simplifier le code de la fonction de rendu:
on passe de ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
glBindBuffer( GL_ARRAY_BUFFER, m_iVtxIndex);
glBindBuffer( GL_ARRAY_BUFFER, m_iNmlIndex);
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, m_iIndIndex);
glEnableClientState( GL_VERTEX_ARRAY);
glEnableClientState( GL_NORMAL_ARRAY);
glEnableClientState( GL_INDEX_ARRAY);
glVertexPointer( m_iVtxSize, m_iVtxType, m_iVtxStride, BUFFER_OFFSET( m_iVtxOffset));
glNormalPointer( m_iNmlType, m_iNmlStride, BUFFER_OFFSET( m_iNmlOffset));
glIndexPointer( m_iIndType, m_iIndStride, BUFFER_OFFSET( m_iIndOffset));
glDrawElements( GL_TRIANGLES, m_iNbIndices, m_iIndType, 0);
glDisableClientState( GL_NORMAL_ARRAY);
glDisableClientState( GL_VERTEX_ARRAY);
glDisableClientState( GL_INDEX_ARRAY);

à ça

Code :

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

1
2
3
glBindVertexArray( m_uiIndex);
glDrawElements( GL_TRIANGLES, m_iNbIndices, m_iIndType, 0);
glBindVertexArray( 0);

Au final, ce ne sont que des display list pour les buffers.
En fait la partie 'activation' du code de la fonction de rendu habituelle est placée au niveau de l'initialisation du VAO :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
glGenVertexArrays( 1, & m_uiIndex);
glBindVertexArray( m_uiIndex);
glBindBuffer( GL_ARRAY_BUFFER, m_iVtxIndex);
glBindBuffer( GL_ARRAY_BUFFER, m_iNmlIndex);
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, m_iIndIndex);
glEnableClientState( GL_VERTEX_ARRAY);
glEnableClientState( GL_NORMAL_ARRAY);
glEnableClientState( GL_INDEX_ARRAY);
glVertexPointer( m_iVtxSize, m_iVtxType, m_iVtxStride, BUFFER_OFFSET( m_iVtxOffset));
glNormalPointer( m_iNmlType, m_iNmlStride, BUFFER_OFFSET( m_iNmlOffset));
glIndexPointer( m_iIndType, m_iIndStride, BUFFER_OFFSET( m_iIndOffset));
glBindVertexArray( 0);

[bafman]

Concernant la question initiale, on ne peut pas récupérer le contenu d'une display liste pour une bonne raison : les display list ne font pas que contenir des données géométriques, elle peuvent aussi contenir des appels de fonction openGL comme des bind de texture ou autre. En plus, elle sont optimisé par le driver, du coup, en fonction du constructeurs, elles ne contiennent pas la même chose.

Par contre, tu peut très bien détruire puis reconstruire ta display list lors de modifications si tu tiens vraiment a utiliser une fonctionnalité paléolithique (d'ailleurs, je ne suis même pas sur qu'elles soient encore présentes dans les dernière version d'openGL)

[LittleWhite]

Par contre, tu peut très bien détruire puis reconstruire ta display list lors de modifications si tu tiens vraiment a utiliser une fonctionnalité paléolithique (d'ailleurs, je ne suis même pas sur qu'elles soient encore présentes dans les dernière version d'openGL)

Elle n'y sont plus. (Pour information)

[Djakisback]

Merci à tous pour vos réponses, c'est sympa
Je vais regarder de plus près les VAO et surtout les VBO.

Après lecture de ton post bafman je m'aperçois que le code d'une display list doit effectivement sans doute être compilé tel quel et il ne doit pas y avoir moyen de récupérer telle ou telle partie (maintenant que j'y pense ce serait comme récupérer des variables C à partir de binaire).

Dans ma première idée, j'étais conscient que l'on compilait autre chose que des données mais je ne voyais pas le mécanisme comme cela.

Pour ce qui est de la destruction/reconstruction de la display list, c'était justement l'idée mais en profitant du stockage des données dans la carte graphique. Si je dois stocker les vertices en RAM, l'intérêt n'est pas le même. Je pense que les VBO devraient me permettre de faire ça.

A savoir, passer d'un objet compilé à un objet non-compilé et vice-versa à tout moment.
Si objet compilé, vertices uniquement stockés dans la CG, suppression des vertices de l'objet de la RAM
Si objet décompilé, vertices uniquement stockés dans la RAM, suppression des vertices de l'objet de la CG

Je vais tester tout ça