Как использовать glOrtho() в OpenGL?

Ответ 1

Посмотрите на эту картинку: Графические проекции

Команда glOrtho создает "наклонную" проекцию, которую вы видите в нижнем ряду. Независимо от того, как далеко вершины находятся в направлении z, они не отступят на расстояние.

Я использую glOrtho каждый раз, когда мне нужно сделать 2D-графику в OpenGL (например, панели состояния, меню и т.д.) используя следующий код каждый раз при изменении размера окна:

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0f, windowWidth, windowHeight, 0.0f, 0.0f, 1.0f);

Это преобразует координаты OpenGL в эквивалентные значения пикселей (X - от 0 до windowWidth, а Y - от 0 до windowHeight). Обратите внимание, что я перевернул значения Y, потому что координаты OpenGL начинаются с нижнего левого угла окна. Таким образом, переворачивая, я получаю более условное (0,0), начиная с верхнего левого угла окна.

Обратите внимание, что значения Z обрезаются от 0 до 1. Поэтому будьте осторожны, когда вы указываете значение Z для своей позиции вершины, оно будет обрезано, если оно выходит за пределы этого диапазона. В противном случае, если он окажется внутри этого диапазона, он, похоже, не повлияет на положение, за исключением Z-тестов.

Ответ 2

Пример минимального запуска

glOrtho: 2D-игры, объекты, находящиеся близко и далеко, имеют одинаковый размер:

glFrustrum: более реалистично, как в 3D, идентичные объекты на расстоянии кажутся меньше:

main.c

#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 upstream.

Обобщение:

gcc -ggdb3 -O0 -o main -std=c99 -Wall -Wextra -pedantic main.c -lGL -lGLU -lglut

Запустите с glOrtho:

./main 1

Запустите с glFrustrum:

./main

Проверено на Ubuntu 18.10.

Схема

Орто: камера - это плоскость, видимый объем - прямоangularьник:

Frustrum: камера - это точка, видимый объем - кусочек пирамиды:

Источник изображения.

Параметры

Мы всегда смотрим с +z на -z с +y вверх:

glOrtho(left, right, bottom, top, near, far)

• left: минимум x мы видим
• right: максимум x, который мы видим
• bottom: минимум y мы видим
• top: максимум y, который мы видим
• -near: минимум z, который мы видим. Да, это -1 раз near. Таким образом, отрицательный вход означает положительный z.
• -far: максимум z, который мы видим. Также отрицательно.

Схема:

Источник изображения.

Как это работает под капотом

В конце концов, OpenGL всегда "использует":

glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);

Если мы не используем ни glOrtho, ни glFrustrum, это то, что мы получаем.

glOrtho и glFrustrum - это просто линейные преобразования (умножение матрицы АКА), такие что:

• glOrtho: переводит заданный трехмерный прямоangularьник в куб по умолчанию
• glFrustrum: переводит данный раздел пирамиды в куб по умолчанию

Это преобразование затем применяется ко всем вершинам. Вот что я имею в виду в 2D:

Источник изображения.

Последний шаг после преобразования прост:

• удалите все точки вне куба (отбраковка): просто убедитесь, что x, y и z находятся в [-1, +1]
• проигнорируйте компонент z и возьмите только x и y, которые теперь можно поместить в 2D-экран

В glOrtho z игнорируется, поэтому вы также можете всегда использовать 0.

Одна из причин, по которой вы можете захотеть использовать z != 0, состоит в том, чтобы спрайты скрывали фон с буфером глубины.

Устаревшие

glOrtho устарело с OpenGL 4.5: профиль совместимости 12.1. "Преобразования с фиксированной функцией VERTEX" выделены красным.

Так что не используйте его для производства. В любом случае, понимание этого - хороший способ получить представление об OpenGL.

Современные программы OpenGL 4 вычисляют матрицу преобразования (которая является маленькой) на ЦП, а затем дают матрицу и все точки, которые должны быть преобразованы в OpenGL, который может выполнять тысячи умножений матриц для разных точек очень быстро параллельно.

Вручную вершинные шейдеры затем выполняют умножение явно, обычно с удобными типами векторных данных языка затенения OpenGL.

Поскольку вы пишете шейдер явно, это позволяет вам настроить алгоритм в соответствии с вашими потребностями. Такая гибкость является главной особенностью более современных графических процессоров, которые в отличие от старых, которые использовали фиксированный алгоритм с некоторыми входными параметрами, теперь могут выполнять произвольные вычисления. Смотрите также: fooobar.com/questions/84613/...

С явным GLfloat transform[] это будет выглядеть примерно так:

#include <math.h>
#include <stdio.h>
#include <stdlib.h>

#define GLEW_STATIC
#include <GL/glew.h>

#include <GLFW/glfw3.h>

#include "common.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 core\n"
    "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 core\n"
    "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
};

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 upstream.

Выход:

Матрица для glOrtho очень проста, состоит только из масштабирования и перевода:

scalex, 0,      0,      translatex,
0,      scaley, 0,      translatey,
0,      0,      scalez, translatez,
0,      0,      0,      1

как указано в документах OpenGL 2.

Матрицу glFrustum тоже не сложно вычислить вручную, но она начинает раздражать. Обратите внимание, что frustum не может быть составлен только с масштабированием и переводами, такими как glOrtho, более подробную информацию можно найти по адресу: https://gamedev.stackexchange.com/a/118848/25171

Математическая библиотека OpenML C++ GLM является популярным выбором для вычисления таких матриц. http://glm.g-truc.net/0.9.2/api/a00245.html документирует операции ortho и frustum.

Ответ 3

  glOrtho описывает преобразование, которое создает параллельную проекцию. Текущая матрица (см. GlMatrixMode) умножается на эту матрицу, и результат заменяет текущую матрицу, как если бы glMultMatrix вызывался со следующей матрицей в качестве аргумента:

Документация OpenGL (мой жирный)

Числа определяют расположение плоскостей отсечения (слева, справа, снизу, сверху, близко и далеко).

"Нормальная" проекция - это перспективная проекция, которая создает иллюзию глубины. Википедия определяет параллельную проекцию как:

Параллельные проекции имеют линии проекции, параллельные как в реальности, так и в плоскости проекции.

Параллельная проекция соответствует перспективной проекции с гипотетической точкой обзора, например, такой, где камера находится на бесконечном расстоянии от объекта и имеет бесконечное фокусное расстояние или "зум".