Je ne comprends pas pourquoi tu as besoin de connaître la colonne qui sera affichée à l'écran pour calculer l'orientation de ton vecteur de direction
moi non plus
beuurkk
t_floatpoint return_vector(int x, double a)
{
t_floatpoint e1;
t_floatpoint e2;
e1.x = 0.5;
e1.y = (1.0 * ((XSIZE / 2) - x)) / XSIZE;
e2.x = (e1.x * cos(RADIAN(a))) - (e1.y * sin(RADIAN(a)));
e2.y = (e1.x * sin(RADIAN(a))) + (e1.y * cos(RADIAN(a)));
return (e2);
}
recapitulation
- t'as ton vecteur de vision dans ta scene 2D, donc juste l'angle de rotation autour de l'axe qui passe verticalement dans le plan de ta scene, d'apres ton code c'est w->angle
- cet angle/vecteur de vision correspond a la direction du rayon qui passe par le milieu de l'ecran, en x = XSIZE / 2;
- l'angle entre le coin gauche et le coin droit de l'ecran est donne par le fov.
- tu veux balayer la scene pour chaque colonne de pixels de gauche a droite, donc en commencant a angle - fov / 2 et en t'arretant a angle + fov / 2
- pour chaque colonne, tu veux lancer un rayon dans ta scene a l'angle correspondant a la colonne.
pour l'instant ca donne a peu pres ce que t'as deja:
float cur_angle;
float inc_angle;
int i;
cur_angle = w->angle - fov / 2.0f;
inc_angle = fov / (float)XSIZE;
for (i = 0; i < XSIZE; i++)
{
raycast(w, cur_angle, i);
cur_angle += inc_angle;
}
rien de complique jusque la nan?
bon, donc t'as l'angle du rayon que tu veux lancer dans ta scene...
la tu veux afficher une colonne pour chaque rayon, colonne composee d'un plafond (eventuellement), d'un mur, et d'un sol (eventuellement aussi).
vu que c'est tout en 2D et que la seule information que t'as c'est la distance de l'oeil au mur que ton rayon a (eventuellement) intersecte, et que plus un mur est loin, plus il est petit (en fonction de 1 / la distance), plus la distance est grande, plus ton mur apparaitra petit, ok jusque la...
donc quand t'as la distance d'intersection (tu te demmerde deja pour l'avoir et visiblement ca ca marche), tu scale la colonne correspondant au mur avec cette valeur. sauf que juste faire ca, ca te donne l'effet fishbowl en question, vu que plus t'envoie un rayon sur le cote, cad decentre par rapport a ton vecteur de vision (celui qui passe par le centre de l'ecran), plus l'intersection est loin. si t'as un mur infiniment long 5 cm en face de ton ecran, et que t'as un fov de 180 degres, aux extremites de ton ecran, le mur aura une distance infinie...
bon, la distance que tu veux est celle qu'aurait le mur si il etait pile en face de ta camera.
comme l'a dit je sais plus qui (flemme de remonter), tu dois projeter le vecteur qui va de ton oeil a l'intersection du mur sur le vecteur de vision (celui qui passe par le centre de ta camera), c'est a dire faire la racine carree du produit scalaire entre les deux vecteurs, c'est a dire multiplier par le cos de l'angle entre le vecteur de vision et le vecteur courant (de la colonne):
void raycast(t_mlx *w, float angle, float x)
{
VECTOR2D vec;
float dist;
vec.x = cosf(angle); // ca ca depend ce comment t'as foutu ton repere, et de comment est mesure l'angle
vec.y = sinf(angle);
dist = intersect(w, &vec); // retourne la distance avec le mur le plus proche
dist *= cosf(w->angle - angle);
draw_column(w, dist, x);
}
apres, le draw_column, bah si t'as la hauteur de tes murs dans w->height (tu peux faire des murs plus ou moins hauts avec ca, mais tu verra pas ceux de derriere si ils sont plus hauts), il suffit de faire:
void draw_column(t_mlx *w, float dist, float x)
{
draw_hline(w, x, w->height / dist);
}
