Qu'est-ce qui fait qu'une surface chevauche une autre exactement?

Je ne peux pas vraiment comprendre ce qui fait qu'une surface chevauche une autre. Dans un moteur 3D que je crée, ma technique échoue dans les cas marginaux.

Ma méthode consiste à trier les surfaces à peindre du plus éloigné au plus proche. Pour déterminer la proximité, je compare les valeurs moyennes de z. Parfois, cependant, une surface qui se chevauche a une valeur z moyenne plus élevée que celle qu'elle chevauche. Ainsi, la surface la plus éloignée est peinte sur la plus proche - ce qui entraîne un rendu bizarre comme celui-ci:

Ce que l'on est censé voir, c'est la surface avant violette du cube uniquement, tandis que la surface latérale rouge est peinte sur celle violette. La valeur z moyenne de la surface violette est plus élevée, et donc plus éloignée. Je doute donc que cette technique soit correcte.

Ce que j'ai également essayé, c'est d'obtenir la distance entre la caméra (c'est-à-dire l'origine) et la surface, mais j'avais besoin d'un point. J'ai choisi le milieu de chaque surface mais cela ne semble pas toujours fonctionner car toutes les surfaces ne sont pas aussi grandes les unes que les autres.

Par conséquent, quel est un moyen fiable pour déterminer l'ordre de proximité des surfaces vers l'origine?

Vous semblez essayer d'implémenter l' algorithme des peintres . Je suppose que vous essayez d'écrire un rasteriser à partir de zéro comme exercice d'apprentissage, car la plupart des matériels 3D modernes utilisent ce que Bart a mentionné (le tampon Z / Depth). Pour que l'algorithme des peintres fonctionne dans tous les cas, vous devez être prêt à subdiviser les surfaces au fur et à mesure qu'elles sont rendues pour résoudre des scénarios possibles (tels que le problème de chevauchement des polygones montré sur la page Wikipedia).

En effectuant le rendu du plus éloigné au plus proche, vous passez également du temps à rendre des pixels qui seront éventuellement occultés par d'autres polygones, ce qui, lorsque vous commencez à mettre des textures et des shaders complexes sur les polygones, gaspille de précieux cycles. C'est la raison pour laquelle le matériel moderne préfère que vous effectuiez un rendu d'avant en arrière, en utilisant le tampon de profondeur pour déterminer si le pixel à rendre est plus éloigné que celui à l'écran (et peut donc être supprimé).

Même avec la plupart des matériels d'accélération modernes, vous devrez toujours trier et restituer d'arrière en avant tous les polygones semi-transparents, le rendu uniquement une fois que tous les polygones opaques auront été rendus.

Ce que vous avez, c'est un problème de visibilité . Une solution utilise un z-buffer .

Le tri des faces selon leur valeur z moyenne ne fonctionne pas, car la valeur z moyenne ne fournit aucune information sur la valeur z réelle des sommets ou même des pixels de surface.

Exemple (avertissement, art ASCII à venir):

          /
         /
cam     /
-->    / 
      /
     /--       <--B
    /
    ^--A

Il y a deux faces A et B. Du point de vue de la caméra, A est devant B. Pourtant, la valeur z moyenne de B est plus petite. Regardons les autres valeurs z:

• la valeur z minimale de A est 4
• la valeur z maximale de A est 11
• par conséquent, la valeur z moyenne de A est de 7,5
• la valeur z minimale de B est 6
• la valeur z maximale de B est 8
• donc la valeur z moyenne de B est 7

Vous pouvez essayer de les trier par leurs valeurs z minimales mais il y a des cas où cela ne fonctionnera pas trop. Il n'y a tout simplement aucun moyen de trier correctement les faces arbitraires en utilisant une seule valeur z.

Dans l'algorithme de Newell http://en.wikipedia.org/wiki/Newell's_algorithm ce que vous faites est de trier les plages min / max des valeurs z. Si les plages de deux faces ne se chevauchent pas, vous pouvez savoir avec certitude laquelle est en face. S'ils le font, parfois vous devez absolument diviser les visages. Parfois, il suffira de suivre tous les sommets pour l'occlusion ou une autre technique.

C'est bien que vous appreniez le rendu en faisant. Gloire. Dans ce cas, il n'y a pas de solution "d'algorithme de peintre", au lieu d'essayer de le réparer par tri, sur la PS1, nous essayions juste de garder les polygones autour de la même taille lorsqu'ils étaient côte à côte (ce que vous faites comme autant que je sache), et la suppression de face arrière (ce que vous ne faites pas)

L'abattage de la face arrière vérifie la normale de la surface dans l'espace d'écran pour sa direction (obtenez simplement le signe de l'élément de profondeur de l'espace d'écran transformé normal (dans notre cas, c'était le z de la normale), ou le produit croisé de deux vecteurs de la triangle ie croix (v1-v0, v2-v0))

Si vous implémentez l'abattage de face arrière, vous réduisez également la quantité de pixellisation que vous faites .. double gain.