Войти
ПрограммированиеСтатьиГрафика

OpenGL на Qt 4. Это просто! (часть 1) (2 стр)

Автор:

Модуль QtOpenGL

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

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

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

Класс QGLWidget

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

Класс:

QGLWidget

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

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

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

// функция устанавливает начальные значения контекста рендеринга
virtual void QGLWidget::initializeGL()

// функция отвечает за изменение размеров окна виджета
virtual void QGLWidget::resizeGL(int width, int height)

// функция рисует изображение
virtual void QGLWidget::paintGL()

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

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

Выполнение функций происходит автоматически по следующей схеме:

(создание виджета)--> ... -->glDraw()-->{?glInit()-->initializeGL(), ?resizeGL(), paintGL(), ...}

(изменение размера окна)--> ... -->glDraw()-->{?glInit(), ?resizeGL(), paintGL(), ...}

updateGL()-->glDraw()-->{?glInit(), ?resizeGL(), paintGL(), ...}

Знак вопроса (?) на схеме условно означает, что в этих местах проверяется, нужно ли сейчас вызвать эти функции или нет. Более полную и подробную информацию о классе QGLWidget можно найти в справке Qt Assistant, который всегда поставляется с Qt, а ещё более подробно смотрите в исходных текстах Qt.

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

#include <QGLWidget>  // подключаем класс QGLWidget

// новый класс Scene3D наследует встроенный класс QGLWidget
class Scene3D : public QGLWidget
{ 
   private: 
      //... 

   protected:
      // метод для проведения инициализаций, связанных с OpenGL 
      /*virtual*/ void initializeGL(); 
      // метод вызывается при изменении размеров окна                   
      /*virtual*/ void resizeGL(int nWidth, int nHeight); 
      // метод, чтобы заново перерисовать содержимое виджета
      /*virtual*/ void paintGL();                         
 
   public: 
      Scene3D(QWidget* parent = 0); // конструктор класса Scene3D
};

// ...

// конструктор класса Scene3D 
Scene3D::Scene3D(QWidget* parent/*= 0*/) : QGLWidget(parent) 
{ 
   // передает дальше указатель parent
} 

Класс виджета, который будет работать с OpenGL, должен наследоваться от класса QGLWidget. Мы назвали этот класс Scene3D. Объектом класса Scene3D будет виджет, в котором будет рисоваться трёхмерная сцена. Конструктор класса Scene3D сначала вызовит конструктор класса QGLWidget, который в свою очередь вызовит конструктор класса QWidget.

В Qt имеет место так называемая иерархия объектов (класса QObject или его классов-наследников), когда связь между объектами образует древовидную структуру (условно сверху вниз). Эту структуру называют деревом объектов. На вершине иерархии находится объект, от которого идёт вниз связь с другими объектами. Объект на вершине иерархии объектов называется объектом верхнего уровня. Он, являясь (как бы) объектом-родителем, связан с нижележащими объектами, которые являются для него (как бы) объектами-потомками. Эти объекты-потомки могут быть объектами-родителями для следующих нижележащих объектов и т.д. В Qt при уничтожении объекта-родителя все его объекты-потомки уничтожаются автоматически. Такая связь эффективна для управления памятью, когда достаточно удалить только верхний в иерархии объект и все связанные с ним нижележащие объекты удалятся автоматически. Здесь важно заметить, что объекты-потомки должны создаваться динамически (через new), иначе может произойти ошибка, связанная с вызовами деструктров. Тогда как использование динамических объектов-потомков исключает эту возможную ошибку. Как правило, объект верхнего уровня создаётся нединамически (в стеке): обычно это виджет окна или виджет главного окна. Остальные GUI-объекты создаются динамически как объекты-потомки этого главного виджета (объекта верхнего уровня). Когда объект верхнего уровня выйдет за область видимости, то всё дерево объектов удалится из памяти. В этом и заключается вся прелесть работы с деревом объектов — не нужно держать в голове динамические объекты GUI и удалять их через delete в деструкторе. В этой части статьи мы не будем создавать дерево объектов и отложим это до второй части. Здесь в обобщающей программе наш объект класса Scene3D будет объектом верхнего уровня. В конечном итоге в конструктор класса QWidget передастся значение 0, что и будет означать, что наш объект класса Scene3D является объектом верхнего уровня в иерархии объектов.

В конструкторе Scene3D() нужно задать начальные значения, не являющиеся как таковыми командами OpenGL, например, углы поворотов при наблюдении сцены. Определять деструктор в данном случае необязательно; деструктор по умолчанию сам создастся компилятором. Функции initializeGL(), resizeGL(), paintGL() являются виртуальными функциями (динамический полиморфизм в C++). Следовательно, в классе-наследнике Scene3D обозначать функции как virtual не нужно. Эти три функции изначально имеют полностью пустое тело, которое нужно заполнить командами OpenGL. Здесь нужно отметить, что функции glDraw() и glInit() принадлежат классу QGLWidget, а не к OpenGL (как можно было бы подумать из префикса gl). Функции glDraw() и glInit() не нужны для пользовательской работы; они просто вызывают initializeGL(), resizeGL(), paintGL(), о которых и пойдёт речь далее. Как раз только эти три функци и используются для пользовательской работы с OpenGL: при инициализации настроек рендеринга, при изменении размера окна виджета и при рисовании.

Инициализация контекста рендеринга

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

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

Вы можете так же дополнительно вызывать initializeGL() в случае необходимости с помощью glInit() класса QGLWidget (префикс gl добавлен для удобства, но это не функция OpenGL). Обратим внимание на первую команду 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) устанавливает режим проверки глубины пикселей объектов (например, для двух последовательно рисующихся треугольников). Зачем это нужно? Дело в том, что одни объекты могут быть ближе к нам (наблюдателям), а другие дальше, а значит, ближние объекты могут закрывать собой дальние. OpenGL никак не проверяет, какой объект ближе, а какой дальше, он просто последовательно рисует объекты. Если последовательно рисуются: объект1, объект2, то даже если объект2 дальше от наблюдателя, он все равно будет закрывать собой объект1, потому что объект2 нарисовался последним. Но как объяснить OpenGL, какой объект ближе, а какой дальше? На помощь нам приходит технология отсечения скрытых (невидимых) поверхностей (т.е. удаление «закрытых» пикселей объектов) с помощью буфера глубины, известного также как z-буфер. Суть этой технологии состоит в том, что каждому пикселю объекта (например, треугольника) на экране с координатами x и y даётся еще координата z, называемая глубиной и характеризующая расстояние до наблюдателя. Если сохранить глубину пикселей объекта1 в буфер глубины и потом сравнить с глубиной пикселей объекта2, то можно определить, какие пиксели объектов видны на экране, а какие скрыты. Например, рассмотрим такую ситуацию: последовательно рисуются два треугольника. Когда обрабатывается первый треугольник, то значения глубины его пикселей сохраняются в буфер глубины. Затем когда обрабатывается второй треугольник, то глубина уже его пикселей сравнивается со значениями в буфере глубины, и те пиксели, которые ближе к нам, замещают те, которые дальше. Команда glEnable(GL_DEPTH_TEST) включает такой режим, при котором проводится сравнение глубины пикселей объектов с глубиной, хранящейся в буфере глубины. Также нужно будет сообщить системе об использовании буфера глубины, т.е. нужно подключить сам буфер глубины. Qt автоматически в конструкторе класса QGLWidget по умолчанию задаст такой формат в контекст, т.е. использовать (подключить) буфер глубины. Поэтому буфер глубины можно явно и не подключать, он подключится сам. Использование буфера глубины и сравнение глубины являются эффективным способом удаления (отсечения) невидимых поверхностей. 

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

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

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

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

/*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() загружают единичную матрицу в матрицу проекции. Параметром glMatrixMode() является матрица, над которой будут совершаться все последующие преобразования. Команда glMatrixMode(GL_PROJECTION) как раз означает, что текущей матрицей для преобразований станет матрица проекции. Для матрицы проекции таковыми преобразованиями являются установление видимого объёма и типа проекции. Необходимо знать, что любые преобразования с матрицами не сбрасываются, а аддитивно накапливаются. Поэтому необходимо каждый раз возвращать первоначальные матрицы, в которых не произведено никаких преобразований. С этой цель единичная матрица и загружается в текущую матрицу (проекции), т.к. единичная матрица соответствует матрице без преобразований. Если не отменять преобразования, то следующее преобразование будет совершаться уже относительно предыдущего.

Команда 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 автоматически масштабирует всю проекцию сцены так, что она становится вытянутой по координате x экрана. Чуть позже в заключительном листинге обобщающей программы будет показано, как этого избежать и «сохранить квадрат квадратным». Также необходимо помнить, что отсчёт координаты y на экране производиться по-разному: из самой нижней точки вверх в OpenGL и из самой верхней точки вниз в экранных координатах в виджете.

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

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

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

/*virtual*/ void Scene3D::paintGL() // рисование
{ 
   // glClear(GL_COLOR_BUFFER_BIT); // окно виджета очищается текущим цветом очистки
   // очистка буфера изображения и глубины
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

   // устанавливаем положение и ориентацию матрице моделирования
   glMatrixMode(GL_MODELVIEW); 
   // загружаем единичную матрицу моделирования
   glLoadIdentity();          

   // последовательные преобразования:
   glRotatef(xRot, 1.0f, 0.0f, 0.0f); // поворот вокруг оси X         
   glRotatef(yRot, 0.0f, 1.0f, 0.0f); // поворот вокруг оси Y
   glRotatef(zRot, 0.0f, 0.0f, 1.0f); // поворот вокруг оси Z
   glTranslatef(xTra, yTra, zTra);    // трансляция 
   glScalef(xSca, ySca, zSca);        // масштабирование по осям 
   
   example_drawAxis(); // рисование осей координат
} 

Первая закомментированная команда 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) также могут привести к разным конечным преобразованиям. Все эти преобразования в итоге изменяют матрицу моделирования от единичной. Именно поэтому необходимо при перерисовании сцены загружать единичную матрицу, после чего будут осуществляться указанные преобразования над ней. К тому же вы можете загружать матрицы, сделанные «своими руками».

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

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

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

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

// ...

void Scene3D::example_drawAxis()
{
   // устанавливаем ширину линии приближенно в пикселях
   glLineWidth(3.0f);
   // до вызова здесь команды ширина была равна 1 пикселю по умолчанию

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

Особенность библиотеки OpenGL в том, что она работает как машина с настройками (машина состояний, или конечный автомат). Если была установлена некоторая настройка, то она становится текущей и будет выполняться до тех пор, пока не будет изменена. Наглядный пример: команда glColor4f(), которая устанавливает текущий цвет RGBA. Обратите внимание, что совместно использована функция qglColor(). То же самое относится и к командам glEnable() для включения и glDisable() для выключения настроек.

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

Страницы: 1 2 3 4 Следующая »

#3D, #графика, #OpenGL, #Qt, #Qt4

19 января 2011 (Обновление: 2 янв. 2013)

Комментарии [98]