Bonjour à tous,
 
Tout est dans la sujet. J'ai beau parcourir la doc de DirectX dans tous les sens, j'arrive pas à comprendre clairement à quoi ça correspond exactement ce RHW. J'ai bien assimilé qu'en l'utilisant dans la définition d'un FVF, ça signifie que les transformations ne sont pas prises en charge par DirectX, mais au-delà de ça ?
 
Y a-t-il un rapport avec le W-buffer ?
 
J'ai juste trouvé un topic sur le forum qui posait à peu près la même question, mais il ne m'a pas vraiment éclairé :
http://forum.hardware.fr/forum2.ph [...] h=&subcat=
 
Voilà, je laisse la parole aux pros.

reciprocal of homogeneous W (RHW) = 1 / hw.  
 
à utiliser lorsque tu veux dessiner en coordonnées écran, ie que tu projettes toi-même. le 1 / hw est la coordonnée qui sera interpolée dans le [z/w]buffer.
 
pour info, les coordonnées homogènes rajoutent une 4ème coordonnée à un système, donc 4 coordonnées pour un système 3d :
 
(x, y, z, w).  
 
ça te permet de traiter / concaténer toutes sortes de transformations par des matrices 4x4 : dans une matrice 3x3, on peut ranger scaling, rotation & co. rajouter une 4ème coordonnée permet de traiter translations, projections & co. pour passer d'une coordonnée homogène à la 'vraie' coordonnée, tu divises par w :
 
(x', y', z' = (x/w, y/w, z/w).
 
tu te retrouves donc avec un 1/w, utilisé pour l'interpolation des coordonnées dans l'espace écran (texture, zbuffer, couleur, etc).

J'avoue que j'ai pas tout compris là.
 
Déjà, partons de la base, c'est quoi une coordonnée homogène exactement ?
 
Et tu parles beaucoup d'interpolation mais c'est encore un terme assez vague pour moi, surtout dans un contexte aussi mathématique.
 
Si tu pouvais me donner encore un petit coup de pouce, ce serait sympa.
 
 

>> Déjà, partons de la base, c'est quoi une coordonnée homogène exactement ?
 
tu connais les matrices ? si oui, tant mieux. si non, cherche sous google. ou demande.
 
donc, pour scaler un point / un vecteur 2d d'un facteur s, on utilise cette matrice :
 
M1 =  
s 0
0 s
 
notre vecteu à tranformer est V = (x, y). multiplier V par M donne V' = (x', y' = (x*s, y*s).
 
pour tourner un point de a radians autour de l'origine, on utilise :
 
M2 =
cos(a) -sin(a)
sin(a) cos(a)
 
si on veut obtenir une matrice qui change l'échelle et fait tourner un point, on multiplie M1 et M2. on peut alors transformer V par M3, V' sera le point changé d'échelle puis tourné.
 
maintenant, on veut translater V. on peut utiliser une matrice  
M4 =
(translationX, translationY)
 
et faire V' = V + M4. note le + et non pas la multiplication. on est maintenant obligé d'avoir deux types d'opérations pour effectuer des calculs simples sur des points. pire, si on veut tourner le point, le translater, le tourner, on doit faire trois calculs différents à la suite. sauf si ... on utilise une petite gruge. prenons une matrice identité :
 
M5 =  
1 0
0 1
 
calculons notre vecteur V' = V*M5.
 
V'.x = M5.a11 * x + M5.a21 * y;
 
si on rajoutait un composant unitaire à V, on pourrait ranger un coefficient de translation en dernière ligne. tranformons notre vecteur V(x, y) en V2(x, y, 1). transformons notre matrice M5 pour rajouter ces facteurs :
 
M6 =  
1 0 0  
0 1 0
tx ty 1
 
tranformons V2 :
V2'.x = 1*x + 0*y + tx*1;
V2'.y = 0*x + 1*y + ty*1;
V2'.w = 0*x + 0*y + 1*1;
 
nos vecteurs 2D ont maintenant 3 composantes, nos matrices de transformations 2D ont 3 x 3 composantes. multiplier des matrices entre elles concatène les transformations. on peut maintenant représenter une suite de transformations (translation, scale, rotation) avec une seule matrice.
 
exemple d'application : faire tourner les points autour d'un nouveau centre (cx, cy).
 
il faut :
* translater le point de (-cx, -cy)
* appliquer la rotation
* translater le point de (cx, cy)
 
on peut calculer ces 3 matrices, les concaténer et obtenir une matrice qui représente cette suite de transformations. au lieu des 3 opérations précédentes (ajouter la matrice trans, multiplier la matrice rotation, ajouter la matrice trans), on n'en a qu'une : V2' = V2 * matrice.
 
pour le moment, w vaut toujours 1. on peut utiliser la même astuce pour représenter une matrice projection : là, w sera différent de 1, on devra alors diviser les composantes du vecteur par w pour trouver la coordonnée non homogène :
 
(x, y, z, w) -> (x/w, y/w, z/w)
 
bref, coordonnées homogènes car elles permettent d'homogénéiser les systèmes de transformation.
 
(pour la projection, je te laisse faire le calcul. la projection est une application de Thalès, tu vas te retrouver avec qq chose comme x' = x/z. il n'y a qu'à trouver le moyen de ranger ça dans une matrice homogène. )
 
>> Et tu parles beaucoup d'interpolation mais c'est encore un terme assez vague pour moi, surtout dans un contexte aussi mathématique.  
 
interpolation = littéralement 'polir entre'. interpolation de base : étant donnés deux valeurs, trouver des valeurs intermédiaires. par exemple entre deux couleurs : A et B, pour passer doucement d'une couleur à l'autre, tu fais couleurIntermédiaire : A*(1-f) + B*f, où f varie entre 0 et 1.
 
>> donc, pourquoi le rhw ?  
 
là, je risque de dire des conneries ... hmmm
 
l'interpolation située plus haut est une interpolation linéaire : si tu as deux points (x1, y1) et (x2, y2) et que tu les interpoles comme dit, tu obtiendras le segment reliant ces deux points.
 
en 3d, l'interpolation est utilisée pour l'affichage des polygones. pour un triangle, tu as 3 points. interpoler par couple entre ces points te donneras 3 segments. MAIS les points interpolés seront en 3d, donc régulièrement espacés en 3d. le problème : lorsque tu affiches ces polygones, leurs points sont projetés sur ton écran, en 2D. interpoler les points 3d et les projeter ne donnera PAS des points régulièrement espacés en 2D. normal : regarde une feuille à carreaux de haut, les points sont régulièrement espacés sur celle-ci. fais tourner la feuille, les points restent régulièrement espacés sur la feuille, mais pas sur l'image formée sur ton oeil. les droites convergent en lignes de fuite.
 
DONC le problème pour afficher les polygones : les points sont projetés, puis on affiche le polygone en scanline : ligne par ligne (en suivant l'ordonnée de l'écran, on part du haut vers le bas). pour chaque ligne, on a y = constante, on parcourt entre 2 points x1 & x2. si tu essayes d'interpoler linéairement les coordonnées de texture (u & v), ou l'intensité d'éclairage, tu vas te retrouver avec de très gros défauts (des déformations). pour contrer ça, il faut interpoler dans un espace linéaire à l'écran. 1/w l'est. mais les coordonnées de texture u & v, ne le sont pas. u/w, v/w le sont. on peut donc interpoler u/w, v/w, et 1/w pour chaque pixel. ensuite, coordonnée de texture u interpolée = (u/w) / (1/w). et hop !
 
oui, c'est compliqué.
 
relation avec le wbuffer, zbuffer ? hmmm ... je sais plus trop. et j'ai la flemme. cherche voir

 
 
wow ! Merci de t'être donné autant de mal pour moi ! J'avoue ne pas avoir tout compris à la première lecture, mais je vais bosser ça. J'ai assez bien saisi le principe des matrices de transformations, il faut maintenant que j'étudie plus avant les différents changements d'espace (modèle -> monde -> camera -> projection).
 
Voilà, merci encore. Tu m'as l'air assez calé sur le sujet en tout cas.

>> Voilà, merci encore. Tu m'as l'air assez calé sur le sujet en tout cas.
 
j'ai commencé la 3d en software, donc rendu de polygone / mapping corrigé à la main, gestion de hiéarchie de même ... ça aide beaucoup. il y a pas mal de docs qui traînent là-dessus sur le net, suffit de chercher et de beaucoup lire / expérimenter.