Solución:
Eche un vistazo a esta imagen: Proyecciones gráficas
los glOrtho El comando produce una proyección “oblicua” que se ve en la fila inferior. No importa qué tan lejos estén los vértices en la dirección z, no retrocederán en la distancia.
Utilizo glOrtho cada vez que necesito hacer gráficos 2D en OpenGL (como barras de salud, menús, etc.) usando el siguiente código cada vez que se cambia el tamaño de la ventana:
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0f, windowWidth, windowHeight, 0.0f, 0.0f, 1.0f);
Esto reasignará las coordenadas OpenGL en los valores de píxeles equivalentes (X va de 0 a windowWidth e Y va de 0 a windowHeight). Tenga en cuenta que cambié los valores de Y porque las coordenadas de OpenGL comienzan en la esquina inferior izquierda de la ventana. Entonces, al voltear, obtengo un (0,0) más convencional que comienza en la esquina superior izquierda de la ventana.
Tenga en cuenta que los valores Z se recortan de 0 a 1. Así que tenga cuidado cuando especifique un valor Z para la posición de su vértice, se recortará si cae fuera de ese rango. De lo contrario, si está dentro de ese rango, parecerá que no tiene ningún efecto en la posición, excepto en las pruebas Z.
Ejemplo mínimo ejecutable
glOrtho: Los juegos en 2D, los objetos cercanos y lejanos parecen del mismo tamaño:
glFrustrum: más real como 3D, los objetos idénticos más alejados parecen más pequeños:
C Principal
#include <stdlib.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
static int ortho = 0;
static void display(void) {
glClear(GL_COLOR_BUFFER_BIT);
glLoadIdentity();
if (ortho) {
} else {
/* This only rotates and translates the world around to look like the camera moved. */
gluLookAt(0.0, 0.0, -3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
}
glColor3f(1.0f, 1.0f, 1.0f);
glutWireCube(2);
glFlush();
}
static void reshape(int w, int h) {
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (ortho) {
glOrtho(-2.0, 2.0, -2.0, 2.0, -1.5, 1.5);
} else {
glFrustum(-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
}
glMatrixMode(GL_MODELVIEW);
}
int main(int argc, char** argv) {
glutInit(&argc, argv);
if (argc > 1) {
ortho = 1;
}
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(500, 500);
glutInitWindowPosition(100, 100);
glutCreateWindow(argv[0]);
glClearColor(0.0, 0.0, 0.0, 0.0);
glShadeModel(GL_FLAT);
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return EXIT_SUCCESS;
}
GitHub en sentido ascendente.
Compilar:
gcc -ggdb3 -O0 -o main -std=c99 -Wall -Wextra -pedantic main.c -lGL -lGLU -lglut
Corre con glOrtho:
./main 1
Corre con glFrustrum:
./main
Probado en Ubuntu 18.10.
Esquema
Ortho: la cámara es un plano, el volumen visible un rectángulo:
Frustrum: la cámara es un punto, el volumen visible es un trozo de una pirámide:
Fuente de imagen.
Parámetros
Siempre estamos mirando de + z a -z con + y hacia arriba:
glOrtho(left, right, bottom, top, near, far)
-
left: mínimoxvemos -
right: máximoxvemos -
bottom: mínimoyvemos -
top: máximoyvemos -
-near: mínimozvemos. sí, este es-1vecesnear. Entonces una entrada negativa significa positivaz. -
-far: máximozvemos. También negativo.
Esquema:
Fuente de imagen.
Cómo funciona bajo el capó
Al final, OpenGL siempre “usa”:
glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
Si no usamos ninguno glOrtho ni glFrustrum, eso es lo que obtenemos.
glOrtho y glFrustrum son solo transformaciones lineales (también conocido como multiplicación de matrices) tales que:
-
glOrtho: toma un rectángulo 3D dado en el cubo predeterminado -
glFrustrum: toma una sección de pirámide determinada en el cubo predeterminado
Esta transformación luego se aplica a todos los vértices. Esto es lo que quiero decir en 2D:
Fuente de imagen.
El paso final después de la transformación es simple:
- eliminar cualquier punto fuera del cubo (selección): solo asegúrese de que
x,yyzestan en[-1, +1] - ignora el
zcomponente y tomar soloxyy, que ahora se puede poner en una pantalla 2D
Con glOrtho, z se ignora, por lo que es mejor usar siempre 0.
Una razón por la que quizás quieras usar z != 0 es hacer que los sprites oculten el fondo con el búfer de profundidad.
Deprecación
glOrtho está obsoleto a partir de OpenGL 4.5: el perfil de compatibilidad 12.1. “TRANSFORMACIONES DE VÉRTEX DE FUNCIÓN FIJA” está en rojo.
Así que no lo use para la producción. En cualquier caso, comprenderlo es una buena forma de obtener información sobre OpenGL.
Los programas modernos de OpenGL 4 calculan la matriz de transformación (que es pequeña) en la CPU, y luego dan la matriz y todos los puntos para ser transformados a OpenGL, que puede hacer miles de multiplicaciones de matrices para diferentes puntos muy rápido en paralelo.
Los sombreadores de vértices escritos manualmente luego hacen la multiplicación explícitamente, generalmente con los tipos de datos vectoriales convenientes del lenguaje de sombreado OpenGL.
Dado que escribe el sombreador explícitamente, esto le permite ajustar el algoritmo a sus necesidades. Tal flexibilidad es una característica importante de las GPU más modernas, que a diferencia de las antiguas que tenían un algoritmo fijo con algunos parámetros de entrada, ahora pueden realizar cálculos arbitrarios. Véase también: https://stackoverflow.com/a/36211337/895245
Con un explícito GLfloat transform[] se vería así:
glfw_transform.c
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#define GLEW_STATIC
#include <GL/glew.h>
#include <GLFW/glfw3.h>
static const GLuint WIDTH = 800;
static const GLuint HEIGHT = 600;
/* ourColor is passed on to the fragment shader. */
static const GLchar* vertex_shader_source =
"#version 330 coren"
"layout (location = 0) in vec3 position;n"
"layout (location = 1) in vec3 color;n"
"out vec3 ourColor;n"
"uniform mat4 transform;n"
"void main() {n"
" gl_Position = transform * vec4(position, 1.0f);n"
" ourColor = color;n"
"}n";
static const GLchar* fragment_shader_source =
"#version 330 coren"
"in vec3 ourColor;n"
"out vec4 color;n"
"void main() {n"
" color = vec4(ourColor, 1.0f);n"
"}n";
static GLfloat vertices[] = {
/* Positions Colors */
0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 1.0f
};
/* Build and compile shader program, return its ID. */
GLuint common_get_shader_program(
const char *vertex_shader_source,
const char *fragment_shader_source
) {
GLchar *log = NULL;
GLint log_length, success;
GLuint fragment_shader, program, vertex_shader;
/* Vertex shader */
vertex_shader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertex_shader, 1, &vertex_shader_source, NULL);
glCompileShader(vertex_shader);
glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &success);
glGetShaderiv(vertex_shader, GL_INFO_LOG_LENGTH, &log_length);
log = malloc(log_length);
if (log_length > 0) {
glGetShaderInfoLog(vertex_shader, log_length, NULL, log);
printf("vertex shader log:nn%sn", log);
}
if (!success) {
printf("vertex shader compile errorn");
exit(EXIT_FAILURE);
}
/* Fragment shader */
fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragment_shader, 1, &fragment_shader_source, NULL);
glCompileShader(fragment_shader);
glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &success);
glGetShaderiv(fragment_shader, GL_INFO_LOG_LENGTH, &log_length);
if (log_length > 0) {
log = realloc(log, log_length);
glGetShaderInfoLog(fragment_shader, log_length, NULL, log);
printf("fragment shader log:nn%sn", log);
}
if (!success) {
printf("fragment shader compile errorn");
exit(EXIT_FAILURE);
}
/* Link shaders */
program = glCreateProgram();
glAttachShader(program, vertex_shader);
glAttachShader(program, fragment_shader);
glLinkProgram(program);
glGetProgramiv(program, GL_LINK_STATUS, &success);
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &log_length);
if (log_length > 0) {
log = realloc(log, log_length);
glGetProgramInfoLog(program, log_length, NULL, log);
printf("shader link log:nn%sn", log);
}
if (!success) {
printf("shader link error");
exit(EXIT_FAILURE);
}
/* Cleanup. */
free(log);
glDeleteShader(vertex_shader);
glDeleteShader(fragment_shader);
return program;
}
int main(void) {
GLint shader_program;
GLint transform_location;
GLuint vbo;
GLuint vao;
GLFWwindow* window;
double time;
glfwInit();
window = glfwCreateWindow(WIDTH, HEIGHT, __FILE__, NULL, NULL);
glfwMakeContextCurrent(window);
glewExperimental = GL_TRUE;
glewInit();
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glViewport(0, 0, WIDTH, HEIGHT);
shader_program = common_get_shader_program(vertex_shader_source, fragment_shader_source);
glGenVertexArrays(1, &vao);
glGenBuffers(1, &vbo);
glBindVertexArray(vao);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
/* Position attribute */
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
/* Color attribute */
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(1);
glBindVertexArray(0);
while (!glfwWindowShouldClose(window)) {
glfwPollEvents();
glClear(GL_COLOR_BUFFER_BIT);
glUseProgram(shader_program);
transform_location = glGetUniformLocation(shader_program, "transform");
/* THIS is just a dummy transform. */
GLfloat transform[] = {
0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f,
};
time = glfwGetTime();
transform[0] = 2.0f * sin(time);
transform[5] = 2.0f * cos(time);
glUniformMatrix4fv(transform_location, 1, GL_FALSE, transform);
glBindVertexArray(vao);
glDrawArrays(GL_TRIANGLES, 0, 3);
glBindVertexArray(0);
glfwSwapBuffers(window);
}
glDeleteVertexArrays(1, &vao);
glDeleteBuffers(1, &vbo);
glfwTerminate();
return EXIT_SUCCESS;
}
GitHub en sentido ascendente.
Compila y ejecuta:
gcc -ggdb3 -O0 -o glfw_transform.out -std=c99 -Wall -Wextra -pedantic glfw_transform.c -lGL -lGLU -lglut -lGLEW -lglfw -lm
./glfw_transform.out
Producción:
La matriz para glOrtho es realmente simple, compuesto solo por escalado y traducción:
scalex, 0, 0, translatex,
0, scaley, 0, translatey,
0, 0, scalez, translatez,
0, 0, 0, 1
como se menciona en los documentos de OpenGL 2.
los glFrustum La matriz tampoco es demasiado difícil de calcular a mano, pero comienza a ser molesta. Tenga en cuenta que el frustum no se puede crear solo con escalas y traducciones como glOrtho, más información en: https://gamedev.stackexchange.com/a/118848/25171
La biblioteca matemática GLM OpenGL C ++ es una opción popular para calcular dichas matrices. http://glm.g-truc.net/0.9.2/api/a00245.html documenta tanto un ortho y frustum operaciones.
glOrtho describe una transformación que produce una paralelo proyección. La matriz actual (ver glMatrixMode) se multiplica por esta matriz y el resultado reemplaza la matriz actual, como si glMultMatrix se llamara con la siguiente matriz como argumento:
Documentación de OpenGL (mi negrita)
Los números definen las ubicaciones de los planos de recorte (izquierda, derecha, abajo, arriba, cerca y lejos).
La proyección “normal” es una proyección en perspectiva que proporciona la ilusión de profundidad. Wikipedia define una proyección paralela como:
Las proyecciones paralelas tienen líneas de proyección que son paralelas tanto en la realidad como en el plano de proyección.
La proyección paralela corresponde a una proyección en perspectiva con un punto de vista hipotético, por ejemplo, una en la que la cámara se encuentra a una distancia infinita del objeto y tiene una distancia focal infinita, o “zoom”.