Soutenez-nous
Publicité
+ Répondre à la discussion
Affichage des résultats 1 à 6 sur 6
  1. #1
    Invité de passage
    Inscrit en
    novembre 2007
    Messages
    13
    Détails du profil
    Informations forums :
    Inscription : novembre 2007
    Messages : 13
    Points : 3
    Points
    3

    Par défaut rendu en plusieurs passes

    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 :
    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?

  2. #2
    Membre Expert

    Profil pro
    Programmeur
    Inscrit en
    août 2002
    Messages
    1 054
    Détails du profil
    Informations personnelles :
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : Programmeur

    Informations forums :
    Inscription : août 2002
    Messages : 1 054
    Points : 1 444
    Points
    1 444

    Par défaut

    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

    Mon site web | Mon blog | Mes photos | Groupe USA
    > BONJOUR, JE SUIS NOUVEAU SUR CE FORUM
    > presse la touche caps lock, stp
    > OH.. MERCI C EST BEAUCOUP PLUS FACILE COMME CA

  3. #3
    Invité de passage
    Inscrit en
    novembre 2007
    Messages
    13
    Détails du profil
    Informations forums :
    Inscription : novembre 2007
    Messages : 13
    Points : 3
    Points
    3

    Par défaut

    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

  4. #4
    Membre Expert
    Homme Profil pro
    Inscrit en
    mars 2011
    Messages
    542
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : mars 2011
    Messages : 542
    Points : 1 046
    Points
    1 046

    Par défaut

    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.
    La perfection est atteinte, non pas lorsqu’il n’y a plus rien à ajouter, mais lorsqu’il n’y a plus rien à retirer. - Antoine de Saint-Exupéry

  5. #5
    Membre émérite Avatar de oxyde356
    Homme Profil pro
    Ingénieur Recherche Imagerie
    Inscrit en
    février 2006
    Messages
    798
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur Recherche Imagerie

    Informations forums :
    Inscription : février 2006
    Messages : 798
    Points : 920
    Points
    920

    Par défaut

    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.

  6. #6
    Invité de passage
    Inscrit en
    novembre 2007
    Messages
    13
    Détails du profil
    Informations forums :
    Inscription : novembre 2007
    Messages : 13
    Points : 3
    Points
    3

    Par défaut

    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 !

+ Répondre à la discussion
Cette discussion est résolue.

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •