Cómo lograr glOrthof en OpenGL ES 2.0

Question

Estoy tratando de convertir mi aplicación OpenGL ES 1 en una aplicación OpenGL ES 2 para poder usar Shaders. Ahora uso la función glOrthof para tener una "ventana gráfica de tamaño real", así puedo colocar los vértices en el píxel "real" en la vista OpenGL.

glOrthof(0, _frame.size.width, _frame.size.height, 0, -1, 1); 

Estoy teniendo problemas para encontrar la manera de lograr esto en OpenGL ES 2, ¿hay alguien que me puede mostrar cómo hacer esto?

Si no es así, ¿alguien tiene un enlace a un buen tutorial/explicación de OpenGL ES 1 to OpenGL ES 2?

Answer 1

El método glOrtho no hace nada más que crear una nueva matriz y multiplicar la matriz de proyección actual por esta matriz. Con OpenGL ES 2.0 usted debe administrar las matrices usted mismo. Para replicar el comportamiento de glOrtho necesitas un uniforme para la matriz de proyección en tu sombreado de vértices, con el que multiplicas tus vértices. Por lo general, también tiene un modelo y una matriz de vista (o una matriz modelview combinado, como en OpenGL ES 1), que a transformar sus vértices con antes de la proyección transformada:

uniform mat4 projection; 
uniform mat4 modelview; 

attribute vec4 vertex; 

void main() 
{ 
    gl_Position = projection * (modelview * vertex); 
} 

la matriz de proyección específico que glOrtho construcciones se pueden encontrado here.

Answer 2

Como Christian describe, todas las matemáticas matriciales para procesar vértices dependen de usted, por lo que debe replicar la matriz que crea glOrthof(). En mi respuesta here, I, siempre el siguiente método Objective-C para generar una matriz de proyección ortográfica tales:

- (void)loadOrthoMatrix:(GLfloat *)matrix left:(GLfloat)left right:(GLfloat)right bottom:(GLfloat)bottom top:(GLfloat)top near:(GLfloat)near far:(GLfloat)far; 
{ 
    GLfloat r_l = right - left; 
    GLfloat t_b = top - bottom; 
    GLfloat f_n = far - near; 
    GLfloat tx = - (right + left)/(right - left); 
    GLfloat ty = - (top + bottom)/(top - bottom); 
    GLfloat tz = - (far + near)/(far - near); 

    matrix[0] = 2.0f/r_l; 
    matrix[1] = 0.0f; 
    matrix[2] = 0.0f; 
    matrix[3] = tx; 

    matrix[4] = 0.0f; 
    matrix[5] = 2.0f/t_b; 
    matrix[6] = 0.0f; 
    matrix[7] = ty; 

    matrix[8] = 0.0f; 
    matrix[9] = 0.0f; 
    matrix[10] = 2.0f/f_n; 
    matrix[11] = tz; 

    matrix[12] = 0.0f; 
    matrix[13] = 0.0f; 
    matrix[14] = 0.0f; 
    matrix[15] = 1.0f; 
} 

La matriz utilizada aquí se define como

GLfloat orthographicMatrix[16]; 

entonces aplico la matriz dentro de mi vértice shader usar algo como lo siguiente:

gl_Position = modelViewProjMatrix * position * orthographicMatrix; 

Mi pedido multiplicación difiere de Christian, por lo que puede estar haciendo algo un poco hacia atrás aquí, pero esto es lo que he usado para manejar esto dentro de una aplicación OpenGL ES 2.0 (cuyo código fuente se puede encontrar en here).