Cartographie des ombres et quads transparents

Le mappage d'ombres utilise le tampon de profondeur pour calculer où les ombres doivent être dessinées.

Mon problème est que j'aimerais que des quads texturés semi-transparents projettent des ombres - par exemple des arbres à panneaux d'affichage. Comme la valeur de profondeur sera définie sur l'ensemble du quad et pas seulement les parties visibles, elle projettera une ombre quad, ce qui n'est pas ce que je veux.

Comment puis-je faire en sorte que mes quadrants transparents projettent des ombres correctes en utilisant le mappage d'ombres?

Votre problème résoudra le rendu avec alpha 1 bit. Ce qui signifie que vous spécifiez un alpha de la texture source qui n'est pas rendu (généralement 0,5).

Vous devez écrire votre propre shader pour économiser la profondeur de la lumière et utiliser les instructions discard. Le rejet existe aussi en hlsl, glsl et en cg. Il n'existe que dans le shader pixel / fragment et élimine le fragment actuel du rendu dans backBuffer et dans z-buffer.

if (texSample.a < 0.5)
   discard;

L'avantage est que vous n'avez pas besoin de modifier le rendu de votre deuxième passe, uniquement le rendu de la profondeur de la lumière. J'ai aussi prouvé que cela fonctionne:

Si vous souhaitez rendre les ombres correctes pour plusieurs objets transparents, vous devrez utiliser plusieurs textures de profondeur, avec des informations de profondeur et d'opacité rendues à l'aide du peeling de profondeur. Et pour la fumée, les cheveux, etc. Les cartes d'opacité profonde ou d'opacité de Fourier sont la meilleure solution (je recommande principalement les cartes d'opacité de Fourier)

edit: Je viens de réaliser que j'ai oublié d'ajouter des crédits. Comme toujours. Le modèle d'arbre est issu du projet loopix, ce qui est tout simplement génial si vous recherchez du lowpoly, une texture et des modèles de végétation gratuits.

Avec un pipeline programmable, vous devez le faire selon les instructions de @notabene. Cependant, c'est aussi facile à faire avec un pipeline fixe sans écrire de shaders. Dans OpenGL, glAlphaFunc est ce que vous voulez. Par exemple:

glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, 0.5f);

Vous avez besoin d'un shader personnalisé pour la génération de la carte des ombres, afin de pouvoir sortir un occluseur valide lorsque la transparence du pixel / fragment est supérieure au seuil que vous spécifiez. Ce whay, la carte de profondeur sera générée par pixel et non par polygone.

La seule façon de penser à cela est de créer une texture de carte de profondeur distincte, d'y rendre les arbres, de produire la profondeur où alpha! = 0, sinon de sortir la profondeur = 1, puis de combiner cette texture de la carte d'ombre avec la texture de la carte d'ombre de la scène , qui devrait être assez simple; prenez simplement la plus petite des deux valeurs et réglez-la sur la carte de profondeur finale.

Cependant, cela ne résout pas les problèmes de fusion; si vous produisez une profondeur derrière une texture alpha, elle sera remplacée lorsque vous rendrez le quad avec la texture dessus, donc pour que cet effet fonctionne, vous devrez rendre chaque quad individuellement dans la texture de la carte de profondeur ...