mapeo perfecto de texturas de píxeles con OpenGL

Question

moderno

Después de decidir probar la programación en OpenGL moderno, he dejado atrás el flujo de funciones fijo y no estoy del todo seguro sobre cómo obtener la misma funcionalidad que tenía antes.

Estoy tratando de texturar cuadrículas de mapa con un tamaño perfecto de píxel, que coincida con el tamaño de la textura. Por ejemplo, una textura de 128x128 se asigna a un cuadrante de 128x128 de tamaño.

Este es mi sombreador de vértices.

 

    #version 110 
    uniform float xpos; 
    uniform float ypos; 
    uniform float tw; // texture width in pixels 
    uniform float th; // texture height in pixels 
    attribute vec4 position; 
    varying vec2 texcoord;   
void main() 
    { 
    mat4 projectionMatrix = mat4(2.0/600.0, 0.0, 0.0, -1.0, 
            0.0, 2.0/800.0, 0.0, -1.0, 
            0.0, 0.0, -1.0, 0.0, 
            0.0, 0.0, 0.0, 1.0); 

    gl_Position = position * projectionMatrix; 
    texcoord = (gl_Position.xy); 
    } 
 

Este es mi fragmento shader:

 

    #version 110 
    uniform float fade_factor;  
    uniform sampler2D textures[1]; 
    varying vec2 texcoord; 

    void main() 
    { 
     gl_FragColor = texture2D(textures[0], texcoord); 
    } 
 

Mi datos de vértice es como tal, donde w y h son la anchura y la altura de la textura.

 

    [ 
    0, 0, 
    w, 0, 
    w, h, 
    0, h 
    ] 
 

me carga una textura de 128x128 y con estos shaders que veo la imagen repetida 4 veces: http://i.stack.imgur.com/UY7Ts.jpg

puede ofrecer cualquier consejo sobre la forma correcta de ser capaz de traducir y la escala dada la XX TW, XPos , xpos uniformes?

Answer 1

Hay un problema con esto:

mat4 projectionMatrix = mat4(2.0/600.0, 0.0, 0.0, -1.0, 
            0.0, 2.0/800.0, 0.0, -1.0, 
            0.0, 0.0, -1.0, 0.0, 
            0.0, 0.0, 0.0, 1.0); 

gl_Position = position * projectionMatrix; 

matices de transformación son asociativos a la derecha, es decir, se debe multiplicar el orden opuesto. Además, normalmente no se especifica una matriz de proyección en el sombreador, se pasa como un uniforme. OpenGL le proporciona uniformes listos para usar para proyecciones y modelos. En el núcleo OpenGL-3 puede reutilizar los nombres de los uniformes para mantenerse compatible.

// predefined by OpenGL version < 3 core: 
#if __VERSION__ < 400 
uniform mat4 gl_ProjectionMatrix; 
uniform mat4 gl_ModelviewMatrx; 
uniform mat4 gl_ModelviewProjectionMatrix; // premultiplied gl_ProjectionMatrix * gl_ModelviewMatrix 
uniform mat4 gl_ModelviewInverseTranspose; // needed for transformin normals 

attribute vec4 gl_Vertex; 

varying vec4 gl_TexCoord[]; 
#endif 

void main() 
{ 
    gl_Position = gl_ModelviewProjectionMatrix * gl_Vertex; 
} 

A continuación se debe entender que las coordenadas de textura no abordan textura píxeles (texels), pero que la textura debe ser entendida como una función de interpolación con los puntos de muestreo dados; las coordenadas de textura 0 o 1 no golpean los centros del téxel, sino que se encuentran exactamente entre el envolvente, por lo que se borran. Siempre que su quad en el tamaño de la pantalla coincida exactamente con las dimensiones de la textura, está bien. Pero tan pronto como quieras mostrar solo una subimagen, las cosas se ponen interesantes (lo dejo como un ejercicio para que el lector descubra el mapeo exacto; pista: Tendrás los términos 0.5/dimension y (dimension - 1)/dimension en la solución)