OpenGL: чому мені потрібно встановити нормальну функцію з glNormal?

Я вивчаю основи OpenGL, але мені цікаво, чому є дзвінок glNormal встановити нормальність вершин.

Якщо я створю такий простий трикутник:

glBegin(GL_TRIANGLES);
    glVertex3f(0,0,0);
    glVertex3f(1,0,0);
    glVertex3f(0,1,0);
glEnd();

Чи не слід нормалі визначати неявно за типом геометричного примітиву? Якщо я не встановлю нормальне значення, чи обчислить його OpenGL?

Виклик glNormalдекількох разів між собою glBegin/Endдозволяє встановити нормальну для вершини замість первісної.

glBegin(GL_TRIANGLES);
    glNormal3f(0,0,1);
    glVertex3f(0,0,0);
    glNormal3f(0,0,1);
    glVertex3f(1,0,0);
    glNormal3f(0,0,1);
    glVertex3f(0,1,0);
glEnd();

Для більш складної сітки, що складається з декількох трикутників, ви хочете, щоб нормальна в одній вершині залежала від інших трикутників навколишньої геометрії, а не лише від норми трикутника, до якої вона належить.

Ось приклад тієї самої геометрії з:

• ліворуч за вершиною нормали - тому кожна вершина обличчя має іншу норму (для цієї сфери це означає, що всі нормали вказують назовні від її центру), і
• праворуч за нормальною нормою - кожна вершина отримує однакове нормальне значення (оскільки ви вказали її лише один раз або тому, що вона використовує стандартне значення за замовчуванням (0,0,1)):

Модель відтінку за замовчуванням ( GL_SMOOTH) призводить до того, що нормали вершин обличчя будуть інтерпольовані по обличчю. Для нормальних вершин це призводить до гладкої затіненої сфери, але для нормальних для обличчя ви закінчуєтеся характерним обличчям .

Ні, GL не розраховує норму для вас. Він не може знати, яким має бути нормальний стан. Ваші примітиви не означають нічого, крім растерізації (та кількох інших місць). GL не знає, на які грані (трикутники) ділиться вершина (обчислювати це під час виконання дуже дорого без використання різних структур даних).

Потрібно попередньо обробити сітчастий «трикутний суп», щоб знайти загальні вершини та обчислити нормалі. Це слід зробити до того, як гра працює на швидкість.

Також є такі випадки, як жорсткі ребра, коли геометрично на куті є спільна вершина, але ви хочете, щоб окремі нормали були правильно. У моделі рендерингу GL / D3D для цього вам потрібні дві окремі вершини (в одному і тому ж положенні), кожна з яких має окрему нормальну.

Вам знадобиться все це для ультрафіолетового випромінювання та текстурування карти.

Коротка відповідь полягає в тому, що вам насправді взагалі не потрібно встановлювати норму. Звичайні вектори використовуються лише в тому випадку, якщо ви виконуєте освітлення OpenGL (або, можливо, якийсь інший розрахунок, який може залежати від них), але якщо це не стосується вас (або якщо ви використовуєте інший метод освітлення, наприклад, світлові карти ), то ви можете цілком радісно опустити всі виклики glNormal.

Отже, припустимо, що ви робите щось, де вказувати glNormal має сенс, і перегляньте це ще раз.

glNormal може бути вказаний первістично або за вершиною. Що стосується первісних нормалів, все, що це означає, - це те, що всі норми для кожної вершини в примітивній грані в одному напрямку. Іноді це те, що ви хочете, але іноді це не так - де корисні для вершин норми корисні, це те, що вони дозволяють кожній вершині мати своє обличчя.

Візьмемо класичний приклад сфери. Якби кожен трикутник у кулі мав однакову норму, то кінцевий результат був би досить гранічним. Мабуть, це не те, що ви хочете, ви хочете плавне затінення замість цього. Отже, те, що ви робите, - це середні норми для кожного трикутника, які мають спільну вершину, і отримуєте плавний затінений результат.

Мінімальний приклад, який ілюструє деякі деталі того, як glNormalпрацює з розсіяною блискавкою.

У коментарях displayфункції пояснюється, що означає кожен трикутник.

#include <stdlib.h>

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

/* Triangle on the x-y plane. */
static void draw_triangle() {
    glBegin(GL_TRIANGLES);
    glVertex3f( 0.0f,  1.0f, 0.0f);
    glVertex3f(-1.0f, -1.0f, 0.0f);
    glVertex3f( 1.0f, -1.0f, 0.0f);
    glEnd();
}

/* A triangle tilted 45 degrees manually. */
static void draw_triangle_45() {
    glBegin(GL_TRIANGLES);
    glVertex3f( 0.0f,  1.0f, -1.0f);
    glVertex3f(-1.0f, -1.0f,  0.0f);
    glVertex3f( 1.0f, -1.0f,  0.0f);
    glEnd();
}

static void display(void) {
    glColor3f(1.0f, 0.0f, 0.0f);
    glClear(GL_COLOR_BUFFER_BIT);
    glPushMatrix();

    /*
    Triangle perpendicular to the light.
    0,0,1 also happens to be the default normal if we hadn't specified one.
    */
    glNormal3f(0.0f, 0.0f, 1.0f);
    draw_triangle();

    /*
    This triangle is as bright as the previous one.
    This is not photorealistic, where it should be less bright.
    */
    glTranslatef(2.0f, 0.0f, 0.0f);
    draw_triangle_45();

    /*
    Same as previous triangle, but with the normal set
    to the photorealistic value of 45, making it less bright.

    Note that the norm of this normal vector is not 1,
    but we are fine since we are using `glEnable(GL_NORMALIZE)`.
    */
    glTranslatef(2.0f, 0.0f, 0.0f);
    glNormal3f(0.0f, 1.0f, 1.0f);
    draw_triangle_45();

    /*
    This triangle is rotated 45 degrees with a glRotate.
    It should be as bright as the previous one,
    even though we set the normal to 0,0,1.
    So glRotate also affects the normal!
    */
    glTranslatef(2.0f, 0.0f, 0.0f);
    glNormal3f(0.0, 0.0, 1.0);
    glRotatef(45.0, -1.0, 0.0, 0.0);
    draw_triangle();

    glPopMatrix();
    glFlush();
}

static void init(void) {
    GLfloat light0_diffuse[] = {1.0, 1.0, 1.0, 1.0};
    /* Plane wave coming from +z infinity. */
    GLfloat light0_position[] = {0.0, 0.0, 1.0, 0.0};
    glClearColor(0.0, 0.0, 0.0, 0.0);
    glShadeModel(GL_SMOOTH);
    glLightfv(GL_LIGHT0, GL_POSITION, light0_position);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glColorMaterial(GL_FRONT, GL_DIFFUSE);
    glEnable(GL_COLOR_MATERIAL);
    glEnable(GL_NORMALIZE);
}

static void reshape(int w, int h) {
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-1.0, 7.0, -1.0, 1.0, -1.5, 1.5);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(800, 200);
    glutInitWindowPosition(100, 100);
    glutCreateWindow(argv[0]);
    init();
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutMainLoop();
    return EXIT_SUCCESS;
}

Теорія

У OpenGL у кожної вершини є власний асоційований нормальний вектор.

Нормальний вектор визначає, наскільки яскравою є вершина, яка потім використовується для визначення того, наскільки яскравим є трикутник.

Коли поверхня перпендикулярна до світла, вона яскравіша за паралельну поверхню.

glNormal встановлює поточний нормальний вектор, який використовується для всіх наступних вершин.

Початкове значення для нормального , перш ніж все glNormalце 0,0,1.

Звичайні вектори повинні мати норму 1, інакше змінюються кольори! glScaleтакож змінює довжину норми!glEnable(GL_NORMALIZE);змушує OpenGL автоматично встановлювати для них свою норму 1. Цей GIF це прекрасно ілюструє.

Бібліографія:

• /programming/5906993/what-is-a-normal-in-opengl
• https://www.opengl.org/sdk/docs/man2/xhtml/glNormal.xml
• http://www.tomdalling.com/blog/modern-opengl/06-diffuse-point-lighting/
• http://learnopengl.com/#!Advanced-Lighting/Normal-Mapping

Вам потрібно glNormal, щоб реалізувати деякі функції, що залежать від кодера. Наприклад, ви можете створити нормали, щоб зберегти жорсткі краї.