matrices 4x3 = 'cas particulier' des matrices 4x4, ça évite de stocker des nombres inutiles quand on utilise des coordonnées homogènes.
les coords homogènes sont utilisées avec les matrices 4x4 pour représenter en une seule matrice une somme de transformations diverses et variées (rotation, scale, projection). notation coords homogènes = standard ( [x, y], [x, y, z] ...) + w, qui vaut 1 quand tu fais des transfos linéaires (scale, rotation, translation) et autre chose quand tu fais des projections. une coordonnée homogène 3d [x, y, z, w] n'est pas utilisable directement si w != 1, il faut diviser tous les membres par w pour retomber sur ses pieds.
pourquoi les coordonnées homogènes ? on va bosser en 2d, c'est plus simple - prend un vecteur 2d, une matrice 2x2. comment représenter une translation ? impossible. en rajoutant w, ça devient tout simple - on bosse alors avec un vecteur à 3 composantes (x, y, w) et une matrice 3x3.
une translation 2d (transx, transy) n'est autre que
x' = x*1 + y*0 + transx*1
y' = x*0 + y*1 + transy*1
w' = 1
soit, représenté sous forme de vecteur V multiplié par une matrice M1 :
V = (x, y, 1)
M1 = 1 0 0
0 1 0
transx transy 1
en faisant V*M1, tu retombes sur les équations au-dessus.
l'intéressant est qu'une matrice contient une somme de transformations. par ex une rotation 2D d'un angle a se fait avec :
x' = x*cos(a) - y*sin(a)
y' = x*sin(a) + y*cos(a)
w' = 1
notée sous matrice homogène :
M2 = cos(a) -sin(a) 0
sin(a) cos(a) 0
0 0 1
application : tu as un objet dans son repère local (ie son centre est (0, 0). tu veux le faire tourner sur lui-même puis le translater : ce sont deux transformations. tu les concatènes en multipliant la matrice de rotation par la matrice translation, tu obtiens M3 :
M3 = cos(a) -sin(a) 0
sin(a) cos(a) 0
transx transy 1
tu obtiens alors :
x' = x*cos(a) - y*sin(a) + transx
y' = x*sin(a) + y*cos(a) + transy
w' = 1
soit la rotation de l'objet + sa translation.
différence avec la 3d ? tu rajoutes des lignes et des colonnes. ton vecteur devient (x, y, z, 1), ta matrice une matrice 4x4. les matrices 4x3 sont utilisées pour éviter de stocker la dernière colonne, qui vaut toujours la même chose (0, 0, 0, 1). pareil, les vecteurs ne sont jamais stockés sous forme de (x, y, z, 1) mais (x, y, z). si en C++ tu surcharges l'opération * pour prendre en compte Point3 * Matrix43, tu ne fais pas une multiplication bourrin ligne colonne, mais un gros bout de code qui style x' = x*m[0][0] + y*m[1][0] + z*m[2][0] + m[3][0]. le bout en gras est en fait la simplification de w=1 * m[3][0].
maintenant, les matrices de translation / rotation / scaling sont très simples en 3d :
Trans = 1 0 0 0
0 1 0 0
0 0 1 0
transx transy transz 1
Rotation autour de X (x reste constant)
RotX = 1 0 0 0
0 c(a) -s(a) 0
0 s(a) c(a) 0
0 0 0 1
scaling :
Scale = sx 0 0 0
0 sy 0 0
0 0 sz 0
0 0 0 1
tu peux multiplier toutes ces matrices et obtenir une translation suivie d'une rotation suivie d'une translation suivie d'un scaling suivie d'autres transfos plus complexes comme le mirroir par rapport à un plan qqconque, le shearing, etc. lors de toutes transfos linéaires, w vaut toujours 1.
maintenant, comment stocker la projection dans cette matrice, vu que ce n'est pas une transfo linéaire ? (je ne suis même pas sûr que 'linéaire' soit le bon terme, enfin quand je dis linéaire ça veut dire transformation dont il existe une inverse : translation de (a, b, c) -> inverse = translation de (-a, -b, -c) - toute transformation qui donne une matrice inversible est linéaire).
la projection n'est pas réversible, car elle zappe une coordonnée : c'est là qu'on passe de la 3d vers la 2d. dans les coordonnées homogènes, c'est là qu'on divise par w. on a un point 3d (x, y, z), ses coordonnées projetées (x', y'
sur un plan distant de dist de la caméra.
tu te rappelles thalès, tu as x'/x = dist/z donc
x' = x*dist / z
y' = y*dist / z
et vu que pour passer des coords homogènes (4d) aux coords réelles (3d) on divise par w, il faut donc qu'on ait w = z / dist.
soit une matrice de proj qui ressemble à
Proj = 1 0 0 0
0 1 0 0
0 0 1 1/dist
0 0 0 1
tu vérifies que tu obtiens pour cette matrice un résultat style (x, y, z, z/dist). en passant en coords 'réelles' tu as (x/w, y/w, z/w, w/w) soit (x*dist/z, etc.).
voilà ... à noter que j'ai fait la démonstration à l'envers, mais ça devrait te remettre les idées à l'endroit 
//
ensuite pour transformer ton objet 3d de son repère local en coords écran, tu as plusieurs chemins :
* la matrice qui transforme le repère local dans le repère world
* la matrice qui transforme le repère world dans le repère caméra
* la matrice qui transforme le repère caméra dans le repère proj
* la matrice qui transforme le repère proj en coords écran (les coords que tu obtiens vont de -1 à 1, il faut transformer ça en 0, largeur du viewport).
voilà. pfiou. j'espère que c'est clair si le texte passe mal sous le forum, copie colle et mate sous notepad.
).
