Distorsión de perspectiva OpenGL

Question

Estoy teniendo este problema extraño y espero que alguien pueda aclararme esto para que pueda entender lo que está mal y actuar en consecuencia. En OpenGL (función fija) estoy renderizando un tubo con caras internas en una proyección ortográfica.

La imagen siguiente muestra el resultado. Consiste en 4 anillos de vértices que forman triángulos usando el patrón de índice que se muestra a la izquierda. Numere los vértices en el tubo para su conveniencia. A la derecha está la textura que se utiliza:

Como se puede ver la textura está siendo fuertemente distorsionado. Como inicialmente creé el tubo con solo 2 anillos de vértices, pensé que aumentar la cantidad de anillos arreglaría la distorsión pero no la alegría. También glHint no parece afectar este problema específico.

Las coordenadas de la textura parecen estar bien. Además, el patrón del inspector parece reproducirse correctamente, pero supongo que la distorsión simplemente no es visible en ese patrón muy específico.

Por favor, ignore las líneas cruzadas ya que una de esas es una ventaja inexistente; Representé el wireframe a través de GL_LINE_LOOP.

Answer 1

Este efecto particular es causado por la forma en que las coordenadas de textura se interpolan en un triángulo. Lo que sucede es que una dirección se convierte en el componente principal, mientras que la otra es sesgada. Su muestra es muy propensa a esto. Esto también pasa a ser un problema con proyecciones de perspectiva y texturas en pisos o paredes. Lo que necesita es lo que se llama "PCT de texturas correctas en perspectiva". Hay un glHint para esto, pero supongo que ya lo has intentado.

Francamente, la única forma de evitar esto es subdividiendo y aplicando también la corrección de perspectiva. Pero, afortunadamente, esto es bastante fácil para la geoemtría basada en cuadriláteros (como la tuya). Al subdividir los bordes, interpola las coordenadas de textura en los centros de subdivisión a lo largo de los 4 bordes y utiliza el valor medio de 4 de ellos. La interpolación de la coordenada de textura solo a lo largo de un borde es exactamente lo que desea evitar.

Si desea mantener intactos sus datos de geometría, puede implementar PCT en el sombreador de fragmentos.

Answer 2

Pruebe algunas subdivisiones:

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); 
} 

normalmente utilizo para Eigen::Vector2fVec.

Answer 3

¿Por qué usa una proyección ortográfica para esto? Si estuviera utilizando una proyección en perspectiva, OpenGL corregirá la asignación de texturas por usted.