Qt学习：三维绘图之OpenGL和Qt的结合（转）

http://www.tuicool.com/articles/qAn2qq

        OpenGL是绘制三维图形的标准API。Qt应用程序可以使用QtOpenGL模块绘制三维图形，该模块依赖于系统的OpenGL库。Qt OpenGL模块提供QGLWidget类，可以通过对它子类化，并使用OpenGL命令开发出自己的窗口部件。对许多三维应用程序来说，这就足够了。 
        这节假设大家都已经学过OpenGL，这样我们就无后顾之忧了。 
        在Qt中绘制OpenGL通常需要做以下工作：1）、必须子类化QGLWidget；2）、实现几个虚函数：void initiallizeGL() 
void resizeGL(), void paintGL(), 这些都是在QGLWidget中实现的，还有一些和用户交互的虚函数，诸如void mouseMoveEvent()之类的，想必大家都比较熟了，这些虚函数是在Widget中实现的。  
         下面我们介绍一个例子。先给出该程序的效果：

 

        菜单栏里的第一项可以完成一个自定义大小的抓图，即由用户自己决定抓图的大小，抓图会显示在右侧的方框里，注意这里只能设置图形的大小小雨当前图形的尺寸， 如果大于当前图形尺寸，则钳位到当前图形尺寸。效果 看起来应该是这样：

 

        菜单栏第二项也是一个抓图功能，它返回一个当前图形尺寸的图形，并填充到右侧。 
        第三项即清除右侧图形。  
        这个代码由以下部件构成： 
        一个QMainWindow,我们通过子类化这个类来完成自己想要的一些功能。 
        一个QWidget，我们把它作为中央窗口，在其上添加自己想要的一些子部件。
        两个QScrollBar，用来盛载一个QGLWidget和一个QLabel。 
        一个QGLWidget，我们通过子类化它并把它加进一个QScrollBar来实现三维绘图，即上图所示的左边窗口。 
        一个QLabel，同样，我们把这个QLabel加进一个QScrollBar来接收抓图后的显示效果。 
        三个QSlider，我们通过这三个滑动条控制所绘制的四面体沿x,y,z轴转动，同样鼠标拖动这个四面体也可以改变滑动条的值。 
        以上是整个程序的框架。 
        以下是代码的实现部分。 

        MainWindow 类定义了我们整个程序的框架：

//mainwindow.h
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>

class QAction;
class QLabel;
class QMenu;
class QSlider;
class QScrollArea;

class GLWidget;

class MainWindow : public QMainWindow
{
    Q_OBJECT
    
public:
    MainWindow(QWidget *parent = 0);
    ~MainWindow();

private slots:
    void renderIntoPixmap();
    void grabFrameBuffer();
    void clearPixmap();
    void about();

private:

    void createMenus();
    void createActions();

    QSlider *createSlider(const char *changedSignal, const char *setterSlot);
    void setPixmap(const QPixmap &pixmap);
    QSize getSize();

    QWidget *centralWidget;
    QScrollArea *glWidgetArea;
    QScrollArea *pixmapLabelArea;
    GLWidget *glWidget;
    QLabel *pixmapLabel;
    QSlider *xSlider;
    QSlider *ySlider;
    QSlider *zSlider;

    QMenu *fileMenu;
    QMenu *helpMenu;
    QAction *renderIntoPixmapAction;
    QAction *grabFrameBufferAction;
    QAction *clearPixmapAction;
    QAction *exitAction;
    QAction *aboutAction;
    QAction *aboutQtAction;

};

#endif // MAINWINDOW_H

 

        以下是程序的实现部分：

//mainwindow.cpp
#include <QtOpenGL>
#include <QAction>
#include <QLabel>
#include <QMenu>
#include <QSlider>
#include <QScrollArea>
#include <QMenuBar>
#include <QApplication>


#include "mainwindow.h"
#include "glwidget.h"

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
    centralWidget = new QWidget;
    setCentralWidget(centralWidget);

    glWidget = new GLWidget;
    pixmapLabel = new QLabel;

    glWidgetArea = new QScrollArea;
    glWidgetArea->setWidget(glWidget);
    //glWidgetArea->viewport()->setBackgroundRole(QPalette::Dark);
    glWidgetArea->setWidgetResizable(true);
    glWidgetArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    glWidgetArea->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    glWidgetArea->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored);
    glWidgetArea->setMinimumSize(50, 50);

    pixmapLabelArea = new QScrollArea;
    pixmapLabelArea->setWidget(pixmapLabel);
    pixmapLabelArea->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored);
    pixmapLabelArea->setMinimumSize(50, 50);

    //在构造一个QSlider时将QGLWidget的信号和槽传给这个函数的形参，这样就可以在QMainWindow中
    //控制OpenGL的动作了，而让GLWidget类只完成绘图工作。
    xSlider = createSlider(SIGNAL(xRotationChanged(int)),
                           SLOT(setXRotation(int)));
    ySlider = createSlider(SIGNAL(yRotationChanged(int)),
                           SLOT(setYRotation(int)));
    zSlider = createSlider(SIGNAL(zRotationChanged(int)),
                           SLOT(setZRotation(int)));

    /*
    xSlider = new QSlider(Qt::Horizontal);
    ySlider = new QSlider(Qt::Horizontal);
    zSlider = new QSlider(Qt::Horizontal);
    */

    QGridLayout *centralLayout = new QGridLayout;
    centralLayout->addWidget(glWidgetArea, 0, 0);
    centralLayout->addWidget(pixmapLabelArea, 0, 1);
    centralLayout->addWidget(xSlider, 1, 0, 1, 2);
    centralLayout->addWidget(ySlider, 2, 0, 1, 2);
    centralLayout->addWidget(zSlider, 3, 0, 1, 2);
    centralWidget->setLayout(centralLayout);

    createActions();
    createMenus();

    xSlider->setValue(15 * 16);
    ySlider->setValue(345 * 16);
    zSlider->setValue(0 * 16);

    setWindowTitle(tr("Grabeer"));
    resize(480, 360);
}

void MainWindow::setPixmap(const QPixmap &pixmap)
{
    pixmapLabel->setPixmap(pixmap);
    QSize size = pixmap.size();
    if (size - QSize(1, 0) == pixmapLabelArea->maximumViewportSize())
        size -= QSize(1, 0);
    pixmapLabel->resize(size);
}

QSize MainWindow::getSize()
{
    bool ok;
    QString text = QInputDialog::getText(this, tr("Grabber"),
                                         tr("Enter Pixmap Size:"),
                                         QLineEdit::Normal,
                                         tr("%1 x %2").arg(glWidget->width())
                                                      .arg(glWidget->height()),
                                         &ok);
    if (!ok)
        return QSize();

    QRegExp regExp(tr("([0-9]+) *x *([0-9]+)"));
    if (regExp.exactMatch(text)) {
        int width = regExp.cap(1).toInt();
        int height = regExp.cap(2).toInt();
        if (width > 0 && width < 2048 && height > 0 && height < 2048)
             return QSize(width, height);
    }
    return glWidget->size();
}

void MainWindow::renderIntoPixmap()
{
    QSize size = getSize();
    if (size.isValid()) {
        QPixmap pixmap = glWidget->renderPixmap(size.width(), size.height());
        setPixmap(pixmap);
    }
}

void MainWindow::grabFrameBuffer()
{
    //QGLWidget有一个返回其帧缓冲区的QImage图片的函数
    QImage image = glWidget->grabFrameBuffer();
    //QPixmap的fromImage函数把一个QImage转换成QPixmap
    setPixmap(QPixmap::fromImage(image));
}

void MainWindow::clearPixmap()
{
    setPixmap(QPixmap()); //给它传一个空的对象
}

void MainWindow::about()
{
    QMessageBox::about(this, tr("About Grabber"),
             tr("The <b>Grabber</b> example demonstrates two approaches for "
                "rendering OpenGL into a Qt pixmap."));
}

QSlider *MainWindow::createSlider(const char *changedSignal,
                                  const char *setterSlot)
{
    QSlider *slider = new QSlider(Qt::Horizontal);
    slider->setRange(0, 16 * 360);
    slider->setSingleStep(16);
    slider->setPageStep(15 * 16);
    slider->setTickInterval(15 * 16);
    slider->setTickPosition(QSlider::TicksRight);

    //这种经典的用法一定要小心，报错：glWidget的槽函数在传进来的时候已经被强制转换成SLOT了，
    //所以setterSlot不用SLOT修饰；同样，changedSignal也不能再拿SIGNAL修饰
    connect(slider, SIGNAL(valueChanged(int)), glWidget, setterSlot);
    connect(glWidget, changedSignal, slider, SLOT(setValue(int)));

    return slider;
}

void MainWindow::createActions()
{
    renderIntoPixmapAction = new QAction(tr("&Render into Pixmap..."), this);
    renderIntoPixmapAction->setShortcut(tr("Ctrl+R"));
    renderIntoPixmapAction->setToolTip(tr("yes, triggerd it"));
    connect(renderIntoPixmapAction, SIGNAL(triggered()),
            this, SLOT(renderIntoPixmap()));

    grabFrameBufferAction = new QAction(tr("&Grab Frame Buffer"), this);
    grabFrameBufferAction->setShortcut(tr("Ctrl+G"));
    connect(grabFrameBufferAction, SIGNAL(triggered()),
            this, SLOT(grabFrameBuffer()));

    clearPixmapAction = new QAction(tr("&Clear Pixmap"), this);
    clearPixmapAction->setShortcut(tr("Ctrl+L"));
    connect(clearPixmapAction, SIGNAL(triggered()), this, SLOT(clearPixmap()));

    exitAction = new QAction(tr("E&xit"), this);
    exitAction->setShortcuts(QKeySequence::Quit);
    connect(exitAction, SIGNAL(triggered()), this, SLOT(close()));

    aboutAction = new QAction(tr("&About"), this);
    connect(aboutAction, SIGNAL(triggered()), this, SLOT(about()));

    aboutQtAction = new QAction(tr("About &Qt"), this);
    connect(aboutQtAction, SIGNAL(triggered()), qApp, SLOT(aboutQt()));
}

void MainWindow::createMenus()
{
    fileMenu = menuBar()->addMenu(tr("&File"));
    fileMenu->addAction(renderIntoPixmapAction);
    fileMenu->addAction(grabFrameBufferAction);
    fileMenu->addAction(clearPixmapAction);
    fileMenu->addSeparator();
    fileMenu->addAction(exitAction);

    helpMenu = menuBar()->addMenu(tr("&Help"));
    helpMenu->addAction(aboutAction);
    helpMenu->addAction(aboutQtAction);
}

MainWindow::~MainWindow()
{ 
}

        GLWidget类是整个绘图的部分，在这部分虽然用了一点Qt的东西，但我们不是非要这样使用，我们可以用整个纯净的OpengGL库来完成我们的绘制。

//glwidget.h
#ifndef GLWIDGET_H
#define GLWIDGET_H

#include <QGLWidget>

class GLWidget : public QGLWidget
{
    Q_OBJECT

public:
    explicit GLWidget(QWidget *parent = 0);

    int xRotation() const { return xRot; }
    int yRotation() const { return yRot; }
    int zRotation() const { return zRot; }

signals:
    void xRotationChanged(int angle);
    void yRotationChanged(int angle);
    void zRotationChanged(int angle);
    
public slots:
    void setXRotation(int angle);
    void setYRotation(int angle);
    void setZRotation(int angle);

protected:
    void initializeGL();
    void paintGL();
    void resizeGL(int w, int h);
    void mousePressEvent(QMouseEvent *event);
    void mouseMoveEvent(QMouseEvent *event);

private slots:
    void alwaysRotate();
    void drawTriangle();

private:
    void normalizeAngle(int *angle);

    int xRot;
    int yRot;
    int zRot;

    QColor faceColors[4];
    QPoint lastPos;
};

#endif // GLWIDGET_H

        以下是代码实现部分：

//glwidget.cpp
#include <QtGui>
#include <QtOpenGL>

#include <math.h>

#include "glwidget.h"

GLWidget::GLWidget(QWidget *parent) :
    QGLWidget(parent)
{
    xRot = 0;
    yRot = 0;
    zRot = 0;

    faceColors[0] = Qt::red;
    faceColors[1] = Qt::green;
    faceColors[2] = Qt::blue;
    faceColors[3] = Qt::yellow;

    QTimer *timer = new QTimer(this);
    connect(timer, SIGNAL(timeout()), this, SLOT(alwaysRotate()));
    timer->start(70);
}

void GLWidget::initializeGL()
{
    glClearColor(0.0, 0.2, 0.3, 1.0);
    glShadeModel(GL_SMOOTH);
    glEnable(GL_DEPTH);
}

void GLWidget::paintGL()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glPushMatrix();
    drawTriangle();
    glPopMatrix();
}

void GLWidget::resizeGL(int w, int h)
{
    int side = qMin(w, h);
    glViewport((width() - side) / 2, (height() - side) / 2, side, side);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glFrustum(-1.2, 1.2, -1.2, 1.2, 5.0, 60.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef(0.0, 0.0, -40.0);
}

void GLWidget::mousePressEvent(QMouseEvent *event)
{
    lastPos = event->pos();
}

void GLWidget::mouseMoveEvent(QMouseEvent *event)
{
    int dx = event->x() - lastPos.x();
    int dy = event->y() - lastPos.y();

    if (event->buttons() & Qt::LeftButton) {
        (xRot + 4 * dx);
        setYRotation(yRot + 4 * dy);
    } else if (event->buttons() & Qt::RightButton) {
        (xRot + 4 * dy);
        setZRotation(zRot + 4 * dx);
    }

    lastPos = event->pos();
}

void GLWidget::drawTriangle()
{
    static const GLfloat P1[3] = { 0.0, -1.0, +2.0 };
    static const GLfloat P2[3] = { +1.73205081, -1.0, -1.0 };
    static const GLfloat P3[3] = { -1.73205081, -1.0, -1.0 };
    static const GLfloat P4[3] = { 0.0, +2.0, 0.0 };

    static const GLfloat * const coords[4][3] = {
        { P1, P2, P3 }, { P1, P3, P4 }, { P1, P4, P2 }, { P2, P4, P3 }
    };

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef(0.0, 0.0, -10.0);
    glRotatef(xRot, 1.0, 0.0, 0.0);
    glRotatef(yRot, 0.0, 1.0, 0.0);
    glRotatef(zRot, 0.0, 0.0, 1.0);

    for (int i = 0; i != 4; ++i) {
        //glLoadName(i);
        glBegin(GL_TRIANGLES);
        qglColor(faceColors[i]);
        for (int j = 0; j < 3; ++j) {
            glVertex3f(coords[i][j][0], coords[i][j][1],
                       coords[i][j][2]);
        }
        glEnd();
    }
}

void GLWidget::normalizeAngle(int *angle)
{
    while (*angle < 0)
        angle += 360 * 16;
    while (*angle > 360 *16)
        angle -= 360 *16;
}

void GLWidget::setXRotation(int angle)
{
    normalizeAngle(&angle);
    if ( angle != xRot ) {
        xRot = angle;
        emit xRotationChanged(angle);
        updateGL();
    }
}

void GLWidget::setYRotation(int angle)
{
    normalizeAngle(&angle);
    if ( angle != yRot ) {
        yRot = angle;
        emit yRotationChanged(angle);
        updateGL();
    }
}

void GLWidget::setZRotation(int angle)
{
    normalizeAngle(&angle);
    if ( angle != zRot ) {
        zRot = angle;
        emit zRotationChanged(angle);
        updateGL();
    }
}

void GLWidget::alwaysRotate()
{
    zRot += 2;
    emit zRotationChanged(zRot);
    updateGL();
}

 

         至此，我们就完成了整个应用程序的编写，继续努力。