#include "Vector3f.h"

#include <cmath>

Vector3f::Vector3f(float x, float y, float z) {

    this->x = x;

    this->y = y;

    this->z = z;

}

Vector3f Vector3f::crossProduct(const Vector3f &v) {

    float nx = y * v.z - z * v.y; // y->z

    float ny = z * v.x - x * v.z; // z->x

    float nz = x * v.y - y * v.x; // x->y

    return Vector3f(nx, ny, nz);

}

/**

  * Given three points in the order counter-clockwise.

  */

Vector3f calculateNormal(const Point3f &p1, const Point3f &p2, const Point3f &p3) {

    Vector3f vector1(p2.x - p1.x, p2.y - p1.y, p2.z - p1.z);

    Vector3f vector2(p3.x - p1.x, p3.y - p1.y, p3.z - p1.z);

    return vector1.crossProduct(vector2);

}

Vector3f normalize(const Vector3f &v) {

    float length = sqrt(v.x * v.x + v.y * v.y + v.z * v.z);

    if (length >= -0.001f && length <= 0.001f) {

        return Vector3f(0.0f, 0.0f, 0.0f);

    }

    return Vector3f(v.x / length, v.y / length, v.z / length);

}

如果是给组成物体的每个小平面都指定一条法线的话, 最后使用光照后得到的物体表面是faceted jewel(像有小面的珠宝似的), 使得物体表面不是平滑的. 解决这个问题的办法是给每个顶点指点一条法线, 而不是给每个小平面指定法线: 先计算每个小平面的法线. 然后再用这些面的法线来计算顶点的法线:

共享有这个顶点的所有小平面的法线的平均值就是这个顶点的法线(近似).

#ifndef GLWIDGET_H

#define GLWIDGET_H

#include <QtOpenGL/QGLWidget>

class GLWidget : public QGLWidget {

    Q_OBJECT

public:

    GLWidget(QWidget *parent = 0);

    ~GLWidget();

protected:

    virtual void initializeGL();

    virtual void resizeGL(int w, int h);

    virtual void paintGL();

    virtual void hideEvent(QHideEvent *event);

    virtual void showEvent(QShowEvent *event);

    virtual void timerEvent(QTimerEvent *event);

    virtual void mousePressEvent(QMouseEvent *event);

    virtual void mouseMoveEvent(QMouseEvent *event);

    virtual void mouseReleaseEvent(QMouseEvent *event);

    virtual void wheelEvent(QWheelEvent *event);

private:

    int     timerId;

    QPoint  lastPos;

    GLfloat rotateX;

    GLfloat rotateY;

    GLfloat rotateZ;

    GLfloat zoom;

    void drawCube(GLfloat factorX = 1, GLfloat factorY = 1,

                  GLfloat factorZ = 1, GLfloat w = 1);

    void drawCone(GLfloat radius = 1.0f, GLfloat height = 1,

                  GLuint steps = 18);

};

#endif // GLWIDGET_H

==================================[GLWidget.cpp]==================================

#include "GLWidget.h"

#include <qDebug>

#include <QTimerEvent>

#include <QMouseEvent>

#include <cmath>

GLWidget::GLWidget(QWidget *parent)

    : QGLWidget(parent) {

    setFormat(QGLFormat(QGL::DoubleBuffer | QGL::DepthBuffer));

    rotateX = 0.0f;

    rotateY = 0.0f;

    rotateZ = 0.0f;

    zoom = 1.0f;

}

GLWidget::~GLWidget() {

}

void GLWidget::hideEvent(QHideEvent *event) {

    this->killTimer(this->timerId);

}

void GLWidget::showEvent(QShowEvent *event) {

    this->timerId = this->startTimer(500);

}

void GLWidget::timerEvent(QTimerEvent *event) {

    if (event->timerId() == this->timerId) {

    } else {

        QGLWidget::timerEvent(event);

    }

}

void GLWidget::mousePressEvent(QMouseEvent *event) {

    if (Qt::LeftButton == event->button()) {

        lastPos = event->pos();

    } else if (Qt::RightButton == event->button()) {

        lastPos = event->pos();

    }

}

void GLWidget::mouseMoveEvent(QMouseEvent *event) {

    if (Qt::LeftButton & event->buttons()) {

        GLfloat dx = event->pos().x() - lastPos.x();

        GLfloat dy = event->pos().y() - lastPos.y();

        rotateX += dy;

        rotateY += dx;

        updateGL();

        //qDebug() << QString("RotateX:%1, RotateY:%2").arg(rotateX).arg(rotateY);

    } else if (Qt::RightButton & event->buttons()) {

        GLfloat dz = event->pos().y() - lastPos.y();

        dz *= 0.01f;

        zoom += dz;

        updateGL();

    }

    lastPos = event->pos();

}

void GLWidget::mouseReleaseEvent(QMouseEvent *event) {

}

void GLWidget::wheelEvent(QWheelEvent *event) {

    GLfloat degrees = event->delta();

    zoom -= degrees * 0.0002f;

    // 注意, 如果zoom为负值, eye就会被放置到z轴的负方向, 而从物体的背面看了.

    if (zoom < 1.0f) {

        zoom = 1.0f;

    }

    updateGL();

}

///////////////////////////////////////////////////////////////////////////////

//                               Opengl Code

///////////////////////////////////////////////////////////////////////////////

void GLWidget::initializeGL() {

    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

    glEnable(GL_DEPTH_TEST);

    glFrontFace(GL_CCW);

    //glEnable(GL_CULL_FACE);

    glCullFace(GL_BACK);

    glShadeModel(GL_SMOOTH);

    // Point size

    // glPointSize(GLfloat size);

    GLfloat sizes[2];

    GLfloat step;

    glGetFloatv(GL_LINE_WIDTH_RANGE, sizes);

    glGetFloatv(GL_LINE_WIDTH_GRANULARITY, &step);

}

void GLWidget::resizeGL(int w, int h) {

    glViewport(0, 0, w, h);

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    gluPerspective(75, (GLdouble)w / h, 0.1, 100);

    glMatrixMode(GL_MODELVIEW);

    glLoadIdentity();

}

void GLWidget::paintGL() {

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glLoadIdentity();

    //glTranslatef(0.0f, 0.0f, zoom);

    gluLookAt(0.0f, 0.0f, zoom, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);

    glRotatef(rotateX, 1, 0, 0);

    glRotatef(rotateY, 0, 1, 0);

    glRotatef(rotateZ, 0, 0, 1);

    // Real draw code.

    //glColor3f(1.0f, 0.0f, 0.0f);

    //drawCube(1, 1, 1, 1);

    glPolygonMode(GL_BACK, GL_LINE);

    drawCone(1.0f, 1.50, 48);

}

void GLWidget::drawCube(GLfloat factorX, GLfloat factorY,

                        GLfloat factorZ, GLfloat w) {

    GLfloat x = factorX * 0.5f;

    GLfloat y = factorY * 0.5f;

    GLfloat z = factorZ * 0.5f;

    // x / w, y / w, z / w

    // 前左下, 前右下, 前右上, 前左上: p0, p1, p2, p3

    // 后左下, 后右下, 后右上, 后左上: p4, p5, p6, p7

    GLfloat p0[4] = {-x, -y, z, w};

    GLfloat p1[4] = {x, -y, z, w};

    GLfloat p2[4] = {x, y, z, w};

    GLfloat p3[4] = {-x, y, z, w};

    GLfloat p4[4] = {-x, -y, -z, w};

    GLfloat p5[4] = {x, -y, -z, w};

    GLfloat p6[4] = {x, y, -z, w};

    GLfloat p7[4] = {-x, y, -z, w};

    // 开始绘制Cube的六个面: 逆时针

    glBegin(GL_QUADS);

    // 前面: p0, p1, p2, p3

    glVertex4fv(p0);

    glVertex4fv(p1);

    glVertex4fv(p2);

    glVertex4fv(p3);

    // 右面: p1, p5, p6, p2

    glVertex4fv(p1);

    glVertex4fv(p5);

    glVertex4fv(p6);

    glVertex4fv(p2);

    // 后面: p5, p4, p7, p6

    glVertex4fv(p5);

    glVertex4fv(p4);

    glVertex4fv(p7);

    glVertex4fv(p6);

    // 左右: p4, p0, p3, p7

    glVertex4fv(p4);

    glVertex4fv(p0);

    glVertex4fv(p3);

    glVertex4fv(p7);

    // 上面: p2, p6, p7, p3

    glVertex4fv(p2);

    glVertex4fv(p6);

    glVertex4fv(p7);

    glVertex4fv(p3);

    // 下面: p0, p4, p5, p1

    glVertex4fv(p0);

    glVertex4fv(p4);

    glVertex4fv(p5);

    glVertex4fv(p1);

    glEnd();

}

void GLWidget::drawCone(GLfloat radius, GLfloat height,

                        GLuint steps) {

    const GLfloat GL_PI = 3.1415f;

    GLfloat angles = 2 * GL_PI / steps;

    GLfloat vertices[steps][3];

    for (int i = 0; i < steps; ++i) {

        vertices[i][0] = radius * cos(i * angles);

        vertices[i][1] = radius * sin(i * angles);

        vertices[i][2] = 0;

    }

    // top surface

    glBegin(GL_TRIANGLE_FAN);

        glColor3f(0.0f, 0.0f, 1.0f);

        glVertex3f(0.0f, 0.0f, height);

        for (int i = 0; i < steps; ++i) {

            glVertex3fv(vertices[i]);

            if ((i & 1) == 0) {

                glColor3f(1.0f, 0.0f, 0.0f);

            } else {

                glColor3f(0.0f, 0.0f, 1.0f);

            }

        }

        glVertex3fv(vertices[0]);

    glEnd();

    // bottom surface

    glBegin(GL_TRIANGLE_FAN);

        glVertex3f(0.0f, 0.0f, 0);

        for (int i = steps - 1; i >= 0; --i) {

            glVertex3fv(vertices[i]);

            if ((i & 1) == 0) {

                glColor3f(0.0f, 1.0f, 0.0f);

            } else {

                glColor3f(1.0f, 0.0f, 1.0f);

            }

        }

        glVertex3fv(vertices[steps - 1]);

    glEnd();

}

translucent objects. First you draw all the opaque objects, with the depth buffer in normal operation. 

Then, you preserve these depth values by making the depth buffer read-only. When the translucent 

objects are drawn, their depth values are still compared to the values established by the opaque objects, 

so they aren't drawn if they're behind the opaque ones. If they're closer to the viewpoint, however, they 

don't eliminate the opaque objects, since the depth-buffer values can't change. Instead, they're blended 

with the opaque objects. To control whether the depth buffer is writable, use glDepthMask(); if you 

pass GL_FALSE as the argument, the buffer becomes read-only, whereas GL_TRUE restores the 

normal, writable operation. 

void GLWidget::paintGL() {

glLoadIdentity();

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

gluLookAt(0, 0, 8, 0, 0, 0, 0, 1, 0);

glPushMatrix();

{

glColor3f(1.0, 0.0f, 0.0f);

glTranslatef(0.0f, 0.0f, -1.0f);

this->drawCube(1.0f, 1.0f, 1.0f, 0.1f);

}

glPopMatrix();

glPushMatrix();

{

glColor3f(0.0, 0.0f, 1.0f);

glTranslatef(0.60f, 0.0f, -0.5f);

this->drawCube(1.0f, 1.0f, 1.0f, 0.1f);

}

glPopMatrix();

glPushMatrix();

{

glEnable(GL_BLEND);

glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

glDepthMask(GL_FALSE);

glColor4f(0.0, 1.0f, 0.0f, 0.5f);

glTranslatef(0.20f, 0.0f, 0.0f);

this->drawCube(0.60f, 1.0f, 1.0f, 0.1f);

glDepthMask(GL_TRUE);

glDisable(GL_BLEND);

}

glPopMatrix();

}

void GLWidget::drawCube(GLfloat len, GLfloat xFactor, GLfloat yFactor,

GLfloat zFactor) {

GLfloat x = len * xFactor / 2;

GLfloat y = len * yFactor / 2;

GLfloat z = len * zFactor / 2;

// GLfloat p0[3] = { -x, -y, -z };

// GLfloat p1[3] = { x, -y, -z };

// GLfloat p2[3] = { x, y, -z };

// GLfloat p3[3] = { -x, y, -z };

// GLfloat p4[3] = { -x, -y, z };

// GLfloat p5[3] = { x, -y, z };

// GLfloat p6[3] = { x, y, z };

// GLfloat p7[3] = { -x, y, z };

glBegin(GL_QUADS);

{

// Draw left surface.

glNormal3f(-1.0f, 0.0f, 0.0f);

glVertex3f(-x, y, -z);

glVertex3f(-x, -y, -z);

glVertex3f(-x, -y, z);

glVertex3f(-x, y, z);

// Draw front surface.

glNormal3f(0.0f, 0.0f, 1.0f);

glVertex3f(-x, -y, z);

glVertex3f(x, -y, z);

glVertex3f(x, y, z);

glVertex3f(-x, y, z);

// Draw right surface.

glNormal3f(1.0f, 0.0f, 0.0f);

glVertex3f(x, -y, z);

glVertex3f(x, -y, -z);

glVertex3f(x, y, -z);

glVertex3f(x, y, z);

// Draw back surface.

glNormal3f(0.0f, 0.0f, -1.0f);

glVertex3f(x, y, -z);

glVertex3f(x, -y, -z);

glVertex3f(-x, -y, -z);

glVertex3f(-x, y, -z);

// Draw top surface.

glNormal3f(0.0f, 1.0f, 0.0f);

glVertex3f(x, y, z);

glVertex3f(x, y, -z);

glVertex3f(-x, y, -z);

glVertex3f(-x, y, z);

// Draw bottom surface.

glNormal3f(0.0f, -1.0f, 0.0f);

glVertex3f(-x, -y, -z);

glVertex3f(x, -y, -z);

glVertex3f(x, -y, z);

glVertex3f(-x, -y, z);

}

glEnd();

// glBegin(GL_QUADS);

// {

// // Draw left surface.

// glNormal3f(-1.0f, 0.0f, 0.0f);

// glVertex3fv(p3);

// glVertex3fv(p0);

// glVertex3fv(p4);

// glVertex3fv(p7);

//

// // Draw front surface.

// glNormal3f(0.0f, 0.0f, 1.0f);

// glVertex3fv(p4);

// glVertex3fv(p5);

// glVertex3fv(p6);

// glVertex3fv(p7);

//

// // Draw right surface.

// glNormal3f(1.0f, 0.0f, 0.0f);

// glVertex3fv(p5);

// glVertex3fv(p1);

// glVertex3fv(p2);

// glVertex3fv(p6);

//

// // Draw back surface.

// glNormal3f(0.0f, 0.0f, -1.0f);

// glVertex3fv(p2);

// glVertex3fv(p1);

// glVertex3fv(p0);

// glVertex3fv(p3);

//

// // Draw top surface.

// glNormal3f(0.0f, 1.0f, 0.0f);

// glVertex3fv(p6);

// glVertex3fv(p2);

// glVertex3fv(p3);

// glVertex3fv(p7);

//

// // Draw bottom surface.

// glNormal3f(0.0f, -1.0f, 0.0f);

// glVertex3fv(p0);

// glVertex3fv(p1);

// glVertex3fv(p5);

// glVertex3fv(p4);

// }

// glEnd();

}