[OpenCL/OpenGL] Animation de pixels dans un cube en 3D

Bonjour,

Avant de décrire mon pb d'un point de vue technique je vais replacer le but de mon appli dans son contexte pour les curieux. Les autres peuvent zapper l'explication...

Le but de mon appli est de simuler des réseaux métaboliques à l'aide d'un système multi agent basé sur les fourmis. L'espace cellulaire est modélisé par un cube qui contient des métabolites (pixels). Chaque métabolite est donc représenté par un pixels en couleurs. Le cube est donc un simple tableau en une dimension contenant l'ensemble des métabolites (ou case vide aussi!).

L'algorithme est exécuté à l'aide de OpenCL. Pour ceux qui ne connaissent pas, OpenCL permet d'exploiter les capacités de calcul des GPU. Bref là n'est pas le sujet.

Donc tout les x pas de temps je génère un tableau de pixels (disons une centaine de tableaus) et mon idée serait de pouvoir afficher ce tableau en temps réel ou sinon je stocke tout les tableaux et j'affiche l'animation a postériori.

Donc ma question est simple : quelle est la meilleur facon sous openGL d'afficher dans un cube fictif tout mes pixels ?

En gros en entrée, j'ai un zoli tableau de pixels qui contient des couleurs mais je sais pas quelle primitive de OpenGL utilisé pour l'affichage. Y a-t-il une primitive "Point" qui permet d'afficher un simple point de la couleur voulu à des coordonnées spécifiques?

Question bonus : est ce que l'utilisation des VBO vous semblent justifier pour ce type d'application ?

Et pour ceux qui connaissent OpenCL et qui se demandent si je compte rapatrié mes tableaux sur le CPU pour les re balancer au GPU pour l'affichage, ne vous inquietez pas. J'ai bien noté que OpenCL possède des fonctions qui permettent de faire la bascule OpenGL/OpenCL de manière efficace (encore faut il que j'apprenne à m'en servir :D)

Voila j'espère avoir été claire. Si ce n'est pas le cas, n'hésitez pas à le faire savoir :)

Il existe une primitive GL_POINTS dans openGL.
A tu une image de ce que tu aimerais afficher? J'ai un peu de mal à me faire une idée.
Combien as tu de points à afficher? entre 1000 points et 1000000 ou + de points la réponse sera différente.

Bonjour,

En effet la primitive "points" a l'air de correspondre parfaitement à ce que je cherche.

Pour en revenir à la quantité de pixels, c'est de l'ordre du million (1 à 7 millions). Je me rends pas du tout compte si cela est beaucoup... L'utilsiation des VBO est t elle préconisé pour cette quantité d'info ?

Je n'ai pas d'image à montrer. Mais il suffit d'imaginer un cube dans lequel à peu près 70% des pixels sont des pixels de couleurs, les autres sont vides.

Cordialement

Bonjour,

Les VBO sont une bonne idée pour éviter de faire trop de transferts entre le CPU et le GPU, mais j'ai l'impression qu'il faudra tout de même faire le transfert à chaque pas.

On peut peut être limité en ne transferrant les positions des points qu'une seule fois dans toute la vie du programme. Vu que si j'ai compris, seules les couleurs change.

Hum, disons que chaque pixels représentent un métabolite et celui ci est amené à se déplacer. D'un point de vue 3D ca revient à dire qu'un pixel rouge à la position x,y,z peut au pas de temps suivant 's'éteindre' en x,y,z et s'allumer en x+1,y-1,z par exemple.

Je ne sais pas si je suis très claire.

En gros la composition du cube (de mon array) changera à chaque pas de temps, mais elle changera sur le GPU du coté OpenCL donc il faudrait que j'arrive à "faire passer" mon cube du coté OpenGL tjrs sur le GPU. Le CPU n'ayant alors qu'un rôle de coordinateur.

Enfin je vois les choses de la sorte.

La simulation proprement dite n'est pas encore totalement fini (essayer de débugger sous OpenCL "à l'aveugle" vous allez rire :D). Je devrais commencer la visualisation d'ici une ou deux semaines.

Je vous tiens au courant.

Si vous avez d'autre idée, n'hésitez pas :)

Et encore merci pr les réponses.

Ne connaissant pas OpenCL je ne peux pas me prononcer.
Mais il me semble que cela ressemble à CUDA, donc qu'il doit y avoir très certainement un moyen d'afficher les données qui sont déjà présentes du coté GPU.