OpenGL: tại sao tôi phải thiết lập bình thường với glN normal?

Tôi đang tìm hiểu một số điều cơ bản về OpenGL nhưng tôi tự hỏi tại sao lại có một cuộc gọi glNormalđể thiết lập các đỉnh bình thường.

Nếu tôi tạo một hình tam giác đơn giản như thế này:

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

Không nên định nghĩa các quy tắc ngầm theo kiểu nguyên thủy hình học? Nếu tôi không đặt bình thường, OpenGL sẽ tính toán nó?

Gọi glNormalnhiều lần giữa glBegin/Endcho phép bạn đặt bình thường trên mỗi đỉnh thay vì theo nguyên thủy.

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();

Đối với một lưới phức tạp hơn bao gồm nhiều tam giác, bạn sẽ muốn bình thường ở một đỉnh phụ thuộc vào các tam giác khác của hình học xung quanh và không chỉ là bình thường của tam giác mà nó thuộc về.

Dưới đây là một ví dụ về hình học tương tự với:

• trên các quy tắc trên mỗi đỉnh bên trái - vì vậy mỗi đỉnh của một mặt có một mức bình thường khác nhau (đối với hình cầu này, nó có nghĩa là tất cả các quy tắc đều hướng ra ngoài từ tâm của nó) và
• trên các quy tắc trên mỗi mặt phải - mỗi đỉnh có cùng giá trị bình thường (vì bạn chỉ định nó một lần hoặc vì nó sử dụng giá trị bình thường mặc định là (0,0,1)):

Mô hình bóng mặc định ( GL_SMOOTH) làm cho các quy tắc của các đỉnh của khuôn mặt được nội suy trên khuôn mặt. Đối với các quy tắc trên mỗi đỉnh, điều này dẫn đến một hình cầu được tô bóng mịn, nhưng đối với các quy tắc trên mỗi mặt, bạn kết thúc với giao diện mặt đặc trưng.

Không, GL không tính toán một chỉ tiêu cho bạn. Nó không biết những gì bình thường nên được. Người nguyên thủy của bạn không có ý nghĩa gì ngoài việc rasterization (và một vài nơi khác). GL không biết mặt nào (hình tam giác) chia sẻ một đỉnh (tính toán này khi chạy rất tốn kém mà không sử dụng các cấu trúc dữ liệu khác nhau).

Bạn cần xử lý trước "súp tam giác" của lưới để tìm các đỉnh chung và tính toán các quy tắc. Điều này nên được thực hiện trước khi trò chơi chạy cho tốc độ.

Cũng có những trường hợp như các cạnh cứng trong đó về mặt hình học có một đỉnh được chia sẻ ở góc, nhưng bạn muốn các quy tắc riêng biệt để nó sáng chính xác. Trong mô hình kết xuất GL / D3D, bạn cần hai đỉnh riêng biệt (tại cùng một vị trí) cho điều này, mỗi đỉnh có một bình thường riêng.

Bạn cũng sẽ cần tất cả điều này cho UV và ánh xạ kết cấu.

Câu trả lời ngắn gọn là bạn thực sự không cần phải thiết lập bình thường. Các vectơ bình thường chỉ được sử dụng nếu bạn đang thực hiện chiếu sáng OpenGL (hoặc có thể là một số phép tính khác có thể phụ thuộc vào chúng), nhưng nếu điều đó không áp dụng cho bạn (hoặc nếu bạn đang sử dụng một phương pháp khác để thực hiện chiếu sáng, ví dụ như lightmap ) sau đó bạn có thể khá vui vẻ bỏ qua tất cả các cuộc gọi glN normal.

Vì vậy, hãy giả sử rằng bạn đang làm một cái gì đó trong đó chỉ định glN normal có ý nghĩa và xem xét nó thêm một số.

glN normal có thể được chỉ định theo nguyên thủy hoặc mỗi đỉnh. Với các quy tắc theo nguyên thủy, tất cả những gì nó có nghĩa là tất cả các quy tắc cho mỗi đỉnh trong mặt nguyên thủy theo cùng một hướng. Đôi khi đây là những gì bạn muốn nhưng đôi khi không - trong đó các quy tắc trên mỗi đỉnh có ích là chúng cho phép mỗi đỉnh có mặt của nó.

Lấy ví dụ kinh điển về một quả cầu. Nếu mỗi tam giác trong một hình cầu có cùng mức bình thường thì kết quả cuối cùng sẽ khá rõ ràng. Đó có lẽ không phải là những gì bạn muốn, thay vào đó bạn muốn có một bóng mượt. Vì vậy, những gì bạn làm là trung bình các quy tắc cho mỗi tam giác có chung một đỉnh chung và có được kết quả bóng mờ mượt mà.

Ví dụ tối thiểu minh họa một số chi tiết về cách làm glNormalviệc với sét khuếch tán.

Các ý kiến ​​của displayhàm giải thích ý nghĩa của mỗi tam giác.

#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;
}

Học thuyết

Trong OpenGL, mỗi đỉnh có vectơ bình thường liên quan.

Vectơ bình thường xác định độ sáng của đỉnh, sau đó được sử dụng để xác định độ sáng của tam giác.

Khi một bề mặt vuông góc với ánh sáng, nó sáng hơn bề mặt song song.

glNormal thiết lập vectơ bình thường hiện tại, được sử dụng cho tất cả các đỉnh sau.

Giá trị ban đầu cho bình thường trước khi tất cả chúng ta glNormallà 0,0,1.

Các vectơ bình thường phải có định mức 1, nếu không màu thay đổi! glScalecũng thay đổi chiều dài của thông thường! glEnable(GL_NORMALIZE);làm cho OpenGL tự động đặt định mức của họ thành 1 cho chúng tôi. GIF này minh họa rất đẹp.

Tài liệu tham khảo:

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

Bạn cần glN normal để thực hiện một số tính năng phụ thuộc vào bộ mã hóa. Ví dụ, bạn có thể muốn tạo các thông số dữ liệu bảo toàn các cạnh cứng.