c - OpenGL/GLUT GL_LINES 的照明不正确-6ren

c - OpenGL/GLUT GL_LINES 的照明不正确

转载作者：太空狗更新时间：2023-10-29 15:38:24

我被要求制作一个简单的旋转木马，通过鼠标左右点击来旋转。对于我使用的棍子 GL_LINES我遇到的问题是无法定义法线 vector 或类似我在 GL_POLYGON 中所做的事情使照明正确。我在网上搜索，但没有找到任何来源来解释 GL_LINES 的灯光。 (有些人告诉我照明是自动的，我不需要为 GL_LINES 指定任何内容)，这就是我提出问题的原因。

这是正面的屏幕截图，从正面看一切正常:

enter image description here

这是显示照明问题的背面屏幕截图。特别是，光源在后面，但那些棍子仍然很亮。

enter image description here

这是背面的另一个屏幕截图，也显示了照明方面的问题。

enter image description here

这是指定水平和垂直杆的两个函数:

void DrawHorizontalStick(){
    glLineWidth(15);
    glColor3f(1.0, 0.0, 0.0);
    glBegin(GL_LINES);
    glVertex3f(0.0, 7.0, 0.0);
    glVertex3f(4.0 * cos(radian__IN_RANGE), 7.0 + 4.0 * sin(radian__IN_RANGE), 0.0);
    glEnd();
}

void DrawVerticalStick(){
    glLineWidth(5);
    glColor3f(1.0, 0.0, 0.0);
    glBegin(GL_LINES);
    glVertex3f(4.0 * cos(radian__IN_RANGE), 7.0 + 4.0 * sin(radian__IN_RANGE), 0.0);
    glVertex3f(4.0 * cos(radian__IN_RANGE), 7.0 + 4.0 * sin(radian__IN_RANGE) - 1, 0.0);
    glEnd();
}

完整的源代码如下:

#include <GL/glut.h>
#include <stdlib.h>
#include <Windows.h>
#include <math.h>
#include <stdio.h>


#define PI 3.14159265
#define numberOfRotationTypes 3


static GLfloat lpos[] = { 0.0, 6.0, 8.0, 1.0 };
static GLfloat black[] = { 0.0, 0.0, 0.0, 1.0 };
static GLfloat white[] = { 1.0, 1.0, 1.0, 1.0 };
static GLfloat red[] = { 1.0, 0.0, 0.0, 1.0 };
static GLfloat green[] = { 0.0, 1.0, 0.0, 1.0 };
static GLfloat blue[] = { 0.0, 0.0, 1.0, 1.0 };
static GLfloat yellow[] = { 1.0, 1.0, 0.0, 1.0 };
static GLfloat magenta[] = { 1.0, 0.0, 1.0, 1.0 };
static GLfloat cyan[] = { 0.0, 1.0, 1.0, 1.0 };
static GLfloat lightgreen[] = { 0.5, 1.0, 0.5, 1.0 };
static float alpha = 0.0;
static float beta = PI / 6.0;
static float zoom = 25.0;
static bool lightSource = true;

float numberOfTriangles = 1;
static GLdouble cpos[3];

static double fenceHeight = -0.5;
static int angle = 0;
static int angle__IN_RANGE = 0.0;
static double radian__IN_RANGE = 0.0;
static int arrayOfAnglesInRange[181];
static int id = 0;

static int speed = 0;
static int signal = 1;

static GLint window[2];
static int rotationType = 0;

void init(void)
{
    glClearColor(0.0, 0.0, 0.0, 0.0);
    glEnable(GL_DEPTH_TEST);
    glShadeModel(GL_SMOOTH);

    /* since back "face" appears in wireframe mode */
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);

    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
}

void writemessage()
{

}

void processAngle(){
    angle__IN_RANGE = arrayOfAnglesInRange[abs(angle) % 181];
}

void setRadian_IN_RANGE(){
    radian__IN_RANGE = ((float)angle__IN_RANGE / 180) * PI;
}

void fillArray(){
    int j = -45;
    for (int i = 0; i < 181; i++)
    {
        if (i < 90)
            arrayOfAnglesInRange[i] = j++;
        else
            arrayOfAnglesInRange[i] = j--;
    }

    //for (int i = 0; i < 182; i++)
    //{
    //  printf("%d\n", arrayOfAnglesInRange[i]);
    //}
}

void keepTrackOfID(){
    int tempAngle = angle;


    if (id % 4 == 0)
        angle += 0;
    else if (id % 4 == 1)
        angle += 30;
    else if (id % 4 == 2)
        angle += 60;
    else if (id % 4 == 3)
        angle += 90;


    processAngle();
    setRadian_IN_RANGE();
    angle = tempAngle;
}


void reshape(int w, int h)
{
    glViewport(0, 0, (GLsizei)w, (GLsizei)h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.0, (GLfloat)w / (GLfloat)h, 0.01, 50.0);
    glMatrixMode(GL_MODELVIEW);
}

void DrawSticksArroundYard(){
    glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
    glMaterialfv(GL_BACK, GL_AMBIENT_AND_DIFFUSE, black);
    GLUquadricObj *quadObj;

    // Right-Line
    glPushMatrix();
    glTranslatef(6.8, 1.0 + fenceHeight, -7.0);
    quadObj = gluNewQuadric();
    gluCylinder(quadObj, 0.1, 0.1, 14.0, 10, 10);
    glPopMatrix();

    // Left-Line
    glPushMatrix();
    glTranslatef(-6.8, 1.0 + fenceHeight, -7.0);
    quadObj = gluNewQuadric();
    gluCylinder(quadObj, 0.1, 0.1, 14.0, 10, 10);
    glPopMatrix();

    // Back-Line
    glPushMatrix();
    glTranslatef(-6.8, 1.0 + fenceHeight, -7.0);
    glRotatef(90, 0, 1, 0);
    quadObj = gluNewQuadric();
    gluCylinder(quadObj, 0.1, 0.1, 13.7, 10, 10);
    glRotatef(-90, 0, 1, 0);
    glPopMatrix();

    // Front-Line
    glPushMatrix();
    glTranslatef(6.8, 1.0 + fenceHeight, 7.0);
    glRotatef(-90, 0, 1, 0);
    quadObj = gluNewQuadric();
    gluCylinder(quadObj, 0.1, 0.1, 13.7, 10, 10);
    glRotatef(90, 0, 1, 0);
    glPopMatrix();

    // Pin-Front-Right
    glPushMatrix();
    glTranslatef(6.8, 0, 7.0);
    glRotatef(-90, 1, 0, 0);
    quadObj = gluNewQuadric();
    gluCylinder(quadObj, 0.2, 0.1, 1.3 + fenceHeight, 10, 10);
    glRotatef(90, 1, 0, 0);
    glPopMatrix();

    // Pin-Front-Left
    glPushMatrix();
    glTranslatef(-6.8, 0, 7.0);
    glRotatef(-90, 1, 0, 0);
    quadObj = gluNewQuadric();
    gluCylinder(quadObj, 0.2, 0.1, 1.3 + fenceHeight, 10, 10);
    glRotatef(90, 1, 0, 0);
    glPopMatrix();

    // Pin-Back-Left
    glPushMatrix();
    glTranslatef(-6.8, 0, -7.0);
    glRotatef(-90, 1, 0, 0);
    quadObj = gluNewQuadric();
    gluCylinder(quadObj, 0.2, 0.1, 1.3 + fenceHeight, 10, 10);
    glRotatef(90, 1, 0, 0);
    glPopMatrix();

    // Pin-Back-Right
    glPushMatrix();
    glTranslatef(6.8, 0, -7.0);
    glRotatef(-90, 1, 0, 0);
    quadObj = gluNewQuadric();
    gluCylinder(quadObj, 0.2, 0.1, 1.3 + fenceHeight, 10, 10);
    glRotatef(90, 1, 0, 0);
    glPopMatrix();

    // Pin-Back-Center
    glPushMatrix();
    glTranslatef(0, 0, -7.0);
    glRotatef(-90, 1, 0, 0);
    quadObj = gluNewQuadric();
    gluCylinder(quadObj, 0.2, 0.1, 1.3 + fenceHeight, 10, 10);
    glRotatef(90, 1, 0, 0);
    glPopMatrix();

    // Pin-Front-Center
    glPushMatrix();
    glTranslatef(0, 0, 7.0);
    glRotatef(-90, 1, 0, 0);
    quadObj = gluNewQuadric();
    gluCylinder(quadObj, 0.2, 0.1, 1.3 + fenceHeight, 10, 10);
    glRotatef(90, 1, 0, 0);
    glPopMatrix();

    // Pin-Right-Center
    glPushMatrix();
    glTranslatef(6.8, 0, 0);
    glRotatef(-90, 1, 0, 0);
    quadObj = gluNewQuadric();
    gluCylinder(quadObj, 0.2, 0.1, 1.3 + fenceHeight, 10, 10);
    glRotatef(90, 1, 0, 0);
    glPopMatrix();

    // Pin-Left-Center
    glPushMatrix();
    glTranslatef(-6.8, 0, 0);
    glRotatef(-90, 1, 0, 0);
    quadObj = gluNewQuadric();
    gluCylinder(quadObj, 0.2, 0.1, 1.3 + fenceHeight, 10, 10);
    glRotatef(90, 1, 0, 0);
    glPopMatrix();
}

void DrawYardFloor(){
    glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, lightgreen);
    glMaterialfv(GL_BACK, GL_AMBIENT_AND_DIFFUSE, lightgreen);
    glBegin(GL_POLYGON);
    glNormal3f(0, 1, 0);
    glVertex3f(-7.3, -0.005, -7.3);
    glVertex3f(-7.3, -0.005, 7.3);
    glVertex3f(7.3, -0.005, 7.3);
    glVertex3f(7.3, -0.005, -7.3);
    glEnd();
}

void DrawCenterPin(){
    glRotatef(-90, 1, 0, 0);
    GLUquadricObj *quadObj = gluNewQuadric();
    gluCylinder(quadObj, 0.2, 0.2, 7, 10, 10);
    glRotatef(90, 1, 0, 0);
}

void DrawBase(){
    glRotatef(-90, 1, 0, 0);
    GLUquadricObj *quadObj = gluNewQuadric();
    gluCylinder(quadObj, 0.5, 0.1, 2, 10, 10);
    glRotatef(90, 1, 0, 0);

}

void DrawTop(){
    glPushMatrix();
    glTranslatef(0, 7, 0);
    glRotatef(-90, 1, 0, 0);
    GLUquadricObj *quadObj = gluNewQuadric();
    gluCylinder(quadObj, 0.2, 0.0, 0.5, 10, 10);
    glRotatef(90, 1, 0, 0);
    glPopMatrix();
}


void DrawHorizontalStick(){
    glLineWidth(15);
    glColor3f(1.0, 0.0, 0.0);
    glBegin(GL_LINES);
    glVertex3f(0.0, 7.0, 0.0);
    glVertex3f(4.0 * cos(radian__IN_RANGE), 7.0 + 4.0 * sin(radian__IN_RANGE), 0.0);
    glEnd();
}

void DrawVerticalStick(){
    glLineWidth(5);
    glColor3f(1.0, 0.0, 0.0);
    glBegin(GL_LINES);
    glVertex3f(4.0 * cos(radian__IN_RANGE), 7.0 + 4.0 * sin(radian__IN_RANGE), 0.0);
    glVertex3f(4.0 * cos(radian__IN_RANGE), 7.0 + 4.0 * sin(radian__IN_RANGE) - 1, 0.0);
    glEnd();
}

void DrawCabin(){

    // Back
    glNormal3f(0.0, 0.0, -1.0);
    glBegin(GL_POLYGON);
    glVertex3f(0, 0, -1);
    glVertex3f(0, 1, -1);
    glVertex3f(2, 1, -1);
    glVertex3f(2, 0, -1);
    glEnd();

    glNormal3f(0.0, 0.0, -1.0);
    glBegin(GL_POLYGON);
    glVertex3f(0, 1.7, -1);
    glVertex3f(0, 2, -1);
    glVertex3f(2, 2, -1);
    glVertex3f(2, 1.7, -1);
    glEnd();

    glNormal3f(0.0, 0.0, -1.0);
    glBegin(GL_POLYGON);
    glVertex3f(0, 1, -1);
    glVertex3f(0, 1.7, -1);
    glVertex3f(0.2, 1.7, -1);
    glVertex3f(0.2, 1, -1);
    glEnd();

    glNormal3f(0.0, 0.0, -1.0);
    glBegin(GL_POLYGON);
    glVertex3f(1.8, 1, -1);
    glVertex3f(1.8, 1.7, -1);
    glVertex3f(2, 1.7, -1);
    glVertex3f(2, 1, -1);
    glEnd();


    // Front
    glNormal3f(0.0, 0.0, 1.0);
    glBegin(GL_POLYGON);
    glVertex3f(2, 0, 1);
    glVertex3f(2, 1, 1);
    glVertex3f(0, 1, 1);
    glVertex3f(0, 0, 1);
    glEnd();

    glNormal3f(0.0, 0.0, 1.0);
    glBegin(GL_POLYGON);
    glVertex3f(2, 1.7, 1);
    glVertex3f(2, 2, 1);
    glVertex3f(0, 2, 1);
    glVertex3f(0, 1.7, 1);
    glEnd();

    glNormal3f(0.0, 0.0, 1.0);
    glBegin(GL_POLYGON);
    glVertex3f(0.2, 1, 1);
    glVertex3f(0.2, 1.7, 1);
    glVertex3f(0, 1.7, 1);
    glVertex3f(0, 1, 1);
    glEnd();

    glNormal3f(0.0, 0.0, 1.0);
    glBegin(GL_POLYGON);
    glVertex3f(2, 1, 1);
    glVertex3f(2, 1.7, 1);
    glVertex3f(1.8, 1.7, 1);
    glVertex3f(1.8, 1, 1);
    glEnd();


    // Floor
    glNormal3f(0.0, -1.0, 0.0);
    glBegin(GL_POLYGON);
    glVertex3f(2, 0, -1);
    glVertex3f(2, 0, 1);
    glVertex3f(0, 0, 1);
    glVertex3f(0, 0, -1);
    glEnd();


    // Top
    glNormal3f(0.0, 1.0, 0.0);
    glBegin(GL_POLYGON);
    glVertex3f(2, 2, 1);
    glVertex3f(2, 2, -1);
    glVertex3f(0, 2, -1);
    glVertex3f(0, 2, 1);
    glEnd();

    // Right
    glNormal3f(1.0, 0.0, 0.0);
    glBegin(GL_POLYGON);
    glVertex3f(2, 0, -1);
    glVertex3f(2, 1, -1);
    glVertex3f(2, 1, 1);
    glVertex3f(2, 0, 1);
    glEnd();

    glNormal3f(1.0, 0.0, 0.0);
    glBegin(GL_POLYGON);
    glVertex3f(2, 1.7, -1);
    glVertex3f(2, 2, -1);
    glVertex3f(2, 2, 1);
    glVertex3f(2, 1.7, 1);
    glEnd();

    glNormal3f(1.0, 0.0, 0.0);
    glBegin(GL_POLYGON);
    glVertex3f(2, 1, -1);
    glVertex3f(2, 1.7, -1);
    glVertex3f(2, 1.7, -0.8);
    glVertex3f(2, 1, -0.8);
    glEnd();

    glNormal3f(1.0, 0.0, 0.0);
    glBegin(GL_POLYGON);
    glVertex3f(2, 1, 0.8);
    glVertex3f(2, 1.7, 0.8);
    glVertex3f(2, 1.7, 1);
    glVertex3f(2, 1, 1);
    glEnd();

    // Left
    glNormal3f(-1.0, 0.0, 0.0);
    glBegin(GL_POLYGON);
    glVertex3f(0, 0, -1);
    glVertex3f(0, 0, 1);
    glVertex3f(0, 1, 1);
    glVertex3f(0, 1, -1);
    glEnd();

    glNormal3f(-1.0, 0.0, 0.0);
    glBegin(GL_POLYGON);
    glVertex3f(0, 1.7, -1);
    glVertex3f(0, 1.7, 1);
    glVertex3f(0, 2, 1);
    glVertex3f(0, 2, -1);
    glEnd();

    glNormal3f(-1.0, 0.0, 0.0);
    glBegin(GL_POLYGON);
    glVertex3f(0, 1, -1);
    glVertex3f(0, 1, -0.8);
    glVertex3f(0, 1.7, -0.8);
    glVertex3f(0, 1.7, -1);
    glEnd();

    glNormal3f(-1.0, 0.0, 0.0);
    glBegin(GL_POLYGON);
    glVertex3f(0, 1, 0.8);
    glVertex3f(0, 1, 1);
    glVertex3f(0, 1.7, 1);
    glVertex3f(0, 1.7, 0.8);
    glEnd();
}

void darwCabin__FINAL(){
    glPushMatrix();
    glTranslatef(4.0 * cos(radian__IN_RANGE), 7.0 + 4.0 * sin(radian__IN_RANGE) - 3, 0.0);
    glRotatef(angle, 0, 1, 0);
    glPushMatrix();
    glTranslatef(-1, 0, 0);
    DrawCabin();
    glPopMatrix();
    glRotatef(-angle, 0, 1, 0);
    glPopMatrix();
}

void display(void)
{
    for (int i = 0; i < 2; i++) {
        glutSetWindow(window[i]); // set the current window to window[i]

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glLoadIdentity();
        glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 64);



        if (i == 1) {
            gluLookAt(0.7, 0, 0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
            glRotatef(-angle, 0, 1, 0);
            glTranslatef(-4.0 * cos(radian__IN_RANGE), -5.4 + 4.0 * sin(radian__IN_RANGE), 0);
            glRotatef(-angle, 0, 1, 0);
        }
        else if (i == 0) {
            cpos[0] = zoom * cos(beta) * sin(alpha);
            cpos[1] = zoom * sin(beta);
            cpos[2] = zoom * cos(beta) * cos(alpha);
            gluLookAt(cpos[0], cpos[1], cpos[2], 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
        }


        if (lightSource == true){
            glLightfv(GL_LIGHT0, GL_POSITION, lpos);
            glMaterialfv(GL_FRONT, GL_EMISSION, white);
            glPushMatrix();
            glTranslatef(lpos[0], lpos[1], lpos[2]);
            glutSolidSphere(0.1, 10, 8);
            glPopMatrix();
            glMaterialfv(GL_FRONT, GL_EMISSION, black);
        }

        DrawYardFloor();
        DrawSticksArroundYard();
        DrawCenterPin();
        DrawBase();
        DrawTop();

        glRotatef(angle, 0, 1, 0);
        for (int j = 0; j < 4; j++){


            glMaterialfv(GL_FRONT, GL_SPECULAR, white);
            glMaterialf(GL_FRONT, GL_SHININESS, 64);


            if (id % 4 == 0)
            {
                glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green);
                glMaterialfv(GL_BACK, GL_AMBIENT_AND_DIFFUSE, black);
            }
            else if (id % 4 == 1)
            {
                glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue);
                glMaterialfv(GL_BACK, GL_AMBIENT_AND_DIFFUSE, black);
            }
            else if (id % 4 == 2)
            {
                glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, white);
                glMaterialfv(GL_BACK, GL_AMBIENT_AND_DIFFUSE, black);
            }
            else if (id % 4 == 3)
            {
                glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, cyan);
                glMaterialfv(GL_BACK, GL_AMBIENT_AND_DIFFUSE, black);
            }
            glPushMatrix();
            glRotatef(j * 360 / 4, 0, 1, 0);
            keepTrackOfID();

            DrawHorizontalStick();
            DrawVerticalStick();
            darwCabin__FINAL();

            id++;
            glPopMatrix();
        }
        glRotatef(-angle, 0, 1, 0);


        glFlush();
        glutSwapBuffers();
    }
}


void keyboard(unsigned char key, int x, int y)
{
    static int polygonmode[2];

    switch (key) {
    case 27:
        exit(0);
        break;
    case 'x':
        if (lightSource == true)
            lpos[0] = lpos[0] + 0.2;
        glutPostRedisplay();
        break;
    case 'X':
        if (lightSource == true)
            lpos[0] = lpos[0] - 0.2;
        glutPostRedisplay();
        break;
    case 'y':
        if (lightSource == true)
            lpos[1] = lpos[1] + 0.2;
        glutPostRedisplay();
        break;
    case 'Y':
        if (lightSource == true)
            lpos[1] = lpos[1] - 0.2;
        glutPostRedisplay();
        break;
    case 'z':
        if (lightSource == true)
            lpos[2] = lpos[2] + 0.2;
        glutPostRedisplay();
        break;
    case 'Z':
        if (lightSource == true)
            lpos[2] = lpos[2] - 0.2;
        glutPostRedisplay();
        break;

    case '+':
        if (zoom != 1.5)zoom = zoom - 0.5;
        glutPostRedisplay();
        break;
    case '-':
        if (zoom != 30)zoom = zoom + 0.5;
        glutPostRedisplay();
        break;
    case '0':
        if (lightSource == true){
            glDisable(GL_LIGHT0);
            lightSource = false;
        }
        else{
            glEnable(GL_LIGHT0);
            lightSource = true;
        }
        glutPostRedisplay();
        break;

    case 'e':
        if (fenceHeight < 2)
            fenceHeight += 0.5;
        glutPostRedisplay();
        break;
    case 'd':
        if (fenceHeight > -0.5)
            fenceHeight -= 0.5;
        glutPostRedisplay();
        break;

    case 'w':
        glGetIntegerv(GL_POLYGON_MODE, polygonmode);
        if (polygonmode[0] == GL_FILL)
            glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
        else glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
        glutPostRedisplay();
        break;
    case 'n':
        angle++;
        processAngle();
        setRadian_IN_RANGE();
        glutPostRedisplay();
        break;
    case 'm':
        angle--;
        processAngle();
        setRadian_IN_RANGE();
        glutPostRedisplay();
        break;
    default:
        break;
    }
}

void mouse(int button, int state, int x, int y)
{
    switch (button) {
    case GLUT_LEFT_BUTTON:
        signal = 0;
        if (speed <= 15)
            speed++;
        break;
    case GLUT_MIDDLE_BUTTON:
    case GLUT_RIGHT_BUTTON:
        signal = 1;
        if (speed >= 1)
            speed--;
        break;
    default:
        break;
    }
}

void specialkey(GLint key, int x, int y)
{
    switch (key) {
    case GLUT_KEY_RIGHT:
        alpha = alpha + PI / 180;
        if (alpha > 2 * PI) alpha = alpha - 2 * PI;
        glutPostRedisplay();
        break;
    case GLUT_KEY_LEFT:
        alpha = alpha - PI / 180;
        if (alpha < 0) alpha = alpha + 2 * PI;
        glutPostRedisplay();
        break;
    case GLUT_KEY_UP:
        if (beta < 0.45*PI) beta = beta + PI / 180;
        glutPostRedisplay();
        break;
    case GLUT_KEY_DOWN:
        if (beta > -0.05*PI) beta = beta - PI / 180;
        glutPostRedisplay();
        break;
    default:
        break;
    }
}

void anim(){
    if (signal == 0){
        angle++;
        glutPostRedisplay();
        Sleep((int)(50 / speed));
    }
    else if (signal == 1){
        if (speed != 0){
            angle++;
            glutPostRedisplay();
            Sleep((int)(50 / speed));
        }
    }
}

int main(int argc, char** argv)
{
    writemessage();
    fillArray();
    processAngle();
    setRadian_IN_RANGE();

    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

    glutInitWindowSize(500, 500);
    glutInitWindowPosition(0, 0);
    window[0] = glutCreateWindow("First");
    init();

    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutIdleFunc(anim);
    glutMouseFunc(mouse);
    glutKeyboardFunc(keyboard);
    glutSpecialFunc(specialkey);

    glutInitWindowSize(500, 500);
    glutInitWindowPosition(600, 10);
    window[1] = glutCreateWindow("Second");
    init();

    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutIdleFunc(anim);
    glutMouseFunc(mouse);
    glutKeyboardFunc(keyboard);
    glutSpecialFunc(specialkey);

    glutMainLoop();
    return 0;
}

最佳答案

线条的光照与其他对象的光照一样。颜色/亮度是根据法线、光照和 Material 参数计算的。

如果您正在使用即时模式绘制命令，则可以在为线条调用 glVertex3f() 之前使用 glNormal3f() 指定法线。如果您不以这种方式指定法线，则基于先前对 glNormal*() 的调用的当前法线将用作您的线条的法线。

现在，明显的后续问题是:一条线的法线是多少？
简单的答案是:无论您想要什么，都会给您想要的结果。

举个典型的例子，如果你用线框模式画一个解析面，这个解析面的法线就可以作为法线。这将给出一个线框模型，其中阴影/亮度对应于表面的形状。

在您的示例中，最明显且可以说是最好的方法是不画线，而是使用某种细梁/圆柱体用多边形表示几何体。但作为练习，我们可以弄清楚这如何处理线条。

在这种情况下，您希望线条代表一个无限细的圆柱体。一个实际的圆柱体的每个顶点的法线都指向外。但是由于直线只有两个顶点，您必须从无穷多的 vector 集中选择一个方向，该方向从终点指向外，并且与直线正交。

我相信您可以通过选择最接近指向视点的法 vector 来获得合理的结果。如果您实际使用圆柱体，这将导致您通过观察圆柱体的中心线获得的亮度。这些法线可以通过以下方式计算:

将您的模型转换应用到线的原始端点 v1 和 v2。我们将转换后的端点称为 v1t 和 v2t。
计算变换线的方向 vector 为:
```
v1d = v2t - v1t
v1d.normalize()
```
计算线端点到视点vp的 vector ，相对于线的方向正交化，归一化:
```
v1n = vp - v1
v1n -= dot(v1d * v1n) * v1d
v1n.normalize()
```
将逆向模型变换应用于 v1n 以获得原始对象空间中的法线。
对第二个顶点进行等效计算。

您可以通过对视点进行逆变换，然后直接在对象空间中计算法线来获得相同的结果。

关于c - OpenGL/GLUT GL_LINES 的照明不正确，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/26921710/

文章推荐： android - 改造给出 java.lang.VerifyError

文章推荐： android - 无法创建目录/Volumes/Android Studio

文章推荐： java - 回调怪异行为(Android、Picasso 库)

文章推荐： Android webview 在默认浏览器中打开页面而不是我的 webview

OpenGL GL_LINES 端点未加入
我在使用 GL_LINES block 时遇到问题……下面示例中的线条没有连接到末端(尽管有时它会随机决定连接一个或两个角)。相反，端点彼此相距 1 像素(留下一个未完全平方的角；如果这有意义的话)。
opengl - GL_LINES 是创建三角形还是使用它们自己的处理？
一段时间以来，我一直对 GL_LINES(以及 GL_LINE_LOOP 和 STRIP)感到好奇，我想知道 GL 实现通常如何处理它们。他们是否从线的端点和宽度推断出四边形？它会做一些更原始和更专业
python - GL_LINES 没有出现在立方体的顶部？
我正在尝试使用 OpenGL 和 Pygame 创建一个 3d Rubiks Cube。但是，当我尝试在我创建的 GL_QUADS 表面上绘制线条时，它们没有显示出来。我已经尝试将 GL_LINES
opengl - 在 GL_LINES 中使用深度缓冲区
我想绘制一个删除隐藏边缘的对象的边缘。我想应用的想法是首先将对象的面渲染到深度缓冲区，然后在第二遍中绘制边缘并启用深度测试。由于并非所有三角形边都应该可见，因此这些边是单独存储的(简单示例:在立方体
opengl - 为什么 GL_LINES 模糊？
考虑以下代码: glColor4ub(255, 255, 255,255); glBegin(GL_QUADS); glVertex2i(100, 100); glVertex2i(300, 100)
c++ - 有没有办法确定每个 GL_LINE 元素将写入多少像素？
我试图通过添加混合渲染到 FBO 来计算每个像素被写入的总次数来近似“轨迹密度”。问题是 (1) 位移大的元素会因为线较长而被计数更多次，以及 (2) 由于用于绘制线的像素数也取决于线的角度。我想
opengl-3 - glDrawArrays GL_LINES 未正确绘制线条
我试图用下面的代码画一条线，它的工作原理: // Include standard headers #include #include // Include GLEW #include // I
opengl - 是否可以让 OpenGL 用类似钢笔的笔画绘制 GL_LINES？
我所说的“类似钢笔”的笔画是这样的:当你用圆珠笔在纸上画画时。您将获得一 strip 有圆形开头和结尾的线条。如果我的解释不够好，请参阅 http://java.sun.com/docs/books/
opengl - glPolygonMode(GL_BACK,GL_LINE) 不起作用
glEnable(GL_CULL_FACE); glCullFace(GL_FRONT); glPolygonMode(GL_BACK,GL_LINE); 在上面的代码示例中，glPolygonMod
opengl - GL_POINT 和 GL_LINES - 真正有用吗？
一段时间以来，我一直在使用 OpenGL 来制作 3D 应用程序，但我从来没有真正理解在生产阶段使用 GL_POINT 和 GL_LINES 原始绘图类型用于 3D 游戏。 (哪里)OpenGL 中的
c++ - glPolygonMode(GL_FRONT_AND_BACK, GL_LINES) 不工作
我正在尝试以正常填充模式渲染图元，然后将其渲染为线框。渲染代码: glClear(GL_COLOR_BUFFER_BIT); glClearColor(0.9f, 0.9f, 0.9f, 1); /
c - OpenGL/GLUT GL_LINES 的照明不正确
我被要求制作一个简单的旋转木马，通过鼠标左右点击来旋转。对于我使用的棍子 GL_LINES我遇到的问题是无法定义法线 vector 或类似我在 GL_POLYGON 中所做的事情使照明正确。我在网上搜
c++ - 如何使用 GL_LINES 在视口(viewport)周围绘制边框？
我无法让我的着色器在纹理的周边运行。我正在关注 https://learnopengl.com/作为指南并使用索引顶点绘制线基元。问题是只绘制了右侧和底部的线，缺少顶部和左侧。我编写了一个小程序来尝
ios - GLKit 不绘制 GL_POINTS 或 GL_LINES
我正在努力开发一款仅使用程序生成的线条绘制的新 iOS 游戏。除了绘制一些图元时出现一些奇怪的问题外，一切都运行良好。我正处于需要实现文本的位置，字符被设置为数组中的一系列点。当我去绘制点(CGPo
c - OpenGL-GLSL 绘制 3D GL_LINES 顶点着色器与顶点
我正在尝试使用着色器在 OpenGL 中绘制 3D 线条...到目前为止还没有办法做到这一点。我的工作正常: void draw_bonds (int nbonds) { glDisable (
c++ - 如何使用屏幕坐标绘制 OpenGL 图元(GL_POINT、GL_LINE 等)？
我正在编写一个 OpenGL 库，它可以使用屏幕坐标绘制点、线和矩形。但是，我不知道如何将屏幕坐标转换为剪辑或相机坐标。我正在使用现代 OpenGL(顶点数组和顶点缓冲区，以及着色器)。这基本上就是
c++ - OpenGL 是否保证 GL_LINES 或 GL_LINE_STRIP 的光栅化顺序？
如果我使用 GL_LINES 或 GL_LINE_STRIP 渲染多段线，我是否可以假设具有低顶点索引的线段首先绘制到帧缓冲区？比如，当我使用顶点 v0、v1、v2 指定线带时，我是否可以假定先渲染线
c++ - OpenGL:并非所有卡都支持 GL_LINE SMOOTH；甚至不会画线，除非
首先，这段代码的目的是什么？ glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); 我可以放在那里 GL_DONT_CARE 但它不会让我画线，除非我使用 glDisable
c++ - 如何使用 glColor4f() 和 glDrawArrays(GL_LINES, 0, 2) 绘制彩色线条
我有以下程序，但我无法弄清楚为什么 glColor4f() 调用不会导致 glDrawArrays() 的输出出现红线，任何人都可以吗告诉我我做错了什么？由于某种原因正在输出一条白线。现代版本的 GL
ios - 在 iOS Open GL ES 中使用 GL_LINES 渲染对象的最小尺寸
我刚刚完成了我的 iOS 应用程序的第一个版本，Corebox ，现在正在开发一些新功能。其中一项新功能是对 OpenGL 渲染进行“小”调整，以强制某些对象永远不会被绘制为小于最小尺寸。所有需要这

太空狗

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

c - OpenGL/GLUT GL_LINES 的照明不正确