Realizzo un software di rasterizzazione e mi sono imbattuto in un piccolo inconveniente: non riesco a ottenere il corretto funzionamento della mappatura della trama in prospettiva.Mappatura della trama corretta in prospettiva; Il calcolo della distanza z potrebbe essere errato
Il mio algoritmo è prima di ordinare le coordinate da stampare per . Questo restituisce un punto più alto, più basso e più centrale. Ho poi passeggiata attraverso le linee di scansione utilizzando il delta del:
// ordering by y is put here
order[0] = &a_Triangle.p[v_order[0]];
order[1] = &a_Triangle.p[v_order[1]];
order[2] = &a_Triangle.p[v_order[2]];
float height1, height2, height3;
height1 = (float)((int)(order[2]->y + 1) - (int)(order[0]->y));
height2 = (float)((int)(order[1]->y + 1) - (int)(order[0]->y));
height3 = (float)((int)(order[2]->y + 1) - (int)(order[1]->y));
// x
float x_start, x_end;
float x[3];
float x_delta[3];
x_delta[0] = (order[2]->x - order[0]->x)/height1;
x_delta[1] = (order[1]->x - order[0]->x)/height2;
x_delta[2] = (order[2]->x - order[1]->x)/height3;
x[0] = order[0]->x;
x[1] = order[0]->x;
x[2] = order[1]->x;
E poi rendiamo order[0]->y-order[2]->y, aumentando la x_start e x_end di un delta. Quando si esegue il rendering della parte superiore, i delta sono x_delta[0] e x_delta[1]. Quando si esegue il rendering della parte inferiore, i delta sono x_delta[0] e x_delta[2]. Quindi interpoliamo linearmente tra x_start e x_end sulla nostra scanline. Le coordinate UV sono interpolate nello stesso modo, ordinate da y, a partire dall'inizio e alla fine, a cui vengono applicate le delta ogni passo.
Funziona bene tranne quando cerco di eseguire la mappatura UV in prospettiva corretta. L'algoritmo di base è quello di prendere UV/z e 1/z per ogni vertice e interpolare tra di loro. Per ogni pixel, la coordinata UV diventa UV_current * z_current. Tuttavia, questo è il risultato:
La parte inversed ti dice dove il delta del sono capovolte. Come puoi vedere, entrambi i triangoli sembrano andare verso diversi punti dell'orizzonte.
Ecco quello che uso per calcolare la Z in un punto dello spazio:
float GetZToPoint(Vec3 a_Point)
{
Vec3 projected = m_Rotation * (a_Point - m_Position);
// #define FOV_ANGLE 60.f
// static const float FOCAL_LENGTH = 1/tanf(_RadToDeg(FOV_ANGLE)/2);
// static const float DEPTH = HALFHEIGHT * FOCAL_LENGTH;
float zcamera = DEPTH/projected.z;
return zcamera;
}
ho ragione, si tratta di un problema di buffer z?
altro suggerimento per il debugging, calcolare ogni punto trama utilizzando il vecchio, non incrementale U e V coordinate per ciascun pixel e confronta i valori calcolati dal incrementali dell'algoritmo (consentendo un certo slop causa di errore di arrotondamento). –
Wow ... questa è una risposta e mezza! : D – Goz
goz: ora spero solo che sia utile poiché probabilmente ha già la maggior parte di questo codice in atto a giudicare dalla foto. Sto pensando che probabilmente ha calcolato male uno dei valori di interpolazione. Ma se tutto va bene se mette il suo algoritmo vicino al mio, può scoprire quale è; ^) – Toad