Ombres en temps-réel Nicolas Holzschuch Cours dOption Majeure 2

Slides:



Advertisements
Présentations similaires
( Application Programming Interface)
Advertisements

Chaîne de Synthèse Réel Modélisation Rendu Image Fichier Scène
Carsten Dachsbacher Christian Vogelgsang Marc Stamminger
Hierarchical Z-Buffer Visibility
Tous droits réservés. Reproduction intégrale ou partielle interdite sans autorisation écrite de la partdu titulaire des droits dauteur. Institut de Formation.
Fanny CHEVALIER Guillaume CAURANT
LOD et Progressive Meshes (maillages progressifs) Hugue Hoppes 1996
Unstructured Lumigraph Rendering
The Reyes Image Rendering Architecture
Qian Cui, Stephane Wolf & Arnaud Choquart - DESS IMM /2003
Technique des Surfels Surfels: Surface Elements as Rendering Primitives SIGGRAPH 2000 H.Pfiste, J.van Baar, M.Zwicker, M.Gross.
Matthias Zwicker Hanspeter Pfister Jeroen van Baar Markus Gross
Efficient Simplification of Point-Sampled Surfaces
Interactivé: L'Action Script.
Structures de données et complexité
Les erreurs types à ne pas commettre OpenGL Carina Portella Jean-Philippe Reynier DESS TNI – IDI Année
Modèles empiriques d’éclairement
Rendu de pierres taillées en temps réel Stéphane Guy Directeur de stage: Cyril Soler.
IMAGIS-GRAVIR / IMAG Rendu de forêts en temps-réel iMAGIS / GRAVIR Franck Sénégas DEA IVR Tuteur: Fabrice Neyret.
Xavier Décoret* Frédo Durand° François Sillion*
جامعــــــة محمد خيضــــــــــــر
12 novembre 2012 Grégory Petit
Programmation des logiciels infographiques interactifs 2D et 3D, et le OpenGL.
Images numériques Quand les images parlent.
INF-1019 Programmation en temps réel
Réalisation dun travail concret avec des matrices Afficher un objet 3D sur une surface Lui appliqué des transformations Le voir se transformer suivant.
Real-time Shadows Xavier Décoret Cours d’option Majeure 2.
Génération et rendu 3D de forêt en OpenGL
Nicolas Holzschuch Cours d’Option Majeure 2
IFT3730: Infographie 3D Transformations Géométriques
1 Transformations affines But: fixer le positionnement et lorientation des objets de la scène.
Résolution des Équations Différentielles
La mise au point et la profondeur de champ
SUJETS SPÉCIAUX EN INFORMATIQUE I PIF Contenu du cours Transformations géométriques des objets –Transformations 2D –Transformations entre systèmes.
Modélisation géométrique à l’aide d’un maillage
Rendu volumique Nicolas Holzschuch iMAGIS/GRAVIR IMAG
Nicolas Holzschuch iMAGIS-GRAVIR/IMAG
Images synthètiques de haute qualité
IFT3730 : Infographie 3D Systèmes et modèles graphiques Pierre Poulin, Derek Nowrouzezahrai Hiver 2013 DIRO, Université de Montréal.
IFT2740 : Outils de l'infographie 3D Systèmes et modèles graphiques
Design dun système de vision embarqué. Application:
Développement dapplication avec base de données Semaine 10 : WCF avec Entité Framework Automne 2013.
IFT3355: Infographie Visibilité
SCHNEIDER Laurent NOYER Vincent TEISSIE Alexis
PROTOTYPE D’UN PROGRAMME ÉCRIT EN C++ BASÉ SUR OPENGL
Projet Télédétection Vidéo Surveillance Deovan Thipphavanh – Mokrani Abdeslam – Naoui Saïd Master 2 Pro SIS / 2006.
Triangulation de Delaunay
Modélisation géométrique
Les images de synthèses Duprat Anatole. Les images de synthèses consistent en la création assistée par ordinateur, d'images numériques. Il existe différentes.
KF-RAY Raytracer parallèle Projet long d’informatique
Création en images de Synthèse Modèles de rendu d’une scène 3D
GRAPHISME PAR ORDINATEUR
Projet Lancer de Rayons
Modèles Mathématiques et représentation discrètes pour la description des images couleur Luc Brun.
L’Audio sur PC Comparaison Numérique vs Analogique Comparaison Audio sur PC vs Hardware dédié (DSP) Rmq: beaucoup de simulitudes avec la vidéo, mais débit.
Credits : Joëlle Thollot, Hector Briceño, Edmond Boyer
1. Ook Christophe Delagarde, septembre 1999 I.U.T., Université de la Méditerrainée 2.
GRAPHISME PAR ORDINATEUR SIF Contenu du cours 10 Textures –Définir la texture –Superposition d’une texture sur une surface plane –Superposition.
Ombre et pénombre Cas d’une source ponctuelle S
Chapitre 1 Nombres relatifs.
GRAPHISME PAR ORDINATEUR SIF Contenu du cours 8 Rendu de surfaces –Modèles de rendu de surfaces –Illumination de la scène –Sources lumineuses –Composante.
1. Spoon Christophe Delagarde, septembre 1998 I.U.T., Université de la Méditerrainée 2.
Architecture et Fonctionnement d’un GPU Géométrie Rendu.
Structures de données avancées : Arbres B+ avec expansion partielle D. E ZEGOUR Institut National d ’Informatique.
MPEG : normalisation La vidéo est compressé en MPEG2 Une vidéo classique : (720x576) à 50 images entrelacées par seconde. Le Mpeg-2 travaille sur 1/4 de.
Plan du cours Cours 1,2 : le pipeline graphique
Visualisation des flots optiques en 3D
Éclairage, ombrage Fiat lux !.
Introduction aux technologies du jeux-vidéo Steve Gury
…que Dedicated Micros a lancé un nouvel enregistreur vidéo numérique hybride Saviez-vous?
Transcription de la présentation:

Ombres en temps-réel Nicolas Holzschuch Cours dOption Majeure 2

Ombres en temps-réel Pourquoi faire ? Les ombres Shadow maps Shadow volumes Ombres douces

Les ombres : pourquoi ? Réalisme accru Positionnement spatial Information sur les objets Informations sur le système graphique : –Comment ça marche, pourquoi,… –Nombreuses extensions, additions,…

Exemples + Vidéo

Ombres dures/ombres douces Vidéos

Techniques 2 méthodes : –Shadow mapping Basé image –Shadow volumes Basé objet –Démos

Shadow mapping Source lumineuse ponctuelle Principe : –Carte de profondeur de la scène –Vue depuis la source lumineuse Pour chaque pixel de limage –Calculer position par rapport à la source –Calculer profondeur par rapport à la source –Comparer à la profondeur stockée –Égal : lumière, plus grand : ombre

Shadow volume Source lumineuse ponctuelle Principe : –Silhouette des objets vus depuis la source –Plans infinis sappuyant sur la source et sur chaque arête –Définit « volume dombre » Pour chaque pixel de limage : –Compter le nombre de plans entrants et sortants –Positif : ombre, nul : lumière

Et maintenant, les détails

Shadow mapping Source lumineuse ponctuelle Principe : –Carte de profondeur de la scène –Vue depuis la source lumineuse Pour chaque pixel de limage –Calculer position par rapport à la source –Calculer profondeur par rapport à la source –Comparer à la profondeur stockée –Égal : lumière, plus grand : ombre

Shadow mapping A < B : ombre light source eye position depth map Z = A fragments light Z = B depth map image plane eye view image plane, aka the frame buffer

Shadow mapping AB : lumière light source eye position depth map Z = A fragments light Z = B depth map image plane eye view image plane, aka the frame buffer

Carte de profondeur Comment la générer ? –Pourquoi cest compliqué ? –back-buffer –pbuffers Précision/coût –En xy –En z

Pourquoi cest compliqué ? CPU Mémoire Disque dur Carte-mère Processeur graphique Mémoire Carte graphique Écran

Comment faire ? Le CPU ne peut pas faire le travail : –Trop lent –Transfert trop lent Cest le processeur graphique qui travaille –Comment faire pour dessiner la scène sans lafficher ? –Deux solutions : back-buffer et pbuffers

Double-buffering Laffichage peut être lent Lutilisateur voit la scène safficher morceau par morceau –Gênant Idée : double-buffer –Deux buffers –On affiche le front-buffer –On dessine dans le back-buffer –Quand on est prêt : glutSwapBuffers();

Double-buffering Suppose que la carte soit équipée : –Coût mémoire supplémentaire (léger) –Automatique de nos jours À demander à la création du contexte OpenGL glutInitDisplayMode(GLUT_DEPTH|GLUT_RGB|GLUT_DOUBLE); Ne pas oublier déchanger les buffers…

Application aux ombres On a un endroit pour dessiner ! On dessine la scène une première fois : –Avec la matrice de projection de la lumière –Directement dans le back-buffer –Ensuite, transfert en mémoire On dessine la scène une deuxième fois : –Avec la matrice de projection de la caméra –Toujours dans le back-buffer –Échange des buffers

Problème Résolution du back-buffer limitée : –À la résolution de la fenêtre –Problèmes daliasing Si je veux davantage de résolution : –pbuffers –Possibilité de rendu sur la carte, par le processeur, dans une zone mémoire spécifique –Résolution plus grande que celle de la fenêtre –Mais pas illimitée –Pas toujours possible, dépend de la carte

Pour chaque pixel Génération de coordonnées de texture –Matrice de projection de la lampe + conversion –Résultat : (r,s,t) coordonnées de texture –r distance à la source –(s,t) coordonnées dans la carte de profondeur –Comparaison r / carteProfondeur (s,t) Extension OpenGL : –GL_ARB_SHADOW ou GL_SGIX_SHADOW

Extensions OpenGL OpenGL : –Spécifications ( –Liste de fonctionnalités ( glBegin, glEnd …) –Architecture Review Board (ARB) Extensions : –Nouvelles fonctionnalités –Décision par lARB (meetings) –Extensions « officielles » : Spécifications approuvées, publiques Nom et prototypes de fonctions publics Différents niveaux dintégration : –GL_ARB_EXTENSION, GL_EXT_EXTENSION, GL_CONSTRUCTEUR_EXTENSION

Extensions OpenGL Comment savoir si une extension est présente ? –glxinfo – (liste cartes+drivers = extensions) –glutExtensionSupported("GL_SGIX_shadow"); On y reviendra au prochain cours

GL_SGIX_SHADOW glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_SGIX, GL_TRUE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_OPERATOR_SGIX, GL_TEXTURE_LEQUAL_R_SGIX); Implémentation très simple

Algorithme Désactiver laffichage des polygones Dessiner la scène Transférer le Z-buffer en mémoire Ré-activer laffichage des polygones Affecter la carte de profondeur comme texture Activer la shadow-map Dessiner la scène Échanger les buffers

Algorithme Désactiver laffichage des polygones : –glColorMask(0,0,0,0); –glDisable(GL_LIGHTING); Permet de gagner du temps –La carte graphique travaille moins Dessiner la scène

Algorithme Récupérer le Z-buffer : glCopyTexImage2D(GL_TEXTURE_2D,0, GL_DEPTH_COMPONENT16_SGIX, 0,0,width,height,0); Alternative : glReadPixels(0, 0, width, height, GL_DEPTH_COMPONENT, taille, pointeur); glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT16_SGIX, width, height, 0, GL_DEPTH_COMPONENT, taille, pointeur); Double transfert CPU/carte graphique !

Algorithme Ré-activer laffichage des polygones : glEnable(GL_LIGHTING); glColorMask(1,1,1,1); glViewport(0, 0, winWidth, winHeight); Activer la shadow map Dessiner la scène Échanger les buffers

Shadow mapping Avantages : –Très simple à implémenter –Code compact –Marche toujours (scène quelconque) Inconvénients : –Problèmes déchantillonnage (xy et z) –Deux passes de rendu (vitesse divisée par deux) Ne pas regénérer systématiquement la shadow map, seulement si la source se déplace –Besoin dextensions OpenGL (disponibles ?)

Échantillonnage Principal inconvénient Système discrétisé Double discrétisation : caméra et source lum. Conflit de précision

Précision en xy La plus visible Solution : augmenter la résolution de la carte –Limite liée à la carte Pas toujours suffisant : –Projection de la texture depuis la source –Pixels après projection déformés et agrandis –Cas idéal : source proche de la caméra –Cas le pire : source opposée à la caméra Animal dans les phares (pas bon pour lui)

Cas idéal : lampe de spéléo Caméra Source La couleur représente laire projetée dun élément de surface Le fantôme représente lombre de lobjet

Cas le pire : source opposée Caméra Source

Source opposée

Résolution en xy Principale source derreur Solutions : –Augmenter la résolution –Déformer la shadow map pour augmenter sa résolution près de lœil –Résolution adaptative Pas de solution idéale si la source est face à lœil

Shadow mapping A < B : ombre light source eye position depth map Z = A fragments light Z = B depth map image plane eye view image plane, aka the frame buffer

Shadow mapping A B : lumière light source eye position depth map Z = A fragments light Z = B depth map image plane eye view image plane, aka the frame buffer

Problèmes de précision

Problème de précision La carte de profondeur est aussi discrétisée en z Besoin de précision : 16 bits, 24 bits… Problèmes avec z voisins : –Auto-ombrage des surfaces Solution : –Déplacer la carte de profondeur (bias) –Trouver la valeur idéale : Trop peu : les surfaces sombrent elles-mêmes Trop : les ombres disparaissent –glPolygonOffset();

Variantes : ID-buffer Pour éviter les problèmes dauto-ombrage Une couleur par objet Objet = ? –Quelque chose qui ne peut pas sombrer –Convexes Ombrage si ID objet ID dans buffer Pas de problème de précision –Mais besoin nombreuses ID : 16 bits Problème si objets proches les uns des autres

Précision La résolution effective dépend de la pyramide de vue de la lampe –Large cône de vue : résolution gaspillée Plus la pyramide est proche des objets, plus on est précis Rapprocher la pyramide de vue –En xy : faible angle douverture –En z : front plane et far plane rapprochés

Shadow Mapping : résumé Avantages : –Très simple à implémenter, code compact –Marche toujours (scène quelconque) –Prix indépendant de la complexité de la scène –Nombreuses variantes pour améliorer la qualité Inconvénients : –Problèmes déchantillonnage (xy et z) –Deux passes de rendu –Artefacts visibles –Sources omni-directionnelles ?

Shadow volume Source lumineuse ponctuelle Principe : –Silhouette des objets vus depuis la source –Plans infinis sappuyant sur la source et sur chaque arête –Définit « volume dombre » Pour chaque pixel de limage : –Compter le nombre de plans entrants et sortants –Positif : ombre, nul : lumière

Shadow volume

Silhouette des objets Travail sur le modèle Pour chaque arête du modèle : –Identifier polygones quelle relie –Produit scalaire normale / vecteur vers la source –Si produits scalaires de signe différent : arête de silhouette –Besoin structure de données sur le maillage Sur-ensemble de la silhouette des objets

Volume dombre Plans définis par (arête + source) Définit volume dombre : –En fait, plusieurs volumes imbriqués –On est à lombre si on est à lintérieur dau moins un volume Principe : pour chaque pixel, on compte les plans, de lœil jusquà la surface affichée –Entrée/sortie dans le volume –Nombre total de plans croisés

Compter les plans Stencil buffer : –Autre fonctionnalité OpenGL –Buffer auxiliaire, jamais affiché –Opérations possibles : Incrémenter/décrémenter le stencil buffer Conditions sur le stencil buffer, actions sur lécran –Multiples utilisations : Ombres, réflexions, fenêtres… Rendu conditionnel Début de programmation de la carte

Utilisation du stencil buffer Premier rendu de la scène –Initialise le Z-buffer Rendu du volume dombre –Pour chaque plan positif : glStencilOp(GL_KEEP,GL_KEEP,GL_INCR); –Pour chaque plan négatif : glStencilOp(GL_KEEP,GL_KEEP,GL_DECR); Deuxième rendu de la scène : –glStencilFunc(GL_EQUAL, 0, ~0); Pour la partie éclairée

Algorithme : tracé du volume glDisable(GL_LIGHTING); drawScene(); /* La scène, écl. ambiant */ glDepthMask(0); /* Ne plus écrire ds Z-buffer */ glStencilFunc(GL_ALWAYS, 0, ~0); glEnable(GL_STENCIL_TEST); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glStencilOp(GL_KEEP, GL_KEEP, GL_INCR); glColorMask(0,0,0,0); /* pas modifier framebuffer */ draw_shadow_volume(); /* plans positifs */ glCullFace(GL_FRONT); glStencilOp(GL_KEEP, GL_KEEP, GL_DECR); draw_shadow_volume(); /* plans négatifs */ glColorMask(1,1,1,1); glDepthMask(1); /* On peut écrire ds Z-buffer */

Algorithme : rendu de la scène glStencilFunc(GL_EQUAL, 0, ~0); glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); glEnable(GL_STENCIL_TEST); glDepthFunc(GL_EQUAL); glEnable(GL_LIGHTING); drawScene();

Shadow volume Avantages : –Ombres précises –Positions quelconques lumière/caméra Inconvénients : –Calcul de la silhouette (sur CPU, év. long) –Besoin de modèles fermés, formés de convexes –Deux rendus de la scène, plus rendu du volume –fill-rate : tracé de nombreux polygones, qui couvrent lécran. –Carte limitée en nb. pixels/seconde

Mauvais cas pour le fill-rate

Shadow volume : améliorations Et si la caméra est dans le volume dombre ? –Le compte des plans nest plus bon Système général : –Prendre un point hors du volume dombre –Compter les plans entre ce point et la surface –Exemple de points hors du volume : linfini –Méthode zfail

zfail/zpass

zfail glDepthMask(0); glStencilFunc(GL_ALWAYS, 0, ~0); glEnable(GL_STENCIL_TEST); glEnable(GL_CULL_FACE); glCullFace(GL_FRONT); glStencilOp(GL_KEEP, GL_INCR, GL_KEEP); glColorMask(0,0,0,0); draw_shadow_volume(); glCullFace(GL_BACK); glStencilOp(GL_KEEP, GL_DECR, GL_KEEP); draw_shadow_volume(); glColorMask(1,1,1,1); glDisable(GL_CULL_FACE); glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); glDepthMask(1);

Limites du volume dombre Le volume dombre est défini par des plans Les plans vont de larête à linfini Linfini est difficile à gérer –En pratique, on coupe à une certaine distance –Que se passe t-il si on voit le volume dombre à cet endroit ? –Et si la source est proche de la caméra ? Il faut que le volume dombre soit fermé : –Si on coupe, on ajoute des polygones de fermeture

Limites du volume dombre Applications : limiter le fill-rate Plus le volume est petit, plus le fill-rate est bas Couper les plans : –far clipping plane –Et fermer le volume : Sur les arêtes, par des plans À linfini, par des plans –Ça marche encore –Pyramide de vue de la source

Dark cap/light cap

Limitations du volume dombre

Extensions OpenGL GL_EXT_stencil_two_side –Pour faire les deux faces du volume dombre en une seule passe GL_NV_depth_clamp –Pour avoir des plans qui vont vraiment à linfini GL_EXT_depth_bounds_test –Pour ne rasteriser que les primitives proches de la source

Shadow volume Avantages : –Ombres précises –Positions quelconques lumière/caméra –Si bien programmé, robuste Inconvénients : –Calcul de la silhouette (sur CPU, év. long) –Scènes spécifiques : modèles fermés, formés de convexes –Deux rendus de la scène, plus rendu du volume –fill-rate limité

Ombres douces Algorithmiquement plus compliqué Problème de visibilité point-surface –Au lieu de point-point –Silhouette ? Ombre de la somme somme des ombres Plusieurs algorithmes approximatifs

Ombre/pénombre

Combinaison dombres

Problèmes de silhouette

Ombres douces Accumulation dombres : –Calculer plusieurs ombres ponctuelles –Additionner les résultats, moyenne –Accumulation buffer –Nombre déchantillons élevés –Temps de calcul multiplié par # échantillons

Accumulation 4 échantillons1024 échantillons

Ombres douces Recherche de voisins : –Shadow map normale –Pour chaque pixel dans la shadow map Rechercher frontière de lombre la plus proche Donne position + distance (source, récepteur) Coefficient datténuation fonction du rapport des distances –Lent (recherche sur r 2 pixels) –Limiter r : taille de la pénombre limitée

Ombres douces Volume dombres douces : –Shadow volume normal –Pour chaque arête de la silhouette : Calculer volume englobant la pénombre Pour chaque pixel dans ce volume –Calculer coefficient datténuation –Beau, réaliste –Problèmes de fill-rate multipliés par 2

Résumé : OpenGL OpenGL : –Z-buffer –Double-buffer –Pbuffers –Extensions –Stencil buffer –Accumulation buffer Cartes graphiques : –Rendu en plusieurs passes –Programmables (en un sens) –utilisées pour faire des choses complexes (ombres) –Ce nest que le début

Résumé : ombres Shadow maps : –Stable, robuste, facile, rapide, aliasage Shadow volumes : –Beau, difficile, complexité algorithmique Ombres douces –Complexe, lent, beau