OpenGL

*
Лекция 2 (26.09.2013)
*
* Для задания различных преобразований объектов сцены в
OpenGL используются операции над матрицами, при этом
различают три типа матриц: видовая, проекций и текстуры.
Все они имеют размер 4x4. Видовая матрица определяет
преобразования объекта в мировых координатах, такие как
параллельный перенос, изменение масштаба и поворот.
Матрица проекций задает как будут проецироваться
трехмерные объекты на плоскость экрана (в оконные
координаты), а матрица текстуры определяет наложение
текстуры на объект.
* Для того, чтобы выбрать, какую матрицу надо изменить,
используется команда void glMatrixMode(GLenum mode), вызов
которой со значением параметра mode равным GL_MODELVIEW,
GL_PROJECTION, GL_TEXTURE включает режим работы с
видовой, проекций и матрицей текстуры соответственно. Для
вызова команд, задающих матрицы того или иного типа
необходимо сначала установить соответствующий режим.
*
* Для определения элементов матрицы текущего типа вызывается
команда
* void glLoadMatrix[f d](GLtype *m) где m указывает на массив из 16
элементов типа float или double в соответствии с названием
команды, при этом сначала в нем должен быть записан первый
столбец матрицы, затем второй, третий и четвертый.
* Команда
* void glLoadIdentity(void) заменяет текущую матрицу на
единичную. Часто нужно сохранить содержимое текущей матрицы
для дальнейшего использования, для чего используют команды
* void glPushMatrix(void)
* void glPopMatrix(void)
* Они записывают и восстанавливают текущую матрицу из стека,
причем для каждого типа матриц стек свой. Для видовых матриц
его глубина равна как минимум 32, а для двух оставшихся типов
как минимум 2.
*
* Для умножения текущей матрицы слева на другую
матрицу используется команда
* void glMultMatrix[f d](GLtype *m) где m должен задавать
матрицу размером 4x4 в виде массива с описанным
расположением данных. Однако обычно для изменения
матрицы того или иного типа удобно использовать
специальные команды, которые по значениям своих
параметров создают нужную матрицу и перемножают ее
с текущей. Чтобы сделать текущей созданную матрицу,
надо перед вызовом этой команды вызвать
glLoadIdentity().
*
Координаты объекта
Видовые координаты
Нормализованные
координаты
Усеченные координаты
Оконные координаты
*
* К видовым преобразованиям будем относить перенос, поворот
и изменение масштаба вдоль координатных осей. Для
проведения этих операций достаточно умножить на
соответствующую матрицу каждую вершину объекта и
получить измененные координаты этой вершины:
* (x’, y’, z’, 1)T =M * (x, y, z, 1)T
* где M матрица видового преобразования. Перспективное
преобразование и проектирование производится аналогично.
Сама матрица может быть создана с помощью следующих
команд:
* void glTranslate[f d](GLtype x, GLtype y, GLtype z)
* void glRotate[f d](GLtype angle, GLtype x, GLtype y, GLtype z)
* void glScale[f d](GLtype x, GLtype y, GLtype z)
*
* glTranlsate..() производит перенос объекта, прибавляя к
координатам его вершин значения своих параметров.
* glRotate..() производит поворот объекта против часовой
стрелки на угол angle (измеряется в градусах) вокруг вектора (
x,y,z ).
* glScale..() производит масштабирование объекта (сжатие или
растяжение), домножая соответствующие координаты его
вершин на значения своих параметров.
* Все эти преобразования будут применяться к примитивам,
описания которых будут находиться ниже в программе. В
случае если надо, например, повернуть один объект сцены, а
другой оставить неподвижным, удобно сначала сохранить
текущую видовую матрицу в стеке командой glPushMatrix(),
затем вызвать glRotate..() с нужными параметрами, описать
примитивы, из которых состоит этот объект, а затем
восстановить текущую матрицу командой glPopMatrix().
*
* for(int i=0;i<10;i++)
*{
*
glPushMatrix();
*
*
*
glRotatef(-2*i, 0, 0, 1);
glTranslatef(4*i, 0, 0);
glRotatef(i, 0, 0, 1);
*
*
glColor3f( abs(cos(i)), 0, abs(sin(i)) );
glutWireTeapot(2);
*
*}
glPopMatrix();
*
* Кроме изменения положения самого объекта иногда бывает
нужно изменить положение точки наблюдения, что однако также
приводит к изменению видовой матрицы. Это можно сделать с
помощью команды
* void gluLookAt (GLdouble eyex, GLdouble eyey, GLdouble eyez,
GLdouble centerx, GLdouble centery, GLdouble centerz, GLdouble
upx, GLdouble upy, GLdouble upz)
* точка ( eyex,eyey,eyez ) определяет точку наблюдения,
* точка ( centerx, centery, centerz ) задает центр сцены, который
будет проектироваться в центр области вывода,
* вектор ( upx,upy,upz ) задает положительное направление оси у,
определяя поворот камеры.
* Если, камеру не надо поворачивать, то задается значение (0,1,0),
а со значением (0,-1,0) сцена будет перевернута.
* Фактически, эта команда совершает перенос и поворот объектов
сцены, но в таком виде задавать параметры бывает удобнее.
*
* В OpenGL существуют ортографическая (параллельная) и
перспективная проекция. Первый тип проекции может быть
задан командами
* void glOrtho(GLdouble left, GLdouble right, GLdouble bottom,
GLdouble top, GLdouble near, GLdouble far)
* void gluOrtho2D(GLdouble left, GLdouble right, GLdouble
bottom, GLdouble top)
* Первая команда создает матрицу проекции в усеченный объем
видимости (параллелограмм видимости) в левосторонней
системе координат. Параметры команды задают точки (left,
bottom, -near) и (right, top, -near), которые отвечают левому
нижнему и правому верхнему углам окна вывода. Параметры
near и far задают расстояние до ближней и дальней
плоскостей отсечения по дальности от точки (0,0,0) и могут
быть отрицательными.
* Во второй команде, в отличие от первой, значения near и far
устанавливаются равными –1 и 1 соответственно.
*
* Перспективная проекция определяется командой
* void gluPerspective(GLdouble angley, GLdouble aspect, GLdouble
znear, GLdouble zfar)
* которая задает усеченный конус видимости в левосторонней
системе координат. Параметр angley определяет угол
видимости в градусах по оси у и должен находиться в
диапазоне от 0 до 180. Угол видимости вдоль оси x задается
параметром aspect, который обычно задается как отношение
сторон области вывода. Параметры zfar и znear задают
расстояние от наблюдателя до плоскостей отсечения по
глубине и должны быть положительными. Чем больше
отношение zfar/znear, тем хуже в буфере глубины будут
различаться расположенные рядом поверхности, так как по
умолчанию в него будет записываться ‘сжатая’ глубина в
диапазоне от 0 до 1.
*
* После применения матрицы проекций на вход следующего
преобразования подаются так называемые усеченные (clip)
координаты, для которых значения всех компонент (xc, yc, zc,
wc)T находятся в отрезке [-1,1]. После этого находятся
нормализованные координаты вершин по формуле:
* (xn, yn, zn)T=(xc/wc, yc/wc, zc/wc)T
* Область вывода представляет из себя прямоугольник в
оконной системе координат, размеры которого задаются
командой:
* void glViewPort(GLint x, GLint y, GLint width, GLint height)
Значения всех параметров задаются в пикселах и определяют
ширину и высоту области вывода с координатами левого
нижнего угла ( x,y ) в оконной системе координат. Размеры
оконной системы координат определяются текущими
размерами окна приложения, точка (0,0)находится в левом
нижнем углу окна.
*
* struct view_point
*{
* double x, y, z, a, b;
* };
* view_point gamer;
* gluLookAt(gamer.x, gamer.y, gamer.z,
gamer.x+cos(gamer.a)*cos(gamer.b),
gamer.y+sin(gamer.a)*cos(gamer.b), gamer.z+sin(gamer.b),
*
0, 0, 1);
*
* int cx, cy;
* SetCursorPos(cx/2, cy/2);
* ShowCursor(FALSE);
* double new_time = GetTickCount();
* dt = new_time - old_time;
* POINT pt;
* GetCursorPos(&pt);
* SetCursorPos(cx/2, cy/2);
* gamer.a += (cx/2 - pt.x)*dt/1000;
* gamer.b += (cy/2 - pt.y)*dt/1000;
*
* if (GetAsyncKeyState(VK_ESCAPE) & 0x8000)
*{
*}
* PostQuitMessage(0);
* if (GetAsyncKeyState(VK_UP) & 0x8000 || GetAsyncKeyState('W') &
0x8000)
*{
* double l = dt/100;
*}
* gamer.x+=l*cos(gamer.a)*cos(gamer.b);
* gamer.y+=l*sin(gamer.a)*cos(gamer.b);
* gamer.z+=l*sin(gamer.b);
*
* Наложение текстуры на поверхность объектов сцены
повышает ее реалистичность, однако при этом надо
учитывать, что этот процесс требует значительных
вычислительных затрат. Под текстурой будем понимать
некоторое изображение, которое надо определенным
образом нанести на объект. Для этого следует
выполнить следующие этапы:
выбрать изображение и преобразовать его к нужному
формату
загрузить изображение в память
определить, как текстура будет наноситься на объект и
как она будет с ним взаимодействовать.
*
* Принятый в OpenGL формат хранения изображений отличается
от стандартного формата Windows DIB только тем, что
компоненты (R,G,B) для каждой точки хранятся в прямом
порядке, а не в обратном и выравнивание задается
программистом. Считывание графических данных из файла и
их преобразование можно проводить и вручную, однако
удобней воспользоваться функцией, входящей в состав
библиотеки GLAUX (для ее использования надо дополнительно
подключить glaux.lib), которая сама проводит необходимые
операции. Это функция
* AUX_RGBImageRec* auxDIBImageLoad(string file)
* где file– название файла с расширением *.bmp или *.dib. В
качестве результата функция возвращает указатель на область
памяти, где хранятся преобразованные данные.
*
* При создании образа текстуры в памяти следует учитывать следующие
требования.
* Во-первых, размеры текстуры как по горизонтали, так и по вертикали
должны представлять собой степени двойки. Это требование
накладывается для компактного размещения текстуры в памяти и
способствует ее эффективному использованию. Использовать только
текстуры с такими размерами конечно неудобно, поэтому перед
загрузкой их надо преобразовать. Изменение размеров текстуры
проводится с помощью команды
* void gluScaleImage(GLenum format, GLint widthin, GL heightin, GLenum
typein, const void *datain, GLint widthout, GLint heightout, GLenum typeout,
void *dataout)
* В качестве значения параметра format обычно используется значение
GL_RGB или GL_RGBA, определяющее формат хранения информации.
Параметры widthin, heightin, widhtout, heightout определяют размеры
входного и выходного изображений, а с помощью typein и typeout
задается тип элементов массивов, расположенных по адресам datain и
dataout. Как и обычно, то может быть тип
* GL_UNSIGNED_BYTE, GL_SHORT, GL_INT и так далее. Результат своей
работы функция заносит в область памяти, на которую указывает
параметр dataout.
*
* При создании образа текстуры в памяти следует учитывать следующие
требования.
* Во-первых, размеры текстуры как по горизонтали, так и по вертикали
должны представлять собой степени двойки. Это требование
накладывается для компактного размещения текстуры в памяти и
способствует ее эффективному использованию. Использовать только
текстуры с такими размерами конечно неудобно, поэтому перед
загрузкой их надо преобразовать. Изменение размеров текстуры
проводится с помощью команды
* void gluScaleImage(GLenum format, GLint widthin, GL heightin, GLenum
typein, const void *datain, GLint widthout, GLint heightout, GLenum typeout,
void *dataout)
* В качестве значения параметра format обычно используется значение
GL_RGB или GL_RGBA, определяющее формат хранения информации.
Параметры widthin, heightin, widhtout, heightout определяют размеры
входного и выходного изображений, а с помощью typein и typeout
задается тип элементов массивов, расположенных по адресам datain и
dataout. Как и обычно, то может быть тип
* GL_UNSIGNED_BYTE, GL_SHORT, GL_INT и так далее. Результат своей
работы функция заносит в область памяти, на которую указывает
параметр dataout.
*
* При использовании в сцене нескольких текстур, в OpenGL применяется
подход, напоминающий создание списков изображений. Вначале, с
помощью команды
* void glGenTextures(GLsizei n, GLuint*textures)
* надо создать n идентификаторов для используемых текстур, которые
будут записаны в массив textures. Перед началом определения свойств
очередной текстуры следует вызвать команду
* void glBindTexture(GLenum target, GLuint texture)
* где target может принимать значения GL_TEXTURE_1D или
GL_TEXTURE_2D, а параметр texture должен быть равен идентификатору
той текстуры, к которой будут относиться последующие команды. Для
того, чтобы в процессе рисования сделать текущей текстуру с некоторым
идентификатором, достаточно опять вызвать команду glBindTexture() c
соответствующим значением target и texture. Таким образом, команда
glBindTexture() включает режим создания текстуры с идентификатором
texture, если такая текстура еще не создана, либо режим ее
использования, то есть делает эту текстуру текущей.
*
* В следующей строке мы говорим OpenGL, что текстура будет
двухмерной (GL_TEXTURE_2D). Ноль задает уровень
детализации, это обычно ноль. Три - число компонент
цветовых данных, так как изображение сделано из трех
цветовых компонент (красный, зеленный, синий). texture1>sizeX - это ширина текстуры, автоматически. texture1->sizeY высота текстуры. Ноль - это бордюр. Он обычно остается
нулем. GL_RGB сообщает OpenGL, что данные изображения
представлены в порядке следования красных, зеленных и
голубых компонент цвета. GL_UNSIGNED_BYTE означает, что
данные из которых состоит изображение имеют размер байта и
все числа без знака, и в конце texture1->data сообщает
OpenGL, где брать сами данные. В этом случае указатель на
данные в записи texture1.
* glTexImage2D(GL_TEXTURE_2D, 0, 3, texture1->sizeX, texture1>sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, texture1->data);
*
* Перед нанесением текстуры на объект осталось
установить соответствие между точками на поверхности
объекта и на самой текстуре. Задавать это соответствие
можно двумя методами: отдельно для каждой вершины
или сразу для всех вершин, задав параметры
специальной функции отображения.
* Первый метод реализуется с помощью команд
* void glTexCoord[1 2 3 4][s i f d](type coord)
* void glTexCoord[1 2 3 4][s i f d]v(type *coord)
* Чаще всего используется команды вида
glTexCoord2..(type s, type t), задающие текущие
координаты текстуры. Вообще, понятие текущих
координат текстуры аналогично понятиям текущего цвета
и текущей нормали, и является атрибутом вершины.
*
* Однако даже для куба нахождение соответствующих
координат текстуры является довольно трудоемким
занятием, поэтому в библиотеке GLU помимо команд,
проводящих построение таких примитивов, как сфера,
цилиндр и диск, предусмотрено также наложение на них
текстур. Для этого достаточно вызвать команду
* void gluQuadricTexture(GLUquadricObj*quadObject,
GLboolean textureCoords) с параметром textureCoords
равным GL_TRUE, и тогда текущая текстура будет
автоматически накладываться на примитив.
*
* glEnable(GL_TEXTURE_2D);
* glBindTexture(GL_TEXTURE_2D, textures[0]);
* glBegin(GL_TRIANGLES);
* glColor3f( abs(cos(old_time/2000)), 0, abs(sin(old_time/2000)) );
* glTexCoord2d(0, 0);
* glVertex3d(0, -3, -2);
* glColor3f( abs(sin(old_time/2000)), abs(cos(old_time/2000)), 0 );
* glTexCoord2d(1, 0);
* glVertex3d(0, 3, -2);
* glColor3f( 0, abs(sin(old_time/2000)), abs(cos(old_time/2000)) );
* glTexCoord2d(0.5, 1);
* glVertex3d(0, 0, 1.5);
* glEnd();
* glDisable(GL_TEXTURE_2D);
*
* При наложении текстуры, как уже упоминалось, надо
учитывать случай, когда размеры текстуры отличаются от
размеров объекта, на который она накладывается. При этом
возможно как растяжение, так и сжатие изображения, и то,
как будут проводиться эти преобразования может серьезно
повлиять на качество построенного изображения. Для
определения положения точки на текстуре используется
параметрическая система координат (s,t), причем значения s и
t находятся в отрезке [0,1]. Для изменения различных
параметров текстуры применяются команды:
* void glTexParameter[i f](GLenum target, GLenum pname,
GLenum param)
* void glTexParameter[i f]v(GLenum target, GLenum pname,
GLenum *params)
* При этом target имеет аналогичный смысл, что и раньше,
pname определяет, какое свойство будем менять,а с помощью
param или params устанавливается новое значение.
*
* Возможные значения pname:
* GL_TEXTURE_MIN_FILTER параметр param определяет
функцию, которая будет использоваться для сжатия
текстуры. При значении GL_NEAREST будет
использоваться один (ближайший), а при значении
GL_LINEAR четыре ближайших элемента текстуры.
* Значение по умолчанию: GL_LINEAR.
* GL_TEXTURE_MAG_FILTER параметр param определяет
функцию, которая будет использоваться для увеличения
(растяжения) текстуры. При значении GL_NEAREST будет
использоваться один (ближайший), а при значении
GL_LINEAR четыре ближайших элемента текстуры.
* Значение по умолчанию: GL_LINEAR.
*
* GL_TEXTURE_WRAP_S параметр param устанавливает
значение координаты s, если оно не входит в отрезок
[0,1]. При значении GL_REPEAT целая часть s
отбрасывается, и в результате изображение
размножается по поверхности. При значении GL_CLAMP
используются краевые значения: 0 или 1, что удобно
использовать, если на объект накладывается один образ.
* Значение по умолчанию: GL_REPEAT.
* GL_TEXTURE_WRAP_T аналогично предыдущему
значению, только для координаты t.
* Использование режима GL_NEAREST значительно
повышает скорость наложения текстуры, однако при
этом снижается качество, так как в отличие от GL_LINEAR
интерполяция не производится.
*
* Для того, чтобы определить, как текстура будет
взаимодействовать с материалом, из которого сделан объект,
используются команды
* void glTexEnv[i f](GLenum target, GLenum pname, GLtype param)
* void glTexEnv[i f]v(GLenum target, GLenum pname, GLtype *params)
* Параметр target должен быть равен GL_TEXTURE_ENV, а в
качестве pname рассмотрим только одно значение
GL_TEXTURE_ENV_MODE, которое наиболее часто применяется.
Параметр если param может быть равен:
* GL_MODULATE конечный цвет находится как произведение цвета
точки на поверхности и цвета соответствующей ей точки на
текстуре.
* GL_REPLACE в качестве конечного цвета используется цвет точки
на текстуре.
* GL_BLEND конечный цвет находится как сумма цвета точки на
поверхности и цвета соответствующей ей точки на текстуре с
учетом их яркости.
*
* Чтобы построить примитив из библиотеки GLU, надо
сначала создать указатель на quadric- объект с помощью
команды gluNewQuadric(), а затем вызвать одну из
команд gluSphere(), gluCylinder(), gluDisk(),
gluPartialDisk(). Рассмотрим эти команды отдельно:
* void gluSphere(GLUquadricObj*qobj, GLdouble radius,
GLint slices, GLint stacks)
* Строит сферу с центром в начале координат и радиусом
radius. При этом число разбиений сферы вокруг оси z
задается параметром slices, а вдоль оси z параметром
stacks.
* void gluCylinder(GLUquadricObj*qobj, GLdouble baseRadius,
GLdouble topRadius, GLdouble height, GLint slices, GLint stacks)
* Строит цилиндр без оснований (то есть кольцо), продольная
ось параллельна оси z, заднее основание имеет радиус
baseRadius , и расположено в плоскости z=0, переднее
основание имеет радиус topRadius и расположено в плоскости
z=height. Если задать один из радиусов равным нулю, то будет
построен конус.
* Параметры slices и stacks имеют тот же смысл, что и в
предыдущей команде.
* void gluDisk(GLUquadricObj*qobj, GLdouble innerRadius,
GLdouble outerRadius, GLint slices, GLint loops) Строит плоский
диск (то есть круг) с центром в начале координат и радиусом
outerRadius. При этом если значение innerRadius ненулевое, то
в центре диска будет находиться отверстие радиусом
innerRadius. Параметр slices задает число разбиений диска
вокруг оси z, а параметр loops –число концентрических колец,
перпендикулярных оси z.
* void gluPartialDisk(GLUquadricObj *qobj, GLdouble
innerRadius, GLdouble outerRadius, GLint slices, GLint
loops, GLdouble startAngle, GLdouble sweepAngle);
Отличие этой команды от предыдущей заключается в
том, что она строит сектор круга, начальный и конечный
углы которого отсчитываются против часовой стрелки от
положительного направления оси y и задаются
параметрами startAngle и sweepAngle. Углы измеряются в
градусах.
* Команды, проводящие построение примитивов из библиотеки
GLUT, реализованы через стандартные примитивы OpenGL и GLU.
Для построения нужного примитива достаточно произвести вызов
соответствующей команды.
* void glutSolidSphere(GLdouble radius, GLint slices, GLint stacks)
* void glutWireSphere(GLdouble radius, GLint slices, GLint stacks)
* Команда glutSolidSphere() строит сферу, а glutWireSphere() каркас сферы радиусом radius. Остальные параметры имеют тот
же смысл, что и в предыдущих командах.
* void glutSolidCube(GLdouble size)
* void glutWireCube(GLdouble size)
* Эти команды строят куб или каркас куба с центром в начале
координат и длиной ребра size.
* void glutSolidCone(GLdouble base, GLdouble height, GLint slices,
GLint stacks)
* void glutWireCone(GLdouble base, GLdouble height, GLint slices,
GLint stacks)
* Эти команды строят конус или его каркас высотой height и
радиусом основания base, расположенный вдоль оси z. Основание
находится в плоскости z=0. Остальные параметры имеют тот же
смысл, что и в предыдущих командах.
* void glutSolidTorus(GLdouble innerRadius, GLdouble outerRadius, GLint nsides, GLint
*
*
*
*
*
*
*
*
*
*
*
*
*
*
rings)
void glutWireTorus(GLdouble innerRadius, GLdouble outerRadius, GLint nsides, GLint
rings)
Эти команды строят тор или его каркас в плоскости z=0. Внутренний и внешний
радиусы задаются параметрами innerRadius, outerRadius. Параметр nsides задает
число сторон в кольцах, составляющих ортогональное сечение тора, а rings- число
радиальных разбиений тора.
void glutSolidTetrahedron(void)
void glutWireTetrahedron (void)
Эти команды строят тетраэдр (правильную треугольную пирамиду) или его каркас,
при этом радиус описанной сферы вокруг него равен 1.
void glutSolidOctahedron(void)
void glutWireOctahedron(void)
Эти команды строят октаэдр или его каркас, радиус описанной вокруг него сферы
равен 1.
void glutSolidDodecahedron(void)
void glutWireDodecahedron(void)
Эти команды строят додекаэдр или его каркас, радиус описанной вокруг него
сферы равен квадратному корню из трех.
void glutSolidIcosahedron(void)
void glutWireIcosahedron(void)
Эти команды строят икосаэдр или его каркас, радиус описанной вокруг него сферы
равен 1.