Discussion :

[manimouleLight&Magic]

Bonjour à tous

je bosse actuellement sur la conception de mon mini-moteur opengl pour le boulot, et étant plutôt habitué au rendu offline, j'ai peur d'avoir de mauvais réflexes:

avant tout il faut savoir que:
-la scene que je dois rendre dans le moteur repose énormément sur la notion de transparence (plusieurs couches superposées, chacune comportant une texture d'opacité) et sur les effets optiques que ça implique (reflexion, réfraction, caustiques, flou de transparence et autres joyeusetés).
-je n'ai pas besoin d'être d'une précision physique démente (de vulgaires approximations et/ou fake ne posent pas de problème majeur), mais je ne peux pas me passer de ces effets

pour prendre un exemple simple, imaginons que ma scene contienne une lentille qui ai un effet "loupe" avec des rayures dessus. Cette lentille devra donc disposer d'une map d'opacité (pour les rayures), d'un environment mapping (pour les reflets), d'un reflet spéculaire (parce que c'est trop badass ), et de cette transparence déformée (l'effet loupe).

le graphiste qui est en moi se dit donc: on va faire un rendu multipasses.
-rendre la totalité de la scene sauf la lentille dans un FBO
-rendre la lentille seule dans un autre FBO, en prenant soin de prendre en compte l'alpha pour ne pas perdre la transparence
-faire un compositing de ces deux FBO, en mettant en arrière-plan la scene, en premier plan la lentille, et en appliquant la deformation de la lentille sur la zone qui va bien

ça implique donc que mon moteur doit pouvoir être configuré pour rendre à chaque frame plusieurs FBO distincts qui ne contiennent pas forcément les mêmes objets.
typiquement, la config de la scene donnerait un truc dans ce goût là:

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
<meshes> 
     table.obj
     chaises.obj
     lentille.obj
</meshes>
<FBO>
     table.obj
     chaises.obj
</FBO>
<FBO>
     lentille.obj
</FBO>
<RENDU>
     compositing des FBO
</RENDU>

tout ça c'est bien beau, mais je me demande si ça a du sens de faire comme ça. Parce que dans ce que j'ai pu voir sur le net pour coder différents effets opengl, j'ai jamais vu de rendus multipasses comme ça, avec des jeux d'objets différents. Donc ça m'inquiète un peu, j'ai peur de faire fausse route.
Est-ce que d'autres moteurs fonctionnent sur ce principe?


de même, mes reflexes de graphistes me poussent à créer des passes de rendu un peu plus exotiques encore, par exemple une passe de material ID (c'est ce qu'on peut voir sur cette image: http://area.autodesk.com/th.gen/?z/h...iwa6:720x0.jpg ça permet d'identifier à chaque pixel quel objet est affiché, ce qui peut être utile pour le compositing )
donc ça reviendrait à préciser, pour chaque passe, les objets qui seront affichés, mais aussi un shader spécifique à chaque objet

ça aussi, ça a du sens?

vous vous y prendriez comment vous?

[LeGreg]

les moteurs temps réel (utilisé dans les jeux) ne fonctionnent pas trop comme ça.

Les effets type réflection, réfraction, déformation etc sont les plus compliqués à mettre en œuvre en 3d polygonale dans un rasteriseur (l'algorithme de base des cartes graphiques actuelles). Les jeux font souvent des simplifications par exemple la lumière ne peut pas faire d'aller retour, les surfaces réfléchissantes sont plates ou les objets réfléchis sont à l'infini.

Si tu veux utiliser à fond le hardware, il faut faire un rendu préalable dans une texture (2D ou cubemap), chaque passe dans une texture différente est coûteuse surtout s'il y a plusieurs points de vue et bien entendu il n'y a pas de récursion.

Alors bien sûr il est très possible de faire illusion, en ne faisant pas trop attention à certains détails, mais ne part pas trop dans le délire genre "je vais faire comme dans mon programme de raytracing".

Certaines personnes font des programmes de raytracing en temps réel ceci dit, voir par exemple ce que fait NVIDIA : http://developer.nvidia.com/optix-interactive-examples sur ses propres cartes graphiques.
Mais ce que tu gagnes en flexibilité, tu le perds sur beaucoup d'autres choses.

LeGreg

[manimouleLight&Magic]

merci de ta reponse legreg (ton pseudo ne m'est pas inconnu d'ailleurs... J'ai probablement déjà lu des tutos que tu as écrit )

il est clair qu'un raytracer serait l'idéal dans mon cas pour avoir des effets optiques au poil, mais mon application est soumise à un temps réel assez strict (simulation physique inside). Même si la bécane qui accueille le programme dispose de beaucoup de ressources, je peux pas me permettre d'avoir un framerate trop bas, d'autant plus que j'ai besoin d'un rendu stéréoscopique. J'ai donc depuis longtemps abandonné l'idée de lancer le moindre rayon

je connais bien le principe du rasterizer, mais je suis pas sûr de voir ce que tu veux dire:
quand je disais que je pouvais me contenter d'approximations pour les effets optiques, je parle de TRES GROSSES approximations. Par exemple, ça ne me fait pas peur pour faire un effet loupe de ne jamais prendre en compte les normales de la loupe, mais de faire un vulgaire scale uniforme de l'arrière plan (c'est vraiment grossier, mais ça suffirait dans mon cas)

mon problème vis à vis du rasterizer, c'est que dans ce domaine, on délaisse beaucoup la notion de transparence, et comme les environnements qu'on rend habituellement n'ont que très peu de zones transparentes, on peut se contenter d'avoir des passes de rendu préliminaires qui sont assez simplistes (Zbuffer, normales en eye-space, et couleur). C'est assez logique: sur un rendu classique on n'a aucun intérêt à savoir ce qui se passe derrière la géométrie du premier plan

mais dans mon cas précis, c'est une autre paire de manche: si je veux faire une vitre en verre dépoli (une vitre floutée), j'ai besoin de connaitre ce qu'il y a derrière cette vitre. Et à part en ayant fait un premier rendu dans une texture contenant seulement l'arrière plan, je vois pas d'autre alternative

en fin de compte ma question peut se résumer comme ça:
dans un moteur opengl classique, comment se déroulerait le rendu si on voulait rendre une scene constituée:
-d'une table sur laquelle sont posés plusieurs objets, dont une statuette en verre
-avec une fausse refraction (même ultra-approximative) et des reflets spéculaires sur le verre de la statuette

[pyros]

Salut,

Je dirais (très schématiquement):
- Une passe classique qui rend la table (sans la statuette) à l'écran et dans un FBO (une texture)
- Une passe pour générer une envMap de la scène ayant pour origine la statuette (ça permettra d'avoir les reflets).
- Une passe de rendu de la statuette avec shader plus ou moins compliqués pour gérer la transparence de la statuette (en se servant de la texture générée à la 1ere passe) et les reflets (en se servant de l'envMap de la 2nd passe).

Les envMap permettent généralement de simuler un lancer de rayon à 1 rebond et le rendu multi-passes (arrière plan dans un FBO puis objet transparent) de gérer les effets de réfractions.

[oxyde356]

Si ta scène est statique : tu précompute une envmap

Si ta scène est dynamique, tu fais deux passes :
- Dans la première tu dessine tes objets opaques dans la target 1 de ton fbo
- Dans la deuxième tu dessine tes objets transparents ordonnés du plus lointain au plus proche (par rapport à leur centre de gravité par exemple => ça marche tant que les objets ne se chevauchent pas ou ne se contiennent pas l'un l'autre, bref une approx), et tu te sers de la texture issue de la target 1 pour calculer ta réfraction (ça pose des problèmes quand la réfraction est très forte ou que ton objet est sur le bord de l'écran [il y a pas mal de workaround pour donner un bon effet] mais en gros c'est ce qui est fait dans la plupart des jeux vidéos et honnêtement c'est nickel), une fois tous les objets transparents dessinés dans ta target 2, tu dessine un grand quad qui prend tout ton viewport, tu règle la fonction de depth de façon à ce que seul les pixels où ils n'y avait pas d'objets transparents dessinés restent et tu recopie la target 1 dans la target 2 dans le fragment shader de ce quad (sans avoir besoin d'une passe supplémentaire donc, juste un drawcall, et si tu avais besoin de désactiver le depth et bien commence par dessiner ce quad avant de dessiner tes objets transparents alors mais plus de pixels devront être recopiés).

Bon pour l'histoire du quad à la fin j'invente un peu histoire de ne pas bousiller une passe pour faire de la copie / composition mais l'idée me semble tout à faire réalisable et performante.

[manimouleLight&Magic]

ok, donc ça confirme que mon approche était correcte, j'ai bien besoin de passes ne contenant pas la même géométrie.

me voilà rassué

merci à tous !