opengl - transformaciones - ¿Orden incorrecto de los valores de la matriz en glm?

transformaciones geometricas en opengl

Question

Antes que nada, no soy un experto con OpenGL. Empecé a usar la biblioteca GLM para realizar operaciones matemáticas sobre OpenGL 3 y GLSL. Necesito una proyección ortográfica para dibujar gráficos 2D, así que escribí este código simple:

glm::mat4 projection(1.0);
projection = glm::ortho( 0.0f, 640.0f, 480.0f, 0.0f, 0.0f, 500.0f);

Imprimiendo en pantalla los valores que glm :: ortho ha creado obtengo:

 0.00313   0.00000   0.00000   0.00000
 0.00000  -0.00417   0.00000   0.00000
 0.00000   0.00000  -0.00200   0.00000
-1.00000   1.00000  -1.00000   1.00000

Como sé, este no es el orden correcto para los valores en OpenGL, ya que multiplicar esta matriz por un vector de posición ignorará todos los valores de traducción.

Probé esa matriz con mi shader y algunos primitivos y solo obtuve una pantalla en blanco. Pero si modifico manualmente la matriz de la siguiente manera, funciona bien:

 0.00313   0.00000   0.00000  -1.00000
 0.00000  -0.00417   0.00000   1.00000
 0.00000   0.00000  -0.00200  -1.00000
 0.00000   0.00000   0.00000   1.00000

Además, mirando la función "orto" en el archivo "glm / gtc / matrix_transform.inl":

template <typename valType>
inline detail::tmat4x4<valType> ortho(
    valType const & left,
    valType const & right,
    valType const & bottom,
    valType const & top,
    valType const & zNear,
    valType const & zFar)
{
    detail::tmat4x4<valType> Result(1);
    Result[0][0] = valType(2) / (right - left);
    Result[1][1] = valType(2) / (top - bottom);
    Result[2][2] = - valType(2) / (zFar - zNear);
    Result[3][0] = - (right + left) / (right - left);
    Result[3][1] = - (top + bottom) / (top - bottom);
    Result[3][2] = - (zFar + zNear) / (zFar - zNear);
    return Result;
}

He reemplazado las últimas 3 líneas de inicialización por el siguiente código y también funcionó bien:

    Result[0][3] = - (right + left) / (right - left);
    Result[1][3] = - (top + bottom) / (top - bottom);
    Result[2][3] = - (zFar + zNear) / (zFar - zNear);

Este es un sombreador de vértices mínimo que estoy usando para la prueba (tenga en cuenta que en este momento el uni_MVP es solo la matriz de proyección explicada anteriormente):

uniform mat4 uni_MVP;

in  vec2 in_Position;

void main(void)
{
  gl_Position = uni_MVP * vec4(in_Position.xy,0.0, 1.0);
}

Creo que esto no es un error, porque todas las funciones funcionan de la misma manera. Tal vez es un problema de mi compilador C ++ que invierte el orden de las matrices multidimensionales? ¿Cómo puedo resolver esto sin modificar todo el código fuente de GLM?

Estoy usando la última versión de la biblioteca GLM (0.9.1) con Code :: Blocks y MinGW ejecutándose en Windows Vista.

¡Gracias por tu ayuda!

Answer 1

Primero, se llama transposición, no inversión. La inversión significa algo completamente diferente. En segundo lugar, así es exactamente como debería ser. OpenGL accede a las matrices en orden principal de columnas, es decir, los elementos de la matriz tienen los siguientes índices:

 0  4  8  12
 1  5  9  13
 2  6 10  14
 3  7 11  15

Sin embargo, sus arrays multidimensionales normales de C / C ++ normalmente cuentan así:

 0  1  2  3
 4  5  6  7
 8  9 10 11
12 13 14 15

es decir, los índices de fila y columna están transpuestos. Las versiones anteriores de OpenGL tenían alguna extensión que permite suministrar matrices en forma transpuesta, para evitar que las personas reescriban su código. Se llama GL_ARB_transpose_matrix http://www.opengl.org/registry/specs/ARB/transpose_matrix.txt

Con los sombreadores es incluso más fácil que tener que usar nuevas funciones. glUniformMatrix tiene un parámetro GLboolean transpose , tienes 3 conjeturas de lo que hace.