Работа с OpenGL на Qt 4 (часть 1)

Материал из Wiki.crossplatform.ru

Версия 08:51, 25 января 2011

Это ознакомительная статья, посвящённая программированию 3D-графики OpenGL (Open Graphics Library — открытая графическая библиотека) с помощью кроссплатформенной библиотеки Qt4 (Q и Trolltech — красивое название). Я надеюсь, она окажется полезной для тех, кто впервые решил познакомиться с OpenGL и выбирает практичную и удобную библиотеку GUI (Graphical User Interface — графический интерфейс пользователя).

Введение

Возможности библиотеки Qt далеко выходят за рамки разработки GUI и она считается одной из самых успешных библиотек для разработки кроссплатформенных приложений для различных целей. Конечно же, статья направлена на популяризацию Qt как API (Application Programming Interface — интерфейс прикладного программирования) для создания трёхмерной графики. Поэтому эта статья также окажется полезной для профессиональных программистов OpenGL, незнакомых с возможностями Qt4, и программистов Qt, не работавших с OpenGL. От читателя потребуется знание языка C++. Изложение будет построено таким образом: сначала мы рассмотрим основы вместе с примерами — кусками кода. И в конце будет написана обобщающая всё сказанное программа.

Модуль QtOpenGL

Библиотека Qt4 имеет специальный модуль для работы с OpenGL — QtOpenGL. Модуль QtOpenGL реализован как платформонезависимый Qt/C++ упаковщик (стандартизация внешних обращений) над платформозависимыми GLX (OpenGL в Linux), WGL (OpenGL в Windows) или AGL (OpenGL в MacOS) API. Функциональность модуля QtOpenGL очень схожа с библиотекой GLUT, но при этом вам предоставляются все возможности Qt, которые несвязаны с OpenGL. В модуле QtOpenGL содержатся следующие классы: QGLColormap, QGLContext,QGLFormat, QGLFramebufferObject, QGLPixelBuffer, QGLWidget, QWSGLWindowSurface.

Классы подключаются стандартным образом:

#include <QGLWidget> // подключаем класс QGLWidget
#include <QtOpenGL>  // подключаем весь модуль QtOpenGL, он уже содержит класс QGLWidget

Класс QGLWidget

Рассмотрим класс QGLWidget вместе с наиболее важными функциями-членами и слотами-членами этого класса.

Класс:

QGLWidget

Конструктор класса:

QGLWidget::QGLWidget(QWidget* pwgt = 0) // конструктор класса, создает объект класса

Функции-члены класса (protected):

virtual void QGLWidget::initializeGL() // устанавливает начальные значения
 
virtual void QGLWidget::resizeGL(int width, int height) // отвечает за изменение размеров окна виджета
 
virtual void QGLWidget::paintGL() // рисует изображение

Слот-член класса (public):

virtual void QGLWidget::updateGL() // вызывает обновление изображения

Выполнение функций происходит по следующей схеме: (запуск приложения)->(конструктор виджета)->initializeGL()->resizeGL()->paintGL() (изменение окна)->resizeGL()->paintGL() updateGL()->paintGL()

Более полную и подробную информацию о классе QGLWidget можно найти в справке Qt Assistant, который всегда поставляется с Qt. Аргументом конструктора класса является указатель на объект класса QWidget. Класс QWidget обеспечивает работу с виджетами (интерфейсными элементами окна), а класс QGLWidget унаследован от QWidget и осуществляет связь виджетов и OpenGL. Значение *pwgt=0 указывает, что виджет будет главным окном. Пример:

#include <QGLWidget>  // подключаем класс QGLWidget
 
class Scene3D : public QGLWidget // новый класс Scene3D наследует встроенный класс QGLWidget
{ 
   private: 
      //... 
 
   protected:
      /*virtual*/ void initializeGL();                    // метод для проведения инициализаций, связанных с OpenGL 
      /*virtual*/ void resizeGL(int nWidth, int nHeight); // метод вызывается при изменении размеров окна
      /*virtual*/ void paintGL();                         // метод, чтобы заново перерисовать содержимое виджета
 
   public: 
      Scene3D(QWidget* pwgt = 0) ; // конструктор класса Scene3D
};
 
 
Scene3D::Scene3D(QWidget* pwgt/*= 0*/) : QGLWidget(pwgt) // конструктор класса Scene3D 
{ 
   // передает дальше указатель pwgt 
}

Функции initializeGL(), resizeGL(), paintGL() являются виртуальными функциями (подробнее о динамическом полиморфизме можно прочитать, например, в книге: Аверкин В.П., Бобровский А.И., Веснич В.В., Радушинский В.Ф., Хомоненко А.Д. «Программирование на C++»). Следовательно, в классе-наследнике Scene3D обозначать функции как virtual ненужно.

Инициализация OpenGL

Функция initializeGL() вызывается только один раз в начале выполнения программы. Судя по названию, в теле этой функции вы можете провести какую-либо инициализацию, т.е. установить некоторые начальные значения. Разумеется, инициализацию можно провести где-то в другом месте, но разумнее инициализацию провести именно в этой функции. И, конечно же, можно изменять первоначальные настройки в любом удобном для этого месте. Пример:

#include <QtOpenGL>  // заранее подключили весь модуль QtOpenGL
 
//...
 
/*virtual*/ void Scene3D::initializeGL() // инициализация
{
   qglClearColor(Qt::white); // цвет для очистки буфера изображения - здесь просто фон окна
   glEnable(GL_DEPTH_TEST);  // устанавливает режим проверки глубины объектов
   // glShadeModel(GL_FLAT); // отключает режим сглаживания цветов
   glEnable(GL_CULL_FACE);   // устанавливается режим, когда строятся только внешние поверхности
}

Обратим внимание на первую команду qglClearColor(Qt::white), которая принадлежит классу QGLWidget. В OpenGL она эквивалентна glClearColor(1.0f, 1.0f, 1.0f, 1.0f), которая устанавливает цвет RGBA для очистки окна. Конечно же, вместо qglClearColor(Qt::white) можно использовать glClearColor(1.0f, 1.0f, 1.0f, 1.0f), и выбор определяется удобством и остаётся за вами. Аргументом функции qglClearColor() является значение типа QColor. Это также встроенный класс Qt, как можно догадаться из приставки Q. Особенность его в том, что он соответствует цветам в OS Windows от 0 до 255. Пример:

#include <QtGui> // подключаем модуль QtGui, он содержит класс QColor
 
//...
 
QColor burmaline(195, 155, 175, 255); // бурмалиновый цвет, последний аргумент прозрачность

В соответствии с правилами обозначения в OpenGL значение 1.0f обрабатывается как тип GLfloat (собственный тип OpenGL). Зачем нужны собственные типы? Дело в том, что различные компиляторы и платформы по-разному распределяют память под стандартные типы и программист должен всегда это держать в уме. Собственные типы OpenGL обрабатываются везде одинаково и освобождают нас от этого обременительного занятия.

Следующая функция glEnable(GL_DEPTH_TEST) является уже функцией OpenGL, что можно понять из приставки gl в отличие от qgl для первой функции. glEnable(GL_DEPTH_TEST) устанавливает режим проверки глубины объектов, известных также как z-буфер (z-buffer) или буфер глубины. Суть его заключается в том, что каждому пикселю на экране с координатами x и y даётся еще координата z, характеризующая расстояние до наблюдателя. Таким образом, одни объекты могут быть ближе к нам, а другие дальше, а значит, ближние объекты могут закрыть собой дальние. Зачем рисовать дальние объекты, если они невидны? Правильно, незачем! Поэтому нужно иметь метод, чтобы не рисовать скрытые (невидимые) поверхности. Как раз это и выполняет glEnable(GL_DEPTH_TEST). Также нужно будет сообщить системе об использовании буфера глубины.

Закомментированная функция glShadeModel(GL_FLAT) отключает режим сглаживания цветов, который всегда установлен по умолчанию. Если вершины имеют разный цвет, то цвет между ними будет плавно переходить из одного в другой. Отключать режим сглаживания нет необходимости, поэтому функция закомментирована и не используется.

OpenGL использует следующие простые геометрические построения — примитивы: точка, линия, треугольник (чаще всего), четырёхугольник, многоугольник (реже всего). Например, когда рисуется треугольник, рисуются его внешняя и внутренняя поверхности. Но часто бывает так, что внутренние поверхности рисовать ненужно, так как мы их никогда не увидим. Для этого используется команда glEnable(GL_CULL_FACE) и в результате её исполнения рисуются только внешние поверхности. Как можно догадаться, это повышает быстродействие рисования, так как теперь видеокарта рисует изображение в два раза меньше. Какая поверхность внешняя, а какая внутренняя определяется с помощью последовательности её вершин — закручивание по правилу правого винта (обход вершин по часовой стрелке).

Настройки окна виджета

Рассмотрим следующую функцию resizeGL(), определенную в Qt. Эта функция вызывается первый раз после initializeGL() и каждый раз автоматически, когда происходит изменение размеров окна. Как вы догадываетесь параметры width и height типа int и есть ширина и высота окна виджета в пикселях, которые отсчитывается от самой верхней левой точки виджета. Эти параметры передаются в функцию resizeGL() автоматически при ее вызове. Очевидно, в её теле требуется задавать настройки, связанные с размером виджета. Пример:

/*virtual*/ void Scene3D::resizeGL(int nWidth, int nHeight) // окно виджета
{ 
   glMatrixMode(GL_PROJECTION); // устанавливает текущей проекционную матрицу
   glLoadIdentity();            // присваивает проекционной матрице единичную матрицу
 
   // мировое окно
   glOrtho(-1.0, 1.0, -1.0, 1.0, -10.0, 1.0);     // параметры видимости ортогональной проекции
   // плоскости отсечения (левая, правая, верхняя, нижняя, передняя, задняя)
   // glFrustum(-1.0, 1.0, -1.0, 1.0, 1.0, 10.0); // параметры видимости перспективной проекции
   // плоскости отсечения: (левая, правая, верхняя, нижняя, ближняя, дальняя)
 
   // поле просмотра                                              
   glViewport(0, 0, (GLint)nWidth, (GLint)nHeight); // устанавливает видовое окно с размерами равными окну виджета
}

Последовательные команды glMatrixMode(GL_PROJECTION) и glLoadIdentity() загружают единичную матрицу в матрицу проекции. Необходимо знать, что любые преобразования с матрицами не сбрасываются, а аддитивно накапливаются. Поэтому необходимо каждый раз возвращать первоначальные матрицы, в которых не произведено никаких преобразований. С этой цель единичная матрица и загружается в текущую матрицу (проекции), т.к. единичная матрица соответствует матрице без преобразований. Если не отменять преобразования, то следующее преобразование будет совершаться уже относительно предыдущего.

Команда glOrtho() означает, что проекция является ортогональной (также ортографической, ортонормальной), в отличие от перспективной проекции, задающейся командой glFrustum(). В перспективной проекции чем дальше объекты находятся от наблюдателя, тем они рисуются меньше, а в ортогональной нет эффекта удаления. Аргументами функции glOrtho() являются плоскости отсечения: левая, правая, верхняя, нижняя, передняя, задняя. Для функции glFrustum() плоскости отсечения: левая, правая, верхняя, нижняя, ближняя, дальняя; при этом наблюдатель находится в точке (0, 0, 0) и расстояния до ближней и дальней плоскостей должно быть положительным. Обратите внимание, что аргументы функции обозначены не 10.0f, а просто 10.0. По умолчанию такие значения относятся к GLdouble.

Функция glViewport(0, 0, (GLint)nWidth, (GLint)nHeight) определяет поле просмотра (порт просмотра) внутри окна в пикселях экрана и образует прямоугольник с левой нижней точкой (0, 0) и правой верхней точкой (nWidth, nHeight). В этом поле и будет всё рисоваться. Для нас важно, что прямоугольник поля просмотра совпадает с прямоугольником виджета окна. Так как nWidth и nHeight типа int, стоит произвести преобразования к типам GLint.

Часто новички, задавшие первоначальные значения одинаковых ширин и высот, недоумевают почему их изображение растягивается по ширине при развертывании окна на весь экран. Ничего удивительного в этом нет - ширина становится больше по значению чем высота. И OpenGL автоматически масштабирует всю проекцию сцены так, что она становится вытянутой по координате y экрана. Чуть позже в заключительном листинге обобщающей программы будет показано, как этого избежать и "сохранить квадрат квадратным". Также необходимо помнить, что отсчёт координаты y на экране производиться по-разному: из самой нижней точки вверх в OpenGL и из самой верхней точки вниз в экранных координатах в OS Windows.

Построение изображения в OpenGL происходит по следующему принципу: (мировые координаты)-->(мировое окно)-->(поле просмотра).

Вывод изображения

Следующая рассматриваемая функция Qt - paintGL() - вызывает рисование сцены и выполняется первый раз после resizeGL() и каждый раз после функции вызова updateGL(). Пример:

Первая закомментированная команда glClear(GL_COLOR_BUFFER_BIT) очищает окно цветом RGBA, который выбран командами qglClearColor(Qt::white) или glClearColor(1.0f, 1.0f, 1.0f, 1.0f) (в данном случае белый цвет). Если в инициализации initializeGL() установлена проверка глубины glEnable(GL_DEPTH_TEST), то можно очистить буфер цвета и глубины вместе glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT).

Команды glMatrixMode(GL_MODELVIEW) и glLoadIdentity() загружают единичную матрицу в матрицу моделирования (имеются также переводы модельно-видовая матрица), аналогично как это говорилось выше о матрице проекции. Матрица моделирования отвечает за наблюдение сцены; а матрица проекции за проецирование сцены, которое может быть либо ортогональным, либо перспективным.

Далее приведены последовательные преобразования: поворот, трансляция, масштабирование. Значения (GLfloat) xRot, yRot, zRot, xTra, yTra, zTra, xSca, ySca, zSca удобно определить как private данные-члены класса и задать им начальные значения в теле конструктора класса. Как вы догадались, это углы поворота вокруг трёх осей, величины трансляции и масштабирования. Особенность углов поворота в том, что они задаются в градусах, а не в радианах. Функция glRotatef() осуществляет поворот наблюдателя на заданный угол вокруг заданной оси. Соответственно, функции glTranslatef() и glScalef() производят трансляцию сцены и масштабирование. Важно напомнить ещё раз, что любое преобразование изменяет текущие матрицы. И следующее преобразование осуществляется относительно предыдущего. Поэтому операции (поворот->трансляция) и (трансляция->поворот) приводят к разным результатам; операции (поворот1->поворот2) и (поворот2->поворот1) также могут привести к разным конечным преобразованиям. Все эти преобразования в итоге изменяют матрицу моделирования от единичной. Именно поэтому необходимо при перерисовании сцены загружать единичную матрицу, после чего будут осуществляться указанные преобразования над ней. К тому же вы можете загружать матрицы, сделанные "своими руками".

Теперь можно полностью представить, как происходит долгий путь построения изображения в OpenGL: (мировые координаты)--> ... -->(координаты в окне). Конвейер преобразований: (мировые координаты)-->[матрица моделирования]-->(преобразованные координаты)-->[матрица проекции]-->(мировое окно - координаты с отсечением)-->[перспективное преобразование]-->(преобразованные координаты)-->[преобразование поля просмотра]-->(координаты в окне).

Нашу последнюю функцию example_drawAxis() можно определить как функцию-член класса. example_drawAxis() для примера создаёт оси координат из примитивов-линий с помощью команд glBegin(GL_LINES) и glEnd(). Аргументом glBegin() является тип примитива, а в теле задаются вершины с помощью glVertex3f().

class Scene3D : public QGLWidget // новый класс Scene3D наследует встроенный класс QGLWidget
{ 
   private: 
      void example_drawAxis();
      //...
   //...
};

void Scene3D::example_drawAxis()
{
   glLineWidth(3); // устанавливаю ширину линии в пикселях
   // до вызова здесь команды ширина была равна 1 пикселю по умолчанию
 
   // ось x красного цвета
   glColor4f(1.00f, 0.00f, 0.00f, 1.0f); // устанавливается цвет последующих примитивов
   glBegin(GL_LINES); // построение линии
      glVertex3f( 1,  0,  0); // первая точка
      glVertex3f(-1,  0,  0); // вторая точка
   glEnd();  
 
   // ось y зеленого цвета
   QColor halfGreen(0, 128, 0, 255);
   qglColor(halfGreen);
   glBegin(GL_LINES);
      glVertex3f( 0,  1,  0);
      glVertex3f( 0, -1,  0);
   glEnd(); 
 
   // ось z синего цвета
   glBegin(GL_LINES);
      glColor4f(0.00f, 0.00f, 1.00f, 1.0f);
      glVertex3f( 0,  0,  1);
      glVertex3f( 0,  0, -1);
   glEnd();
}

По умолчанию ось y будет направлена вверх в плоскости экрана, ось x вправо в плоскости экрана, а ось z будет перпендикулярна экрану и направлена из него на вас. Оси образуют правую тройку векторов, как и должно быть в стандартной математике. Центр системы координат будет расположен в центре экрана. Эта система координат показывает мировые координаты, которыми задаются трёхмерные объекты в программе.

Особенность библиотеки OpenGL в том, что она работает как машина с настройками (машина состояний, или конечный автомат). Если была установлена некоторая настройка, то она будет выполняться до тех пор, пока не будет изменена. Наглядный пример: команда glColor4f(), которая устанавливает цвет RGBA. Обратите внимание, что совместно использована функция qglColor(). Представление примитивов с помощью команд glBegin() и glEnd() является очень наглядным и простым для понимания, тем не менее, недостаточно эффективным по быстродействию. Поэтому для повышения быстродействия в случаях статической геометрии их часто помещают в дисплейные списки (display lists, имеются также переводы: списки отображения, списки изображения, таблицы отображения). Ещё большей эффективности можно добиться, используя массивы вершин, массивы индексов вершин, массивы цветов вершин и т.д. Этот метод применим также в случае динамической геометрии. Пример использования массивов будет продемонстрирован в заключительном обобщающем листинге программы.

Наконец, рассмотрим слот updateGL(). Слоты являются как бы командами и используются Qt в механизме сигналов и слотов, но здесь этот механизм объясняться не будет. Слот updateGL() вызывает выполнение функции paintGL(), которая в свою очередь выполняет рисование сцены. Этот слот можно не определять в своём классе, например, Scene3D, если вы не добавляете в его тело что-то своё. В этом случае он просто берётся из QGLWidget. Пример:

void Scene3D::example_calculate()
{
   // вычисления
   // преобразования
   // ...
 
   updateGL(); // вызывается функция paintGL() -> перерисование сцены -> обновление изображения
}