Hello GL Example

QtLogo Class

This class encapsulates the OpenGL geometry data which will be rendered in the basic 3D scene.

 class QtLogo : public QObject
 {
 public:
     QtLogo(QObject *parent, int d = 64, qreal s = 1.0);
     ~QtLogo();
     void setColor(QColor c);
     void draw() const;
 private:
     void buildGeometry(int d, qreal s);

     QList<Patch *> parts;
     Geometry *geom;
 };

The geometry is divided into a list of parts which may be rendered in different ways. The data itself is contained in a Geometry structure that includes the vertices, their lighting normals and index values which point into the vertices, grouping them into faces.

 struct Geometry
 {
     QVector<GLushort> faces;
     QVector<QVector3D> vertices;
     QVector<QVector3D> normals;
     void appendSmooth(const QVector3D &a, const QVector3D &n, int from);
     void appendFaceted(const QVector3D &a, const QVector3D &n);
     void finalize();
     void loadArrays() const;
 };

The data in the Geometry class is stored in QVector<QVector3D> members which are convenient for use with OpenGL because they expose raw contiguous floating point values via the constData() method. Methods are included for adding new vertex data, either with smooth normals, or facetted normals; and for enabling the geometry ready for rendering.

 class Patch
 {
 public:
     enum Smoothing { Faceted, Smooth };
     Patch(Geometry *);
     void setSmoothing(Smoothing s) { sm = s; }
     void translate(const QVector3D &t);
     void rotate(qreal deg, QVector3D axis);
     void draw() const;
     void addTri(const QVector3D &a, const QVector3D &b, const QVector3D &c, const QVector3D &n);
     void addQuad(const QVector3D &a, const QVector3D &b,  const QVector3D &c, const QVector3D &d);

     GLushort start;
     GLushort count;
     GLushort initv;

     GLfloat faceColor[4];
     QMatrix4x4 mat;
     Smoothing sm;
     Geometry *geom;
 };

The higher level Patch class has methods for accumulating the geometry one face at a time, and treating collections of faces or "patches" with transformations, applying different colors or smoothing. Although faces may be added as triangles or quads, at the OpenGL level all data is treated as triangles for compatibility with OpenGL/ES.

 void Patch::draw() const
 {
     glPushMatrix();
     qMultMatrix(mat);
     glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, faceColor);

     const GLushort *indices = geom->faces.constData();
     glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_SHORT, indices + start);
     glPopMatrix();
 }

Drawing a Patch is simply acheived by applying any transformation, and material effect, then drawing the data using the index range for the patch. The model-view matrix is saved and then restored so that any transformation does not affect other parts of the scene.

 void QtLogo::buildGeometry(int divisions, qreal scale)
 {
     qreal cw = cross_width * scale;
     qreal bt = bar_thickness * scale;
     qreal ld = logo_depth * scale;
     qreal th = tee_height *scale;

     RectPrism cross(geom, cw, bt, ld);
     RectPrism stem(geom, bt, th, ld);

     QVector3D z(0.0, 0.0, 1.0);
     cross.rotate(45.0, z);
     stem.rotate(45.0, z);

     qreal stem_downshift = (th + bt) / 2.0;
     stem.translate(QVector3D(0.0, -stem_downshift, 0.0));

     RectTorus body(geom, 0.20, 0.30, 0.1, divisions);

     parts << stem.parts << cross.parts << body.parts;

     geom->finalize();
 }

The geometry is built once on construction of the QtLogo, and it is paramaterized on a number of divisions - which controls how "chunky" the curved section of the logo looks - and on a scale, so larger and smaller QtLogo objects can be created without having to use OpenGL scaling (which would force normal recalculation).

The building process is done by helper classes (read the source for full details) which only exist during the build phase, to assemble the parts of the scene.

 void QtLogo::draw() const
 {
     geom->loadArrays();

     glEnableClientState(GL_VERTEX_ARRAY);
     glEnableClientState(GL_NORMAL_ARRAY);

     for (int i = 0; i < parts.count(); ++i)
         parts[i]->draw();

     glDisableClientState(GL_VERTEX_ARRAY);
     glDisableClientState(GL_NORMAL_ARRAY);
 }

Finally the complete QtLogo scene is simply drawn by enabling the data arrays and then iterating over the parts, calling draw() on each one.

 class GLWidget;

 class Window : public QWidget
 {
     Q_OBJECT

 public:
     Window();

 protected:
     void keyPressEvent(QKeyEvent *event);

 private:
     QSlider *createSlider();

     GLWidget *glWidget;
     QSlider *xSlider;
     QSlider *ySlider;
     QSlider *zSlider;
 };

 Window::Window()
 {
     glWidget = new GLWidget;

     xSlider = createSlider();
     ySlider = createSlider();
     zSlider = createSlider();

     connect(xSlider, SIGNAL(valueChanged(int)), glWidget, SLOT(setXRotation(int)));
     connect(glWidget, SIGNAL(xRotationChanged(int)), xSlider, SLOT(setValue(int)));
     connect(ySlider, SIGNAL(valueChanged(int)), glWidget, SLOT(setYRotation(int)));
     connect(glWidget, SIGNAL(yRotationChanged(int)), ySlider, SLOT(setValue(int)));
     connect(zSlider, SIGNAL(valueChanged(int)), glWidget, SLOT(setZRotation(int)));
     connect(glWidget, SIGNAL(zRotationChanged(int)), zSlider, SLOT(setValue(int)));

     QHBoxLayout *mainLayout = new QHBoxLayout;
     mainLayout->addWidget(glWidget);
     mainLayout->addWidget(xSlider);
     mainLayout->addWidget(ySlider);
     mainLayout->addWidget(zSlider);
     setLayout(mainLayout);

     xSlider->setValue(15 * 16);
     ySlider->setValue(345 * 16);
     zSlider->setValue(0 * 16);
     setWindowTitle(tr("Hello GL"));
 }

 QSlider *Window::createSlider()
 {
     QSlider *slider = new QSlider(Qt::Vertical);
     slider->setRange(0, 360 * 16);
     slider->setSingleStep(16);
     slider->setPageStep(15 * 16);
     slider->setTickInterval(15 * 16);
     slider->setTickPosition(QSlider::TicksRight);
     return slider;
 }