ta premiere image c'est un mapping spherique.
la 2eme un mapping cylindrique.
mettons que tu considere que la premiere, parceque c'est la seule qui te permet de regarder partout, comme une skybox:
si j'ai bien suivi, ton pbl c'est de convertir les coordonnees de pixels de ton affichage en coordonnees de texels pour faire une lookup dans ta texture?
tu peux faire en deux etapes:
A- coord pixel ecran -> coords 3D d'un vecteur (comme si tu codais un raytracer/raycaster)
B- coord vecteur 3D -> coord texel 2D
pour A:classique, t'as les 3 vecteurs 3d de ta camera: side, up, et forward, et tu fais un truc du genre:
int2 pixelCoords; // coordonnees dans le range [0,screenSize[
float2 pixelUV_01 = (pixelCoords + 0.5) / screenSize;
float2 pixelUV_m1p1 = pixelUV_01 * 2 - 1;
float3 view = forward * invZoomFactor + side * pixelUV_m1p1.x + up * pixelUV_m1p1.y;
si tu as une matrice 3x3 pour ta camera tu peux directement faire:
int2 pixelCoords; // coordonnees dans le range [0,screenSize[
float2 pixelUV_01 = (pixelCoords + 0.5) / screenSize;
float3 pixelUV_m1p1 = float3(pixelUV_01 * 2 - 1, invZoomFactor);
float3 view = viewMatrix.transform(pixelUV_m1p1);
pour B:les coordonnees 'XY' du vecteur view vont mapper sur la coordonnee 'U' de ta texture.
la coordonnee 'Y' du vecteur va mapper sur la coordonnee 'V' de ta texture.
suivant comment est fait ta projection, 'Y->V' peut etre un mapping direct, mais c'est plus probable que ce soit spherique aussi.
bon, donc, en gros:
texU = atan2f(view.x, view.z) / (2*pi); // extrait l'angle de vue horizontal, et le remappe dans [0,1]
texV = acosf(view.y) / pi; // extrait l'angle de vue vertical, et le remappe dans [0,1]
tes tecoords {texU, texV} sont entre 0 et 1 et pretes a faire une lookup.
apres, si tu fais ca par pixel, et que tu veux pas utiliser OpenGL pour pouvoir le "porter sur des plateformes retros", le cout par pixel risque de piquer un peu avec toute cette trig
donc je dirais que c'est ptet pas le mapping le plus judicieux
tu peux eviter l'acosf en changeant la projection pour que Y->V soit un mapping lineaire, et t'aurais:
texU = atan2f(view.x, view.z) / (2*pi); // extrait l'angle de vue horizontal, et le remappe dans [0,1]
texV = view.y * 0.5 + 0.5;
mais ca reste quand meme hardcore.
ya des chances qu'une cubemap soit qd meme plus efficace, mais bon je connais pas ton HW...
pour la lookup de la cubemap, l'idee est toute simple, t'as ton view vector, et tu dois trouver l'axe le plus grand:
int largestAxis = 0;
if (abs(view.y) > abs(view.x))
largestAxis = (abs(view.y) > abs(view.z)) ? 1 : 2;
else if (abs(view.z) > abs(view.x))
largestAxis = 3;
int cubeFaceId = 2*largestAxis + (view.axis(largestAxis) >= 0);cubeFaceId aura les valeurs suivantes:
0 = face X negative
1 = face X positive
2 = face Y negative
3 = face Y positive
4 = face Z negative
5 = face Z positive
ensuite, tu lookup la face en question avec les UV suivants:
float2 uv = float2(view.axis((largestAxis + 1)%3), view.axis((largestAxis + 2)%3)) / view.axis(largestAxis);
ca va prendre les deux axes autres que l'axe principal de la vue, et ca va les renormaliser en les projetant au bout de la pyramide qui va du centre de la cubemap a la face.
un side-effect de cette reprojection est que ton vecteur 'view' n'a pas besoin d'etre normalise, donc c'est plutot cool
)
)
