c++ - figuras - gluPerspective fue eliminado en OpenGL 3.1, ¿reemplazos?

gluperspective ejemplo

Question

Estoy tratando de leer algunos tutoriales de OpenGL en la red. el problema es que encontré algunos viejos que usan gluPerspective() . gluPerspective fue desaprobado en OpenGL 3.0 y eliminado en 3.1.

¿Qué función puedo usar en su lugar?

Estoy usando C ++ con el último FreeGlut instalado.

Answer 1

Copiado de uno de mis proyectos anteriores:

// The following code is a fancy bit of math that is eqivilant to calling:
// gluPerspective( fieldOfView/2.0f, width/height , 0.1f, 255.0f )
// We do it this way simply to avoid requiring glu.h
GLfloat zNear = 0.1f;
GLfloat zFar = 255.0f;
GLfloat aspect = float(width)/float(height);
GLfloat fH = tan( float(fieldOfView / 360.0f * 3.14159f) ) * zNear;
GLfloat fW = fH * aspect;
glFrustum( -fW, fW, -fH, fH, zNear, zFar );

Answer 2

Debe calcular la matriz manualmente y luego pasarla a OpenGL.

Calculando la matriz

Este fragmento de código se basa en la documentación de gluPerspective .

 void BuildPerspProjMat(float *m, float fov, float aspect,
 float znear, float zfar)
 {
  float f = 1/tan(fov * PI_OVER_360);

  m[0]  = f/aspect;
  m[1]  = 0;
  m[2]  = 0;
  m[3]  = 0;

  m[4]  = 0;
  m[5]  = f;
  m[6]  = 0;
  m[7]  = 0;

  m[8]  = 0;
  m[9]  = 0;
  m[10] = (zfar + znear) / (znear - zfar);
  m[11] = -1;

  m[12] = 0;
  m[13] = 0;
  m[14] = 2*zfar*znear / (znear - zfar);
  m[15] = 0;
 }

Hay una biblioteca de C ++ llamada OpenGL Mathematics que puede ser útil.

Cargando la Matriz en OpenGL 3.1

Todavía soy nuevo en la API de OpenGL 3.1, pero necesita actualizar una matriz en la GPU y luego usarla en su sombreador de vértices para obtener la perspectiva adecuada. El siguiente código simplemente carga la matriz usando glUniform4fv en la tarjeta de video.

{
  glUseProgram(shaderId);
  glUniformMatrix4fv(glGetUniformLocation(shaderId, "u_proj_matrix"),
                     1, GL_FALSE, theProjectionMatrix);
  RenderObject();
  glUseProgram(0);
}

Un sombreador de vértices simple de un blog aleatorio (encontrado a través del desbordamiento de la pila).

attribute vec4      a_position;
attribute vec4      a_color;

varying vec4        v_color;

uniform mat4 u_proj_matrix;
uniform mat4 u_model_matrix;

void main() {
  mat4 mvp_matrix = u_proj_matrix * u_model_matrix;
  v_color = a_color;
  gl_Position = mvp_matrix * a_position;
}

Answer 3

Esta es una versión modificada de la función de Dan, con cálculos simplificados de Comportamiento no especificado .

void buildPerspProjMat(GLfloat *m, GLfloat fov, GLfloat aspect,
GLfloat znear, GLfloat zfar){

  GLfloat h = tan(fov);
  GLfloat w = h / aspect;
  GLfloat depth = znear - zfar;
  GLfloat q = (zfar + znear) / depth;
  GLfloat qn = 2 * zfar * znear / depth;

  m[0]  = w;  m[1]  = 0;  m[2]  = 0;  m[3]  = 0;

  m[4]  = 0;  m[5]  = h;  m[6]  = 0;  m[7]  = 0;

  m[8]  = 0;  m[9]  = 0;  m[10] = q;  m[11] = -1;

  m[12] = 0;  m[13] = 0;  m[14] = qn;  m[15] = 0;
}

Answer 4

La fórmula para varias matrices de perspectiva está documentada en la documentación de Direct3D .

Aquí está la formulación para D3DXMatrixPerspectiveFovRH , la matriz de proyección de perspectiva para diestros:

yScale = cot(fovY/2)
xScale = yScale / aspect ratio

xScale     0          0              0
0        yScale       0              0
0        0        zf/(zn-zf)        -1
0        0        zn*zf/(zn-zf)      0

Answer 5

Utilice GLM .

glm::mat4 projection = glm::perspective(
  // FOV & aspect
  60.0f, 16.0f / 10.0f, 
  // Near and far planes
  0.001f, 1000f);

// If you''re using the now deprecated matrix stacks
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(glm::value_ptr(projection));

// if you''re using the new shader based pipelines
GLint projectionUniformLocation = ...;
glUniformMatrix4fv(projectionUniformLocation, 1, GL_FALSE, 
  glm::value_ptr(projection));

Tenga en cuenta que si tiene GLM_FORCE_RADIANS definido, debe usar radianes en la función de perspectiva, no en grados ...

glm::mat4 projection = glm::perspective(
  // FOV & aspect
  PI / 3.0f, 16.0f / 10.0f, 
  // Near and far planes
  0.001f, 1000f);