Discussion :

[Yellowmat]

Salut à toutes et à tous,

Je suis nouveau sur OpenGL, mon quotidien c'est plutôt le développement C++ (avec Qt). Bref, je suis en train de développer une application et j'ai besoin d'OpenGL pour arriver à les fins.

Ce que je dois faire est :
* afficher des objets superposés dont la forme est un carré
* appliquer une texture sur chaque carré
* contrôler le niveau de transparence de chaque objet individuellement
* faire en sorte que tout soit optimiser au mieux

Pour le moment j'arrive à afficher des objets représentés par des carrés et appliquer une texture dessus ... j'ai fait un test avec la transparence mais malheureusement les textures n'avaient plus de couleur (certainement un mauvais paramètre passé à la fonction glBlendFunc, enfin je pense).

Par contre je ne vois pas comment rendre la texture transparente, et je ne sais pas non plus si il est possible d'avoir un contrôle sur le niveau de transparence des objets.

D'avance merci pour votre aide.

[Laurent Gomila]

Pour glBlendFunc il faut utiliser SRC_ALPHA et ONE_MINUS_SRC_ALPHA (me souviens plus des noms exacts).

Ensuite pour régler la transparence, tu peux utiliser un glColor(1, 1, 1, alpha) avant chaque tracé de cube.

Et attention à bien les afficher du plus lointain au plus proche.

[Yellowmat]

Ok, je vais regarder pour les paramètres de glBlendFunc ... de mémoire c'est quelque chose d'équivalent à ceux que tu cites.

Ok aussi pour afficher du plus loin au plus proche, mais j'ai quelques questions à ce sujet :
* est ce qu'on doit faire appel à la fonction glClearColor avant d'afficher les objets ? Si oui, je pense qu'on peut aussi jouer sur le facteur d'opacité ?
* pour l'appel de la fonction glColor(1, 1, 1, alpha), on est obligé de spécifier les composantes rgb ? Il n'existe pas une fonction permettant de spécifier uniquement le facteur d'opacité ?

Je n'ai pas le temps de faire les tests aujourd'hui, je regarderai ça aussi rapidement que possible et mettrai le tag résolu une fois le test effectué.

En attendant, merci pour ta réponse.

PS : super ton article sur les moteurs 3D

[Laurent Gomila]

est ce qu'on doit faire appel à la fonction glClearColor avant d'afficher les objets ? Si oui, je pense qu'on peut aussi jouer sur le facteur d'opacité ?

glClearColor sert à spécifier la couleur d'effacement qui sera utilisé par glClear ; pas grand chose à voir avec ton problème

pour l'appel de la fonction glColor(1, 1, 1, alpha), on est obligé de spécifier les composantes rgb ? Il n'existe pas une fonction permettant de spécifier uniquement le facteur d'opacité ?

Non, la composante alpha fait partie intégrante de la couleur. Est-ce vraiment un problème ?

J'imagine qu'il existe d'autres moyens de spécifier un alpha par objet (avec DirectX il y a au moins 3 méthodes différentes), mais là c'est la seule simple qui me vienne à l'esprit. Donc si ça pose problème (a priori je ne vois pas pourquoi) on pourra toujours se pencher sur une autre méthode.

[Yellowmat]

Ok, ça ne devrait pas poser de problème, je testerai et remonterai rapidement le résultat.

Toujours à propos de glClearColor ... tu m'as dit qu'il est impératif d'afficher les objets du plus loin au plus proche, dans mon esprit le "background" est ce qu'il y a de plus loin et la fonction glClearColor permet d'effacer mais finalement ça se traduit par un affichage d'une couleur (je sais, j'ai l'esprit un peu tordu), par conséquent je me demande si il est nécessaire de dessiner le fond d'abord et ensuite les objets ou est ce qu'il y a une autre façon de faire ... d'où ma question. Mais bon, je pinaille, je ne pense pas que ça puisse avoir une importance.

[Laurent Gomila]

Effectivement je vois pas trop pourquoi tu poses cette question

Si tu n'effaces pas ton backbuffer avant de rendre tes objets, tu auras des restes de la frame précédente. A moins bien sûr que tes objets ne couvrent tout le backbuffer.

[Yellowmat]

Dernières questions (je sais que je pourrai avoir la réponse en testant mais comme je n'en ai pas la possibilité dans un futur proche) à propos du backbuffer :
* est il possible aussi d'en contrôler l'opacité ?
* si oui, est ce qu'on doit aussi utiliser la transparence avec le paramètres alpha ?

D'avance merci ... je n'ai plus de questions pour le moment

[Laurent Gomila]

Contrôler l'opacité du backbuffer ça ne rime à rien, il n'y a rien "derrière", c'est juste la surface sur laquelle tu affiches ta scène.

Tu peux stocker une composante alpha dedans si ton format le permet, mais ça ne servira pas à changer une quelconque opacité du backbuffer.

[Yellowmat]

Etant débutant, j'espère qu'on excusera le commentaire suivant

Si je me pose la question de gérer l'opacité du backbuffer c'est pour les raisons suivantes :
* je compte encapsuler tous les appels des primitives OpenGL dans un objet QGLWidget sous Qt3 ... cet objet offre quelques facilités pour l'implémentation d'objets graphiques sous Qt (version 3.3.3 pour moi)
* je souhaite afficher cet objet graphique sur la fenêtre principale de mon application SDI ... application affichant déja des informations (autres que celles affichées par mon objet graphique)
* je souhaite pouvoir contrôler le niveau d'opacité de cet objet graphique de sorte que je puisse voir à la fois ses informations et par transparence les informations affichées dans ma fenêtre principale

Voila pour les détails.

Il est tout à fait possible que la gestion de l'opacité du backbuffer soit hors propos mais dans mon esprit ça ne me semblait pas aussi évident

Etant donné que tu as (il me semble l'avoir lu quelque part) une expérience avec Qt, peut être pourras tu me dire si ce que je souhaite faire est possible ?

D'avance merci

[Laurent Gomila]

Je ne sais pas comment faire avec Qt, mais ce qui est sûr c'est que si c'est possible ce sera bien avec lui qu'il faudra voir, pas avec OpenGL.

OpenGL ne te donne qu'une image à afficher, c'est sur ton contrôle Qt qu'il faudra agir si tu veux qu'il soit transparent.

[Yellowmat]

Bon, après vérification, l'affichage d'un contrôle transparent pose problème. En fait il existe une méthode sous Qt qui s'applique aux contrôles et qui permet de gérer l'affichage avec opacité ... mais elle ne s'applique qu'aux contrôles haut niveau et pas dans mon cas ou le contrôle possède un père.

Ceci dit, tout espoir n'est pas perdu. Si l'encapsulation des appels des primitives OpenGL dans un objet Qt pose problème, est il possible de le faire dans un objet non dérivé d'une classe graphique ? Si oui que dois je faire (initialisation de OpenGL ou non ?) pour faire comme ça ?

D'avance merci.