Distorsione prospettiva Opengl

Question

Sto avendo questo strano problema e spero che qualcuno possa chiarirlo per me così posso capire cosa c'è che non va e agire di conseguenza. In OpenGL (funzione fissa) sto visualizzando un tubo con facce interne in una proiezione ortogonale.

L'immagine seguente mostra il risultato. Consiste di 4 anelli di vertici che formano triangoli usando il modello di indice mostrato a sinistra. Ho numerato i vertici sul tubo per la vostra convenienza. A destra è la trama in uso:

Come si può vedere la texture viene pesantemente distorta. Come inizialmente ho creato il tubo con solo 2 anelli di vertici, ho pensato che alzare la quantità di anelli avrebbe risolto la distorsione ma non la gioia. Anche glHint non sembra influenzare questo problema specifico.

Le coordinate della trama sembrano essere buone. Inoltre, sembra che il modello di correttore sia visualizzato correttamente, ma suppongo che la distorsione non sia visibile in quel modello molto specifico.

Si prega di ignorare le linee incrociate in quanto uno di questi è un margine inesistente; Ho reso il wireframe tramite GL_LINE_LOOP.

Answer 1

Questo particolare effetto è causato dal modo in cui le coordinate della trama sono interpolate in un triangolo. Quello che succede è che una direzione diventa il componente principale, mentre l'altra è distorta. Il tuo campione sembra essere molto incline a questo. Questo è anche un problema con proiezioni prospettiche e trame su pavimenti o pareti. Quello che ti serve è il cosiddetto "prospettiva corretta texturing" PCT. C'è uno glHint per questo ma immagino, l'hai già provato.

Sinceramente, l'unico modo per evitarlo è suddividere e applicando anche la correzione prospettica. Ma per fortuna questo è abbastanza facile per geoemtry basato quadrilatero (come il tuo). Quando si suddividono i bordi, interpolare le coordinate della trama nei centri di suddivisione lungo tutti e 4 i bordi e utilizzare il valore medio di un 4 di essi. Interpolare la coordinata della trama solo lungo un bordo è esattamente ciò che si desidera evitare.

Se si desidera mantenere intatti i dati geometrici, è possibile implementare PCT nello shader di frammenti.

Answer 2

Prova qualche suddivisione:

template< typename Vec > 
void glVec2d(const Vec& vec) 
{ 
    glVertex2f(static_cast<float>(vec.x()) , static_cast<float>(vec.y())); 
} 

template< typename Vec > 
void glTex2d(const Vec& vec) 
{ 
    glTexCoord2f(static_cast<float>(vec.x()) , static_cast<float>(vec.y())); 
} 

template< typename Vec > 
void glQuad 
    (
    const Vec& A, 
    const Vec& B, 
    const Vec& C, 
    const Vec& D, 
    unsigned int divs = 2, 
    const Vec& At = Vec(0,0), 
    const Vec& Bt = Vec(1,0), 
    const Vec& Ct = Vec(1,1), 
    const Vec& Dt = Vec(0,1) 
    ) 
{ 
    // base case 
    if(divs == 0) 
    { 
     glTex2d(At); 
     glVec2d(A); 

     glTex2d(Bt); 
     glVec2d(B); 

     glTex2d(Ct); 
     glVec2d(C); 

     glTex2d(Dt); 
     glVec2d(D); 

     return; 
    } 

    Vec AB = (A+B) * 0.5; 
    Vec BC = (B+C) * 0.5; 
    Vec CD = (C+D) * 0.5; 
    Vec AD = (A+D) * 0.5; 
    Vec ABCD = (AB+CD) * 0.5; 

    Vec ABt = (At+Bt) * 0.5; 
    Vec BCt = (Bt+Ct) * 0.5; 
    Vec CDt = (Ct+Dt) * 0.5; 
    Vec ADt = (At+Dt) * 0.5; 
    Vec ABCDt = (ABt+CDt) * 0.5; 

    // subdivided point layout 
    // D CD C 
    // 
    // AD ABCD BC 
    // 
    // A AB B 

    // subdivide 
    glQuad2d(A, AB, ABCD, AD, divs - 1, At, ABt, ABCDt, ADt); 
    glQuad2d(AB, B, BC, ABCD, divs - 1, ABt, Bt, BCt, ABCDt); 
    glQuad2d(ABCD, BC, C, CD, divs - 1, ABCDt, BCt, Ct, CDt); 
    glQuad2d(AD, ABCD, CD, D, divs - 1, ADt, ABCDt, CDt, Dt); 
} 

Io di solito uso Eigen::Vector2f per Vec.

Answer 3

Perché stai utilizzando una proiezione ortografica per questo? Se stavi usando una proiezione prospettica, OpenGL correggerebbe la mappatura della trama per te.