WWW.DISSERS.RU

БЕСПЛАТНАЯ ЭЛЕКТРОННАЯ БИБЛИОТЕКА

   Добро пожаловать!

Pages:     | 1 || 3 | 4 |   ...   | 5 |

«Михаил Краснов O p e n G L ГРАФИКА В ПРОЕКТАХ DELPHI CattJUfl-JEetfiefiJtffa Дюссельдорф • Киев • Москва • ...»

-- [ Страница 2 ] --

Примитив, задаваемый константой GL_QUAD_STRIP. СОСТОИТ ИЗ связанных че тырехугольников. Первый четырехугольник формируется из вершин номер один, два, три и четыре. Второй четырехугольник в качестве опорных берет вторую, третью, пятую и четвертую вершины. Ну и так далее.

Если в предыдущем примере поменять константу на GL QUAD S':'RII-, как это сделано в проекте из подкаталога ЕхЗ 1, то изображение в окне получится таким, как на рис. 2.7.

Для рисования выпуклого многоугольника используется примитив GL POLYGON. Многоугольник строится из связанных треугольников с общей вершиной, в качестве которой берется первая среди перечисляемых в ко мандных скобках. Код для рисования шестиугольника может выглядеть так:

glBegin ( L POLYGON);

G For i : 0 to 6 do = / 6}, 0. glVertex2f (.

glEnd;

Обратите внимание, что в отличие от предыдущих реализаций этой задачи вершины шестиугольника последовательно соединяются не с центром окна, а с крайней правой вершиной, указанной самой первой. Это становится хо рошо заметным, если менять цвет для каждой вершины, как это сделано в проекте из подкаталога Ех32.

Замечание ) Для воспроизведения треугольников и четырехугольников лучше не использо вать примитив G L _ P O L Y G O N, в таких случаях оптимальным будет использова ние примитивов, специально предназначенных для этих фигур.

Рис. 2. 6. Для построения независимых Рис. 2. 7. То же, что и рис. 2.6, четырехугольников используется но константа GL QUAD STRIP примитив, задаваемый константой GL QUADS Глава 2. Двумерные построения Попробуем чуть усложнить наши построения: зададимся целью нарисовать фигуру, как на рис. 2.8.

Поскольку примитив GL_POLYGON позволяет строить только выпуклые много угольники, построение всей фигуры разбиваем на две части, каждая из ко торых представляет собой выпуклый многоугольник. Соответствующий про ект располагается в подкаталоге ЕхЗЗ, а на рис. 2.9 я пометил эти части раз ными цветами.

/' P LG N OY O Рис. 2. 9. Фигуру для построения Рис. 2. 8. Невыпуклый многоугольник разбиваем на несколько частей Если же попытаться нарисовать эту фигуру "за один присест", то картинка может получиться, например, такой, как на рис. 2.10.

Подкаталог Ех34 содержит проект, в котором эта же фигура строится с ис пользованием связанных четырехугольников и только одной пары команд ных скобок. При этом построении также имеются потери эффективности:

некоторые четырехугольники местами строятся на уже закрашенных местах.

Для проверки достаточно включить контурный режим рисования много угольников, причем при включении такого режима выборочно для лицевой или изнаночной стороны можно заметить, что одни многоугольники мы видим с лицевой стороны, а другие — с изнаночной.

Рис. 2. 1 0. Так выглядит попытка построения фигуры с использованием одной пары командных скобок OpenGL. Графика в проектах Delphi Замечание Важно запомнить: базовые команды OpenGL предназначены для построения только выпуклых фигур, поэтому сложные фигуры чаще всего рисуются этапа ми, по частям.

Возможно, вы уже задались вопросом, как нарисовать фигуру с внутренним отверстием. Подкаталог Ех35 содержит проект для рисования диска, а ЕхЗб содержит проект, в котором внутри квадрата рисуется круглое отверстие.

Всю фигуру разбиваем на четыре четверти, каждая из которых — группа связанных четырехугольников. Если включить режим контурного рисования многоугольников, картинка получится такой, как на рис. 2.11.

Рис. 2.11. Так разбивается фигура, если требуется нарисовать внутреннее отверстие Если вы имеете опыт работы в графических редакторах, такой подход, воз можно, вас несколько разочаровал. Конечно, было бы гораздо удобнее, если бы имелась, например, функция закраски замкнутой области, как это при нято в большинстве графических редакторов. Но мы имеем дело с низко уровневой библиотекой, и она не предоставляет подобных готовых функций.

Замечание Как мы увидим дальше, есть несколько способов решения задачи построения сложных объектов— невыпуклых многоугольников или объектов, содержащих отверстия, — однако самый быстрый (в смысле скорости воспроизведения, а не кодирования) способ состоит в том, чтобы вы сами полностью расписали алгоритм построения на основе многоугольников, а в идеале— с использова нием только треугольников.

Утешением может стать то, что аппаратные возможности растут стремитель но и подобные рекомендации теряют свою актуальность.

Сейчас самое время обратить ваше внимание на очень важный факт. Если в примере на отверстие включить режим сглаживания многоугольников:

а ^ f i n a b l e { G L POLYGON SMOOTH);

Глава 2. Двумерные построения 69_ то построение фигуры замедляется, что хорошо заметно при изменении размеров окна, когда происходит его перерисовка. Использование режимов, их включение и отключение, может сильно сказаться на скорости воспроиз ведения, о чем необходимо постоянно помнить.

Команда glEdgeFlag Режим вывода полигонов (так мы будем иногда называть многоугольники) позволяет рисовать контуры фигур или только точки в опорных вершинах фигуры. Когда сложная фигура разбивается на части, контурный режим мо жет испортить картинку: станет заметным поэтапное построение фигуры.

В такой ситуации решение может состоять в исключении некоторых вершин из построения границы фигуры, что осуществляется вызовом команды glEdgeFlag. Аргумент этой команды имеет тип Boolean, если точнее — GLboolean, и мы в главе 1 говорили о небольшой проблеме с этим типом OpenGL. Как оговаривается в справке, команда дает эффект только в режи ме контурного или поточечного вывода многоугольников. Также специально оговаривается возможность использования этой команды внутри командных скобок.

Смысл команды следующий: вершины, указываемые после вызова команды с аргументом False, при построении границы многоугольника не учитыва ются, как если бы мы рисовали контур в этом месте прозрачным цветом.

Посмотрите пример, располагающийся в подкаталоге Ех37, в котором наша тестовая фигура рисуется в двух режимах: полная заливка и контурно. Код при этом выполняется один и тот же, но для того, чтобы скрыть от наблю дателя секторное разбиение фигуры, некоторые вершины заключены между строками:

glEdgeFlag (FALSE);

glEdgeFlag (TRUE);

Поэтому при контурном режиме эти вершины просто пропускаются.

Режим вывода многоугольников меняется при нажатии пробела, после чего окно перерисовывается.

В качестве упражнения я бы посоветовал удалить строки, в которых вызыва ется команда glEdgeFlag, и посмотреть на получающийся результат.

Массивы вершин Мы рассмотрели все десять примитивов, имеющихся в нашем распоряже нии. Код практических построений, включающих сотни и тысячи отдельных /0 OpenGL. Графика в проектах Delphi примитивов, подчас чересчур громоздок, большая часть его в таких случа ях — С Т И И Т С Ч СТрОК С В З В М КОМанДЫ qlVertex.

ОН ЫЯИ ЫО О Библиотека OpenGL располагает средством сокращении кода, базирующим ся на использовании массивов вершин. В массиве вершин, т. е. массиве ве щественных чисел, задаются координаты опорных вершин, по которым вы зовом О Н Й КОМанДЫ gIDrawArrays СТрОИТСЯ Последовательность ПрИМИТИ ДО вов заданного типа.

Поскольку эта команда не входит в стандарт OpenGL и является его расши рением (extension), для получения справки по ней необходимо вызвать кон текстную П М Щ на С О О glDrawArraysEXT.

ООЬ ЛВ У команды gIDrawArrays три аргумента: тип примитива и характеристики используемого массива.

Для использования этой функции надо, как минимум, задать массив вер шин, по которым будет строиться множество примитивов. Ссылка на мас сив вершин создается командой givertexPointer, также являющейся расширением стандарта. Помимо массива вершин, для украшения картинки будем также использовать массив цвета вершин, ссылка на который задается командой gicoiorpointer, тоже не входящей в стандарт. Прибавив оконча ние ЕХТ к именам этих команд, можно получить контекстную подсказку, по которой легко разобраться с их аргументами. Но, к сожалению, для исполь зования массива вершин полученной информации недостаточно, необходи мо еще использовать, как минимум, команду glEnabieciieritstate, справку по которой уже невозможно получить никакими ухищрениями. Эта команда аналогична glEnabie, но применяется только в контексте массивов вершин.

У нее имеется парная команда — giDisabieciientstaie, отключающая ис пользование массива вершин.

В заголовочном файле opengl.pas. поставляемом с Delphi, отсутствуют прото типы команд, не входящих в стандарт OpenGL, а также отсутствует описа ние констант, используемых такими командами, что немного затруднит на ше изучение этой библиотеки.

Обратимся к проекту из подкаталога Ех38.

Массив с именем vertex содержит координаты четырех точек — углов квад рата, а в массиве цветов colors содержатся соответствующие вершинам зна чения RGB:

Vertex : Array [0..3, 0. J or GLFloat;

. Colors : Array [0..3, 0..2] of GLFloau;

Код рисования выглядит так:

glVertexPointer(2, GL FLOAT, 0, @Vertex);

// указатель на массив вершин qlCoiorPointer(3, GL FLOAT, 0, ^Colors);

// указатель на массив цветов Глава 2, Двумерные построения • glEnableCIientStane(GL_VERTEX_ARRAY);

// массив версии - включаем режим glEnableClientState(GL_COLOR_ARRAYj;

// массив цветов - включаем режим // рисование множества полигонов glDrawArrays(GL_POLYGON, 0, 4);

// выключаем режимы (Б ЭТОМ glDisablcClientState(GL_COLOR_ARRAY);

// примере не обязательно) glDisafcleClientState(GL_VERTEX A R R A Y ) ;

Значение первого аргумента команды givertexpointer равно двум, посколь ку вершины заданы указанием двух координат. То есть этот аргумент задает по сколько вещественных чисел считывать для каждой точки.

Результат работы программы показан на рис. 2.12.

Рис. 2.12. Иллюстрация к примеру на использование массива вершин Для использования команд-расширений программу пришлось дополнить строками с описанием прототипов процедур:

procedure glVertexPoir.ter isize: GLint;

atype: GLenum;

stride: GLsizei;

data: pointer);

stdcall;

external OpenGL32• procedure glColorPointer (size: GLint;

atype: GLenum;

stride: GLsizei;

data: pointer);

stdcall;

external OpenGL32;

procedure glDrawArrays (mode: GLenum;

first: GLint;

count: GLsizei);

stdcall;

external Oper.GL32;

procedure glEnaOleGlienr.State {aarray: GLenum);

stdcall;

external OpenGL32 • procedure glDisacleClier.tstarc (aarray: GLenum);

stdcall;

external OpenGL32;

Здесь OpenGL32— константа, определяемая в модуле opengl.pas.

Потребовалось также задать значение констант, используемых этими про F цедурами:

const GL_VERTE!X_ARRAY - S8074;

GL_COLOF_ARRAY = $8076;

OpenGL. Графика в проектах Delphi Значения констант и информацию о типах аргументов процедур я почерп нул из заголовочных файлов сторонних разработчиков и перепроверил по содержимому файла gl.h, поставляемым с Visual C + +. Информация о команде g i s n a b i e c i i e n t s t a t e взята из описания OpenGL фирмы SGI.

Первым аргументом giorawArrays может быть любая константа, которую допускается использовать в giBegin. Чтобы лучше разобраться с принципом построения, рекомендую посмотреть результат работы программы с исполь зованием ОТЛИЧНЫХ ОТ Gl, P L G N KOHCTaHT.

OY O В примере по массиву вершин строится множество полигонов вызовом команды qlDrawArrays(GL POLYGON, 0, 4 оисование множества полигенов Эта команда является сокращением следующей последовательности команд (пример из подкаталога Ех39):

glGeyin (GL_POLYGON);

q1Ar r a yE L emen t(0);

q1ArrayKlemcnt(1);

glArrayElemenr(2);

glArrayE lenient(3);

qlEnd;

Используемая здесь функция giArrayL-:;

lament (также расширение стандарта) берет в качестве вершины примитива элемент массива с заданным индек сом. Индекс, как видно из примера, начинается с нуля.

В продолжение этой темы разберите также проект из подкаталога Ех40 — мою адаптацию и трансляцию под Delphi программы Polygons из книги | ! [, результат работы которой иллюстрирует рис. 2.13.

Рис. 2.13. Уже сейчас вы умеете создавать высококачественные изображения Глава 2. Двумерные построения Вы, возможно, задаетесь вопросом, почему в заголовочном файле, постав ляемом с Delphi, отсутствуют прототипы процедур, хоть и не входящих в стандарт OpenGL, но документированных разработчиком библиотеки. От вет на этот вопрос заключается, по-видимому, в том, что этот файл является трансляцией заголовочных файлов gl.h и glu.h, опубликованных SGI, и в него вошло только то, что документировано в этих файлах. Как явствует из заголовка файла, за основу положены файлы версии 1993 года.

Помимо массивов вершин и массива цветов вершин, имеется массив границ— аналог команды ciEdgeFiay применительно к массивам вершин.

В этом случае необходимо использовать команду giBdgeFiagPointer. Приба вив суффикс ЕХТ, вы можете получить справку по этой команде. В ней.

в частности, говорится, что включение режима использования массива гра ниц осуществляется так:

glEnable (GL_EDGE_FLAG_ARRAY_EXT);

Однако это указание, по-видимому, является ошибочным. Я смог вос пользоваться массивом флагов границ только с использованием следующего кода:

glEnableClientState(GL_EDGE_FLAG_ARRAY);

То же самое я могу сказать по поводу аргументов команды.

Посмотрите проект из подкаталога Ех41, где для иллюстрации используется все та же тестовая фигура, изображенная на рис. 2.8.

В ЭТОМ Примере фигура ВЫВОДИТСЯ С ИСПОЛЬЗОВанием Команды glDrawArrays в двух режимах — сплошной заливкой и контурно. При втором режиме ска зывается действие подключения массива границ.

В КОДе ПрОГрамМЫ ДОбавИЛСЯ ПрОТОТИП Процедуры glEdqeFI.agPointer. Обра тите внимание на расхождение в описании прототипа с документацией:

у прототипа два аргумента вместо трех. Если попытаться и точности следо вать документации, в результате либо не используется массив границ, либо возникает сообщение об ошибке.

Прямое обращение к пикселам экрана Библиотека OpenGL располагает командами, позволяющими осуществить непосредственный доступ к пикселам экрана. Разберем проект из подката лога Ех42 — простой пример на вывод блока пикселов на экран вызовом двух команд:

glRaster?os2f (-0.25, 0.25);

g l D r a w P i x e l s (IniageWidth, ImageHei g h t, GL_RGB, GL_UNfiIGNi;

:!J BYTE, 5 Image) ;

?

Первая команда задает базовую точку для выводимого блока, вторая осу ществляет собственно вывод массива пикселов. Высота при выводе может и 74 OpenGL. Графика в проектах Delphi отличаться от реального размера массива, т. е. быть меньше, ширину же для корректного вывода желательно не брать меньше действительного размера массива.

В этом простом примере выводимый массив заполняется значениями RGB так, что в результате получается шахматная доска с сине-красными клетками:

const ImageWidth = 64;

ImageHeight = 64 ;

Image : Array [0.. ImageHeight-!, 0.. ImageWidth — 1, 0.. 2 ] of G U y _ Lb.f;

Создание образа шахматной доски} procedure TfrmGL.Makelmage;

var i, j : Integer;

begin For i := 0 to ImageHeight — 1 do For j := 0 to ImageWidth — 1 do begin If ({i and 8) = 0) xor ((j and S) = 0) then begin Imagefi][j][0] := 0;

// красный Image[i][j][1] := 0;

// зеленый Image[i][j][2] :^ 255;

// синий end else begin Image[i][j][0] := 255;

// красный Image[i][j][1] := 0;

// зеленый Image[i] [j] [2] := 0;

// синий end;

end;

end;

В развитие темы разберем более интересный пример (подкаталог Ех43), где выводимый массив заполняется следующим образом: создается объект клас са TB±tmap, в который загружается растр из bmp-файла, последовательно считываются пикселы объекта, и в соответствии со значениями цвета каж дого пиксела заполняются элементы массива. Все просто, только надо обра тить внимание, что ось Y битовой карты направлена вниз, поэтому элемен ты массива заполняются в обратном порядке:

procedure TfrmGL.Makelmage;

va r i, j : Integer;

PixCol : TColor;

Глава 2. Двумерные построения Bitmap : TBitmap;

begin Bitmap := TBitinap. Create;

Bitmap. LoadFromFile ( 'Claudia.brr.p1 ) ;

For i := 0 to ImageHeight — 1 do For j := 0 to ImageWidth — 1 do begin PixCoi := Bitmap.Canvas.Pixels [j, i];

// перевод цвета из TColor в цвет для команд OpenGL Image[ImageHeight - i - 1][j][0] := PixCoi and SFF;

Image[ImageHeight - i - 1][j][1] := (PixCoi and $FF00) shr 8;

Image[ImageHeight - i - 1][j][2] := (PixCoi and 3FF0000) shr 16;

end;

Bitmap.Free;

end;

Обратите внимание на строку, задающую выравнивание пикселов — без нее массив пикселов будет выводиться некорректно:

glPixelStorei (GLUNPACK_ALIGMMENT, I) ;

Возможно, при знакомстве с файлом справки вы обратили внимание на команду giBitKap, специально предназначенную для вывода битовых мас сивов. Растр в таком случае может быть монохромным, а не 24-битным.

Обычно эта команда используется для вывода текста, мы рассмотрим ее в главе 6.

Выводимые массивы пикселов легко масштабируются вызовом команды gipixeizoom, аргументы которой — масштабные множители по осям X и Y.

Для иллюстрации посмотрите проект из подкаталога Ех44, где нажатием клавиш 'X' и 'Y' можно управлять масштабом по соответствующим осям.

Обратите внимание, что при отрицательном значении множителей изобра жение переворачивается по соответствующей оси.

Этот пример демонстрирует также еще одно возможное использование команды glPixelStorei, позволяющей, в частности, прокручивать изобра жение по вертикали или горизонтали, что в нашей программе осуществляет ся нажатием клавиш 'R' и 'Р'.

^ Замечание j Учтите, что при прокрутке изображения на величину, превышающую половину растра, происходит аварийное завершение программы.

Команда gicopypixeis позволяет копировать часть экрана в текущей пози ции. Задаваемой glRasterPos.

В проекте из подкаталога Ех45 я воспользовался этой командой следующим образом: при нажатой кнопке мыши вслед за указателем мыши перемешает OpenGL. Графика в проектах Delphi ся копия левого нижнего угла экрана. Изображение восстанавливается при каждой перерисовке экрана.

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

Команда giPixeiTransfer позволяет задавать режимы вывода пикселов.

в частности, задавать цветовые фильтры. В примере, располагающемся в подкаталоге Ех46, нажатием клавиш 'R', 'G', 'В' можно изменить составляю щую долю соответствующего цвета.

Замечание ^ Надо отметить, что команды непосредственного доступа к пикселам экрана ра ботают сравнительно медленно, поэтому используются только в исключитель ных случаях.

Команда giReadPixels позволяет считывать содержимое всего экрана или части его. Это одна из самых важных для нас команд, мы еще неоднократно будем к ней обращаться.

Для иллюстрации ее работы я подготовил проект (подкаталог Е.\47), вы водящий на экран простейшие стереокартинки. Одна из них показана на рис. 2.14.

Рис. 2.14. Если вы умеете смотреть на стереокартинки, то увидите здесь парящий квадрат. Картинка рассчитана на размеры монитора, не ручаюсь, что в книге эффект повторится В примере реализован следующий алгоритм: экран заполняется множеством маленьких черно-белых квадратиков, создающих хаос. Затем небольшая об Глава 2. Двумерные построения ласть экрана размером 50x50 пикселов считываете?! в массив и последова тельно копируется восемь раз, в две строки по четыре квадрата впритык.

Вот фрагмент кода для первой копии:

Pixel : Array [0..50, 0..50, 0..2] of GLUbyte;

// считываем в массив часть образа экрана вблизи центра glReadPixels(round(ClientWidth 12), roundiClientHeight • />, bO, 50, GL_RGB, GL_UNSIGNED_BYTb, @?ixel);

g!RasterPos2f (-0.5, 0.0);

// устанавливаем точку вывода glDrawPixels(50, 50, GL RGB, GL UN3IGNED_BYTE, 3pixe:i;

// вывод копим В принципе, достаточно однократного копирования, но тогда требуется осо бое мастерство для того, чтобы увидеть объемное изображение.

Чтобы скрыть уловку, можно еще набросать на экране немного точек или линий, но разглядеть после этого спрятанный квадрат становится труднее.

При нажатии клавиши <пробел> экран перерисовывается, так что у вас есть возможность подобрать наиболее удачную картинку.

Команда gIGetString Вы, наверное, обратили внимание, изучая справки по командам-расши рениям, что приложение может получить информацию об имеющихся рас ширениях OpenGL с помощью команды giGe-iistring. Из соответствующей справки выясняем, что результат работы команды — строка типа рег.а:, а аргументом может быть одна из четырех констант.

В зависимости от используемой константы строка содержит информацию о фирме-производителе или способе воспроизведения, версии OpenGL и имеющихся расширениях стандарта.

На основе использования этой функции построен пример, располагающийся в подкаталоге Ех48. Результат работы программы представлен на рис. 2.15.

/ gG t u g I eS i n К о м п а н и я - п р о и з в о д и т е л ь : NVIDIA Coiporation Способ в о с п р о и з в е д е н и я : HIVA TNT/AGP Версий: 1 1. GL_EXT_bgra GL_EXTclip_volume_hint Gl Расширения GL_ARB_multitextun

П Использовать команду giGetstring, точно так же, как и любую другую функцию OpenGL, мы можем только тогда, когда установлен контекст 78 OpenGL. Графика в проектах Delphi воспроизведения, хоть в данном случае не осуществляется никакого вос произведения вообще.

П Результат работы этой функции — длинная строка, заканчивающаяся ну лем, поэтому для использования в модуле Delphi конвертируем ее с по мощью функции strPas.

Этот пример дает еще одну подсказку, как распознать наличие графического акселератора: при отсутствии такового giGetstring с аргументом и:._?1МЕ>г-:~;

;

< ВОЗВращаеТ СТрОКу 'GDI G e n e r i c '.

В файле справки можно также прочитать, что g.LGenstring с аргументом GL_EXTENSIONS возвращает строку, где через пробел перечисляются поддер живаемые текушим соединением расширения.

В часТНОСТИ, СОГЛаСНО Документации, КОМаНДОЙ glDrawArrays МОЖНО ПОЛЬЗО ваться, только если в расширениях присутствует GL_EXT_vertex зггау. Это одно из спорных мест, потому что я с успехом применяю расширение мас сива вершин, хотя в указанном списке ссылка на его наличие отсутствует.

Поэтому я бы не советовал полностью доверяться возвращаемому списку.

Не стоит и в программах сразу же прекращать выполнение, если вы опирае тесь на расширение стандарта OpenGL, которое не определяется. По-моему, в такой ситуации достаточно просто предупредить пользователя о возмож ных сбоях в работе программы.

Обработка ошибок Использующее OpenGL приложение по ходу работы может выполнять не корректные действия, приводящие к ошибкам в работе. Часть ошибок носит фатальный характер, ведущий к аварийному завершению работы приложе ния. Другие могут и не приводить к такому финалу, но код воспроизведе ния, содержащий ошибку, не выполняется. Пример такой ошибки, который я уже приводил — неверная константа в качестве аргумента функции giBegin или неверное количество вершин для воспроизведения примитива. Конеч но, компилятор не может и не должен распознавать подобные ошибки, но и OpenGL не может отработать такие указания клиента. В документации по OpenGL к каждой команде прикладывается раздел "Errors", содержащий ука зания, какие ошибки могут возникнуть при использовании этой команды.

Команда OpenGL giGetError возвращает информацию об ошибке в виде од ной из семи констант. Обратите внимание, что в свою очередь эта команда сама может генерировать ошибку, если вызывается внутри командных ско бок OpenGL.

На использовании этой функции построен пример, располагающийся в подкаталоге Ех49. В программе из-за заведомо неверного аргумента функции QLBQQITL генерируется ошибка библиотеки OpenGL типа GL :N:VALID гмиг-:.

Глава 2. Двумерные построения Соответствующее сообщение выводится в заголовке окна, использовать диа логовые окна в такой ситуации нежелательно, поскольку это приведет к пе рерисовке окна, т. е. снова будет сгенерирована ошибка.

В программе также введена пользовательская функция, возвращающая стро ку с описанием ошибки:

function GetError : String;

begin Case glGetError of GL_TNVALID_ENUM : Result :- 'Неверный аргумент!';

GL Л NVALID_VALUE : Result := 'Неверное значение аргумента!';

GL_INVALIDjOPERATION : Result := 'Неверная операция!';

GL_rTACK OVERFLOW : Result :- 'Переполнение стека!';

GL_iTACK_UNDERFLOW : Result := 'Потеря значимости стека!';

GL_OUT_OF_MEMORY : Result := 'He хватает памяти!1;

GL_NO_ERROR : Result := 'Нет ошибок.';

end;

end;

Масштабирование Мы уже знаем, что границы области вывода лежат в пределах от—I до I.

Это может привести к неудобству при подготовке изображений. К счастью.

OpenGL предоставляет удобное средство на этот случай — масштабирование.

Разберем его на примере программы построения фигуры, показанной на рис. 2.8. Для изменения масштаба используется команда giscaief с тремя аргументами, представляющими собой масштабные множители для каждой из осей.

Например, если перед командными скобками вставим строку:

glScaief 0.5, 1.0!;

, (О.Ъ, то будет нарисована уменьшенная в два раза фигура (готовый проект распо лагается в подкаталоге Ех50).

После команд рисования необходимо восстановить нормальный масштаб, т. е. в данном случае добавить строку:

glScalef (2.0, 2.0, 1.0};

.

Есть и другой способ запоминания/восстановления текущего масштаба, но о нем мы поговорим позднее.

Восстанавливать масштаб необходимо для того, чтобы каждое последующее обращение к обработчику перерисовки экрана не приводило бы к последо вательному уменьшению/увеличению изображения. В принципе, можно не SO OpenGL. Графика в проектах Delphi пользовать и флаги для того, чтобы обратиться к строке единственный раз в ходе работы приложения.

Масштабные множители могут иметь отрицательные значения, при этом изображение переворачивается по соответствующей оси. Иллюстрирующий это свойство проект находится в подкаталоге Ех51.

При двумерных построениях значение коэффициента по оси Z безразлично, единица взята без особых соображений.

Поворот Для поворота используется команда qiRotatef с четырьмя аргументами: угол поворота, в градусах, и вектор поворота, три вещественных числа.

Для двумерных построений наиболее нагляден поворот по оси Z, чем я и пользуюсь в приводимых примерах.

В предыдущем примере перед командными скобками вставьте строку:

gIRotatet (5, 0.0, 0.0, 1.0);

И СОЗДаЙТе О б р а б о т ч и к СОбыТИЯ K e y P r e s s С еДИНСТВеННОЙ КОМаНДОЙ R e f r e s h.

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

Здесь надо обратить внимание на две вещи: на то, что при положительном значении компоненты вектора поворот осуществляется против часовой стрелки и то, что важно не само значение компоненты, а ее знак и равенст во/неравенство ее нулю.

Хотя мы пока ограничиваемся плоскостными построениями, поворот по любой из осей сказывается на воспроизводимой картинке. Проверьте: при повороте по осям X и Y мы получаем правильную картинку в проекции с учетом поворота по осям.

Поворот часто используется при построениях, поэтому важно разобраться в нем досконально. Точно так же, как было с масштабом, поворот действует на все последующие команды воспроизведения, так что при необходимости текущее состояние восстанавливается обратным поворотом.

Например, если надо нарисовать повернутый на 45 градусов квадрат, т. с.

ромб, то код должен выглядеть так (готовый проект можете взять в подката логе Ех53):

glRotatof (45, 0.0, 0.0, 1.0);

дLBegin (GL_POLYGON) ;

glVertex2f (-0.6, -0.1);

giVertex2f (-0.6, 0.4);

Глава 2. Двумерные построения glVertex2f (-0.1, 0.4);

glVertex2f (-0.1, •- G. 1) ;

glEnd;

giRotat-f (-45, 0.0, 0.0, 1.0);

Этот пример очень занимателен и вот почему. Удалим восстановление угла поворота и запустим приложение. Увидим не ромб, а квадрат. При внима тельном рассмотрении обнаружим, что квадрат был повернут дважды. Про изошло это потому, что сразу после появления окна па экране (функция r API showWindow) происходит его перерисовка ( ф у н к ц и я API > ^ - * ••••^-•-i.•_•}.

Если вы были внимательны, то могли заметить, что такой же эффект на блюдался и в предыдущем примере.

При выполнении операции поворота можно спросить: поворачивается изо бражение или точка зрения? Мы будем для ясности считать, что поворачи вается именно изображение. Следующий пример пояснит это.

( Замечание i Точный ответ такой: все объекты в OpenGL рисуются в точке отсчета системы координат, а команда glRotato осуществляет поворот системы координат.

Нарисуем две фигуры: квадрат и ромб, причем ромб получим путем поворо та квадрата. Текст программы будет такой (проект из подкаталога Пх54):

glRota-ef (45, 0.0, 0.0, 1.0);

glBegin ! L PO LYGON);

G g l e t x f 1,-0.6,.Vre2 -0.1};

glVertex2f ( 0 6 0.4) ;

-., glVertexzf ( 0 1 0.4);

-., glVertex2f ( 0 1 -0.1);

-., glEnd;

glRota-ef (4 5, 0.0, 0.0, 1.0);

glBegin ( L POLYGON) ;

G glVertex2f { 0.1, -0.1);

glVertex2f fO.l, 0.4) ;

giVectex2f (0.6, 0.4) ;

glVGrtex2f (0.6, -0.1) ;

glEnd;

Точно так же нам придется поступать всегда, когда на экране присутствует несколько объектов, повернутых относительно друг друга: перед рисованием очередного объекта осуществлять поворот, а после рисования — возвращать точку зрения или осуществлять следующий поворот с учетом текущего по ложения точки зрения.

Пожалуйста, будьте внимательны! Начинающие пользователи OpenGL по стоянно задают вопрос, как повернуть примитив, не поворачивая остальные примитивы. Еще один раз перечитайте предыдущий абзац.

$2 OpenGL. Графика в проектах Delphi В заключение разговора о повороте рассмотрите проект (подкаталог Ех55).

основанный на примере с диском. При нажатой кнопке или движении кур сора происходит перерисовка окна и поворот диска на 60 градусов.

Чтобы вы могли оценить преимущества использования "низкоуровневых" приемов, окно перерисовывается в этих случаях по-разному:

procedure TfrmGL.FormKeyPress(Sender: TObject;

var Key: Char);

begin Refresh end;

procedure TfrmGL. FormMouseMove (Sender: TObject;

S i t : TShiitSbK.e;

X, hf;

Y: Integer);

begin invalidateRect (Handle, nil, False);

end ;

При нажатии кнопки хорошо видно мерцание на поверхности окна, кото рого не появляется при движении указателя мыши по его поверхности.

Перенос Перенос точки зрения (системы координат) осуществляется командой giTransiatef с тремя аргументами — величинами переноса для каждой из осей.

Все сказанное по поводу восстановления точки зрения справедливо и в от ношении переноса.

Рассмотрите пример из подкаталога Ех56, иллюстрирующий использование переноса системы координат. Думаю, особых пояснений здесь не потребу ется, поэтому перейдем к вопросу о совместном использовании поворота и переноса — это чаще всего и используется при построениях.

Программа из подкаталога Ех57 строит узор, показанный па рис. 2.16.

Стоит разобрать этот пример подробнее. В цикле шесть раз происходит пе ренос и поворот системы координат:

glTranslatef ( 0 3 0.3, 0.01;

-., glRotatef (60, 0, 0, 1) ;

Кружочки рисуются в текущей точке отсчета системы координат, относи тельно которой происходят каждый раз преобразования. По завершении цикла точка зрения возвращается точно в начальное положение, поэтому дополнительных манипуляций с системой координат не требуется.

Перед циклом делаем перенос для выравнивания картинки на экране:

qlTransldtef (0.4, 0.1, 0.0);

Глава 2. Двумерные построения Рис. 2. 1 7. Еще один пример Рис. 2. 1 6. Пример на комбинацию на поворот и перенос поворота и переноса После цикла, конечно, требуется восстановить первоначальное положение системы координат:

glTransIatef ( 0 4 -0.1, 0.0);

-., Разобравшись с этим примером, перейдите к примеру, располагающемуся в следующем подкаталоге, Ех58. Здесь строятся шесть квадратов по кругу, как показано на рис. 2.17.

Как и все предыдущие, этот пример тоже не отличается особой сложностью.

В цикле перед рисованием очередного квадрата смещаем и поворачиваем систему координат:

/ 3), 0. • cos ( i P sin (Pi * i / 3}, 0.0! ;

glTranslatef ( -.

glRotatef ( 6 * -0 О, 0, 1);

а после рисования очередного квадрата делаем обратные действия:

glRotaief ( 0 * i, 0, 0, 1);

0.0) ;

31, -0. glTranslatef (. * cos ( i 07 P Все, надеюсь, просто и понятно. Здесь только надо хорошенько уяснить, что порядок манипуляций с системой координат поменять нельзя: вначале пе ренос, затем поворот, по окончании рисования — в обратном порядке: по ворот, затем перенос. Если поменять порядок в любой из пар этих действий либо в обеих парах, будет рисоваться другая картинка — обязательно про верьте это самостоятельно.

Сохранение и восстановление текущего положения По предыдущим примерам вы должны были очень хорошо уяснить, на сколько важно восстанавливать текущую систему координат. При каждой 84 OpenGL. Графика в проектах Delphi следующей перерисовке окна она сдвигается и поворачивается, поэтому нам приходится постоянно следить, чтобы после рисования система координат вернулась в прежнее место. Для этого мы пользовались обратными поворо тами и перемещениями. Такой подход неэффективен и редко встречается в примерах и профессиональных программах, т. к. приводит к потерям ско рости воспроизведения. Если вы прочитаете справку по функциям giRctar.cf и giTransiatef, то узнаете, что эти функции реализуются как перемножение текущей матрицы на матрицы попорота и переноса, соответственно.

Обычно в состоянии, к которому потребуется затем вернуться, запоминают значение текущей матрицы. Вместо того чтобы заново перемножать матри цы и тратить время на операции, связанные с математическими расчетами, возвращаемся сразу к запомненному значению.

Команды g^fushMatrix и g: popMntrix позволяют запомнить и восстановить текущую матрицу. Эти команды оперируют со стеком, то есть, как всегда в подобных случаях, можно запоминать (проталкивать) несколько величин, а при каждом восстановлении (выталкивании) содержимое стека поднима ется вверх на единицу данных.

Использование этих функций делает код более читабельным, а воспроиз ведение — более быстрым, поэтому во всех оставшихся примерах мы. как правило, не будем производить малоэффективные действия по обратному перемножению матриц, а будем опираться на использование рассмотренных команд.

Для большей ясности рассмотрите пример из подкаталога Ех59 — модифика цию примера на шесть квадратов. В цикле перед операциями поворота и пе реноса запоминаем текущую систему координат (обращаемся к giPush^atnx), а после рисования очередного квадрата — восстанавливаем ее (вызываем ст.;

poptfat-iix). Надеюсь, понятно, что в стек помещается и извлекается из пего пять раз одна и та же матрица, причем в этой программе в стеке со держится всегда не больше одной матрицы.

Библиотека OpenGL позволяет запоминать и возвращать не только текущую систему координат, но и остальные параметры воспроизведения.

Посмотрите документацию по функции giGec, а конкретно, список моди фикаций этой функции, различающихся но типу аргумента в зависимости от запоминаемого параметра. Обратите внимание, что второй аргумент функ ции — всегда указатель на переменную соответствующего типа, поэтому все функции заканчиваются на "v". Первый аргумент — символическая констан та, указывающая, какой параметр запоминаем.

Закрепим изученный материал разбором проекта из подкаталога ЕхбО.

Рисуем три точки, первую и третью одинаковым цветом. Код следующий:

g.LCoIor3f" (1.0, 0.0, 0.0);

glCetFloatv (GL CURRENT COLOR, @Colox);

Глава 2. Двумерные построения glBegin (GL_POINTS);

glVertex2f (-0.25, —0.25•;

glColor3f (0.0, O.G, 1.С) ;

giVertex2f (-0.25, 0.25);

glCclor3f (Color ;

0 :, Color [1J, Color [2\ ;

;

glVertex2f (0.25, 0.25);

glEnd;

Для сохранения текущего цвета используется переменная г с ••.,;

.- гипа TGLArrayf3 (массив трех вещественных чисел). В качестве пояснения напом ню, что вторым аргументом giGev. должен быть указа!ель на переменную.

в которой сохраняется значение параметра.

Первые шаги в пространстве Во всех предыдущих примерах для задания вершин мы пеполыовали иер сию команды givertex с указанием двух координат вершин. Третья коорди ната, по оси Z, устанавливалась нулевой.

Для дальнейшего знакомства с OpenGL нам необходимо выяснить одну важную вещь, для чего попробуем рисовать примитивы с заданием третьей координаты, не равной нулю.

Взгляните па пример из подкаталога Ех61. Здесь рисуется треугольник со значением координаты вершин по Z равным текущему значению перемен ной h. При нажатии клавиш <пробел>+<5Ып> значение этой переменной увеличивается на единицу, если нажимать просто <пробел>. то "лкие ние переменной на единицу уменьшается. Значение переменной выводится в заголовке окна. После этого картинка перерисовывается.

Поработав с этим примером, вы можете обнаружить, что пока копр,!!: па i a по оси Z не превышает по модулю единицу, треугольник виден наблюд:ие лю. Вы можете уменьшить шаг изменения переменной h, чтобы повысить достоверность вывода, но результат окажется таким же: как шлько прпмпгпв выходит за пределы воображаемого куба с координатами вершин, имеющи ми по модулю единичное значение, примитив перестает быть пилимым.

Точнее, нам становится не видна часть примитива, выходящая за пределы этого куба. В примере из подкаталога Ех62 мы манипулируем координатой только одной из вершин треугольника, остальные не перемешаются и рас полагаются точно на плоскости. При движении третьей вершины в про странстве мы видим только ту часть треугольника, которая помещается и куб.

Этот пример иллюстрирует еще одну важную вешь. Помимо треугольник;

"!, здесь строится квадрат. Первым строится квадрат, вторым — треугольник.

Треугольник частично перекрывает квадрат так. как если бы ом был нарисо ван сверху. Если поменять порядок рисования примитивов, квадрат pneyci ся "выше" треугольника.

8 6 O p e n G L. Графика в проектах Delphi Замечание Итак, OpenGL воспроизводит только те части примитивов, координаты которых не превышают по модулю единицу. Примитивы с одинаковыми координатами рисуются по принципу: "каждый последующий рисуется поверх предыдущего".

Если вы не теряли внимание по ходу наших уроков, то должны были убедиться в правильности второго вывода, еще разбираясь с примером на связанные четырехугольники.

Последний пример этой главы достоин того, чтобы разобраться с ним под робнее. Обратите внимание, что при отрицательном значении переменной h треугольник строится все равно "выше" квадрата, т. е. пока мы не можем получить действительно пространственных построений, учитывающих вза имное положение примитивов в пространстве.

ГЛАВА Построения в пространстве Главной темой этой главы является трехмерная графика. Начнем мы с обзо ра методов, позволяющих достичь объемности получаемых образов, а в кон це главы будут описаны методы построения анимационных программ.

Глава завершает базовый курс изучения основ OpenGL, и после ее изучения читатель сможет создавать высококачественные трехмерные изображения.

Примеры к главе помещены на дискете в каталоге Chapter3.

Параметры вида В предыдущей главе мы убедились, что объем сцены ограничен кубом с ко ординатами точек вершин по диагонштям { — 1, —I, —1) и (1, 1, 1). Начнем дальнейшее изучение с того, что увеличим объем этого пространства. Про ект из подкаталога ExOl нам поможет. На сцене присутствует все тот же треугольник, одну из вершин которого можно перемещать по оси Z нажати ем клавиши <пробел>, значение координаты вершины выводится в заголов ке окна. Теперь мы видим треугольник целиком в пределах большего, чем раньше, объема.

Код перерисовки окна выглядит так:

wglMakeCurrent. (Canvas. Handle, г г г ) ;

.:

glViewporr (0, 0, Clier.tWidth, CiientHeighr) ;

glPushMatrix;

// задаем перспективу glFrustum (-1, 1, -1, 1, 3, 10);

// перенос объекта по оси Z glTrans-atef(0.0, 0.0, -5.0);

glClearColor (0.5, 0.5, 0.75, 1.0);

glClear (GL COLOR BUFFER BIT);

OpenGL. Графика в проектах Delphi glColoT3f (l.C, C O, 0.5);

qlBegin (GL_TRTANGLES);

g!Vertex3f" ( 1 -1, 0);

-, glVertex3f {-1, 1, 0) ;

qlVertexjf (1, 0, h);

owapBui'iers (Canvas. Handle) ;

wqlMakoCurrent (0, 0) ;

Основная последовательность действий заключена между командами rjiPushMatrix и giPopMatrjx. Если этого не делать, то при каждой перерисов ке окна, например, при изменении его размеров, сцена будет уменьшаться в размерах.

Здесь встречается новая для нас команда — qiFrusLum, задающая параметры вида, в частности, определяющие область воспроизведения в пространстве.

Все, что выходит за пределы этой области, будет отсекаться при воспроизве дении. Первые два аргумента задают координаты плоскостей отсечении сле ва и справа, третий и четвертый параметры определяют координаты плоско стей отсечения снизу и сверху. Последние аргументы задают расстояния до ближней и дальней плоскостей отсечения, значения этих двух параметров должны быть положительными — это не координаты плоскостей, а расстоя ния от глаза наблюдателя до плоскостей отсечения.

Замечание ^ Старайтесь переднюю и заднюю плоскости отсечения располагать таким обра зом, чтобы расстояние между ними было минимально возможным: чем мень ший объем ограничен этими плоскостями, тем меньше вычислений приходится производить OpenGL.

Теперь все, что рисуется с нулевым значением координаты Z, не будет вид но наблюдателю, поскольку ближнюю плоскость отсечения мы расположи ли на расстоянии трех единиц от глаза наблюдателя, располагающегося в точке (0, 0. 0). Поэтому перед воспроизведением треугольника смещаем систему координат на пять единиц вниз.

Треугольник удалился от наблюдателя, и его вершины располагаются уже не на границе окна, а сместились вглубь экрана.

Замечание } В главе 6 мы узнаем, как соотнести пространственные и оконные координаты, если видовые параметры заданы с помощью команды g, Frus t un..

Переходим к следующему примеру — проекту из подкаталога ЕхО2. Отличие ОТ Первого Примера СОСТОИТ В ТОМ. ЧТО команды g l P u s h M a t r i x И u.LPcpMatrix Глава 3. Построения в пространстве удалены, а перед вызовом команды gifrustum стоит вызов команды glLoadider.tity. Будем понимать это как действие "вернуться в исходное со стояние". При каждой перерисовке экрана перед заданием видовых пара метров это следует проделывать, иначе объем смены будет последовательно отсекаться из предыдущего.

{ Л Замечание Устанавливать видовые параметры не обязательно при каждой перерисовке экрана, достаточно делать это лишь при изменении размеров окна.

Это несложное соображение предваряет следующий пример — проект из подкаталога ЕхОЗ. Для повышения надежности работы приложения пользу емся яино получаемой ссылкой на контекст устройства, а не значением свойства Canvas.Handle. Сразу же после получения контекста воспроизведе ния делаем его текущим в обработчике события Create формы, а непосред ственно перед удалением освобождаем контекст в обработчике Destroy.

Теперь такие параметры OpenGL, как цвет фона и цвет примитивов, можно задавать единственный раз — при создании формы, а не выполнять это дей ствие каждый раз при перерисовке экрана. В отличие от всех предыдущих проектов, в данном появляется отдельный обработчик события, связанного с изменением размеров окна. Напомню, раньше при этом событии выпол нялся тот же код, что и при перерисовке окна.

Во всех оставшихся примерах, как правило, будет присутствовать отдельный обработчик события, связанного с изменением размеров окна. В этом обра ботчике задается область вывода и устанавливаются параметры вила, после чего окно необходимо перерисовать:

procedui e Tf rmGL. FormResize (Sender : TObj-ecL) ;

begin gIViewport (0, 0, CljentWidth, C l i e n t H e i g h t ) ;

glLoadidenticy;

g.l Frustum ( - 1, 1, - 1, 1, 3, 1 0 ) ;

// видовые параметры g l T r a n s i l a t e f ( C O, 0.0, —5.0);

// начальный сдвиг системы ко^рлин^'г I n v a l i c a t e R e c t (Hanaie, n i l. False;

'1 ;

end;

Код, связанный с перерисовкой окна, теперь сокращается и становится бо лее читабельным:

p r o c e d u r e TfrmGL.ForrePaint(Sender: TObject);

begin g l C l e a r {GL_COLOR_BUFFF.K BIT) ;

glBegin fGL_TRlANGLP:3) ;

g l V e r t e x 3 f (-]., - 1, 0) ;

OpenGL Графика в проектах Delphi gIVertex3f (-1, 1, 0);

glVertex3f (1, 0, h);

glEnd;

SwapBuffers(DC);

end;

Хоть мы уже и рисуем пространственные картинки, однако почувствовать трехмерность пока не могли. Попробуем нарисовать что-нибудь действи тельно объемное, например, куб (проект из подкаталога ЕхО4). Результат работы программы — на рис. 3.1.

J* Пространство Рис. 3. 1. В будущем мы получим более красивые картинки, начинаем же с самых простых Для придания трехмерности сцепе поворачиваем ее по осям:

procedure TfrmGL.FormResize(Sender: TObject);

begin glViowport (0, 0, ClientWidth, Client-Height) ;

glLoaaldentity;

giFrusLum (-1, 1, —1, 1, 3,. 0 ;

1) // задаем перспективу // этот фрагмент нужен для придания трехмерности gITranslat.ef (O.0, 0.0, -8.0);

/ перенос объекта - ось Z qlRotatef (30.0, 1.0, 0.0, 0.0);

поворот объекта - ось X glRotatef [70.0, 0.0, 1.0, 0.0);

поворот объекта - ось Y Invalidat-eRect (Handle, nil, ^alsei ;

end;

Построение куба сводится к построению шести квадратов, отдельно для каждой стороны фигуры:

glBegin ( L _ U D ) ;

G_QAS g±Vertex3f (1.0, 1.0, 1.0);

glVerrex3f ( 1 0 1.0, 1.0);

-., g ! V r. x f ( 1 0 -1.0, l.Cj;

..ere3 -., glVerrex3f (1.0, -1.0, l.C);

alEnd;

Глава 3. Построения в пространстве glBegin {GL_QUADS);

glVertex3i (1.0, i.0, -1.0);

glVertex3f (1.0, -l.C, -1.0);

qlVertex3f (-1.0, -1.0, -1.0);

glVertex3f (-1.0, 1.0, -1.0);

glEnd;

glBegin (GLjQUADS);

glVer-ex3f (-1.0, 1.0, 1.0);

glVertex3f (-I.C, 1.0, - 1. 0 ) ;

J g!Ver ;

ex3f (-1.0, -1.0, -1.0);

glVertex3f (-1.0, -1.0, 1.0};

giEnd;

glBegin {GL_QUADS);

glVertex3f (1.0, 1.0, 1.0);

glVertex3f (1.0, -1.0, 1.0);

glVertex3f (1.0, -1.G, - 1. 0 ) ;

g.LVertex3f (1.0, 1.0, - 1. 0 ) ;

glEnd;

glBegin (GL_QUADS);

glVertex3f (-1.0, 1.0, - 1. 0 ) ;

glV G rtex3f (-1.0, 1.0, 1.0);

glVertex3f (1.0, 1.0, 1.0);

glVertex3f (1.0, 1.0, - 1. 0 ) ;

glEnd;

glBegin(3L_QUADS);

g!Vertex3f (-1.0, -1.0, --1.0);

glVertex3f {1.0, -1.0, -1.0;

;

glVercex3f (1.0, —1.0, 1.0);

glVer-ex3f (-1.0, -1.0, 1.0);

glEnd;

Код получается громоздким, согласен.

Замечание J Для некоторых базовых фигур мы сможем в будущем найти возможность со кратить код, но в общем случае объемные объекты строятся именно так, т. е.

из отдельных плоских примитивов.

Я хочу предостеречь вас на случай, если вы желаете прямо сейчас потрени роваться и нарисовать что-нибудь интересное. Пока что наши примеры сильно упрощены, могут быть только учебной иллюстрацией и не годятся в качестве шаблона или основы для построения более серьезных программ.

OpenGL. Графика в проектах Delphi Получившаяся картинка действительно трехмерная, но пространственность здесь только угадывается: куб залит монотонным цветом, из-за чего плохо попятно, что же нарисовано. Сейчас это не очень важно, мы только учимся плакать видовые параметры. Для большей определенности в ближайших примерах будем рисовать каркас куба, как, например, в следующем приме p.j -- проекте из подкаталога F.xO5 (рис. 3.2).

( ГПространство К Рис. 3.2. Для ориентировки в пространстве будем рисовать каркасную модель куба Чтобы выводить только ребра куба, после установления контекста воспроиз веден им задаем нужный режим воспроизведения полигонов:

Т АНН !G1 П По [учившаяся картинка иллюстрирует важную вещь: использование коман ды ::•",•.., 1,г приводит к созданию перспективной проекции. Хорошо видно, _п _ что ребра куба не параллельны друг другу и имеют точку схода где-то на го ри,сжте.

Чтобы помочь вам лучше разобраться с одной из важнейших команд биб.нкмоки OpenGL, я написал пример, расположенный в подкаталоге ЕхОб.

В пом примере аргументы команды — переменные:

Нажатием ил пробел можно приблизить точку зрения к сцене, если при '•?;

.-м у.гержииать клавишу , точка зрения будет удаляться.

Чюоы приблизить точку зрения, варьируем с помощью первых четырех щмлментов параметры перспективы, уменьшая объем сцены, для удаления и пространстве проводим обратную операцию.

Затем заново обращаемся к обработчику Resize формы, чтобы установить riitpaueipLi перспективы в обновленные значения и перерисовать окно:

'.:: л - у - VK SFACF, t h e n bog.: г:

/,';

'•-::•:: :i'X in j n i i f t. ! h e n b e g i n нажат уда;

;

^мсч -.'. S'r.iLL, v L e R := v L e f t -• G. I ;

Глава 3. Построения в пространстве vRight :- vRighr + 0.1;

vBottom :- vBottcin — O.I;

vTop := vTop + 0.1;

• end else begin // лриолижаемся vLeft: : = vLeft + С. 1;

vRight :- vRight -• 0.1;

vBottom := vBoLtom t- 0.1;

vTop := vTop - G.I;

end;

FormResize(nil);

end;

Аналогично клавишами управления курсором можно манипулировать зна чениями каждой из этих четырех переменных в отдельности, а клавиши и отвечают за координаты ближней и дальней плоскостей отсечения.

Так, если чересчур близко к наблюдателю расположить залнюю плоскость отсечения, дальние ребра куба станут обрезаться (рис. 3.3).

А' Пространство Рис. 3.3. Вот что происходит с кубом, если заднюю плоскость приближать слишком близко Еще один способ приблизить к сцене точку зрения — уменьшать значение координаты передней плоскости отсечения. Возможно, это более практич ный способ, поскольку у первого способа есть один недостаток: если при ближаться к сцене чересчур близко, картинка переворачивается и при даль нейшем "приближении" удаляется, оставаясь перевернутой.

Замечание Это в принципе два разных способа навигации в пространстве, и, если быть точным, оба они не перемещают точку зрения. Можно для этих нужд не изме нять параметры вида, а действительно смещать в пространстве систему коор динат.

OpenGL. Графика в проектах Delphi Теперь мы перейдем к другой проекции — ортографическсш. параллельной.

Посмотрим проект из подкаталога ЕхО7, результат работы которого показан на рис. 3.4.

/?gl0rtho Рис. 3.4. Великий Леонардо нашел бы эту картинку нелепой, но чертежник должен быть довольным Отличается эта проекция от перспективной именно отсутствием перспекти вы. В обработчике изменения размеров окна видовые параметры задаются с помощью команды giortho:

procedure TfrmGL.FormResize(Sender: TObject);

begin glViewport(0, 0, ClientWidth, ClientHeight);

glLoadlcientity;

g l O r t h o {-2, 2, - 2, 2, 0, 1 5. 0 ) ;

// видовые параметры giTranslatef (0.0, 0.0, -10.fi);

// перенос системы координат по оси Z giRotatef (30.0, 1.0, 0.0, 0.0);

// поворот системы кооодинат по оси X giRotatef (60.0, CO, 1.0, 0.0);

// поворот системы координат го оси Y InvalidaneRect {Handle, nil, False;

;

end;

Аргументы КОМаНДЫ g l O r t n o ИМеЮТ ТОЧНО ТаКОЙ Же СМЫСЛ, ЧТО И у g l F r u s t u f l i.

но последние два аргумента могут иметь отрицательное значение.

Помимо этих двух команд, OpenGL предоставляет еще несколько возмож ностей установки видовых параметров, например, библиотека glu содержит команду giuOrtho2D. Эта команда имеет четыре аргумента, смысл которых такой же, как и у giorthc. По своему действию она эквивалентна вызову giortho с указанием значения расстояния до ближней плоскости отсечения равным минус единице, и расстоянием до дальней плоскости отсечения равным единице..

Как при такой проекции выглядит куб из предыдущих примеров, показано на рис. 3.5, а проект находится в подкаталоге ЕхО8.

Глава 3. Построения в пространстве JT gluPerspeclive J * Пространство Рис. 3.5. Командой gluOrtho2D следует Рис. 3. 6. Так работает команда пользоваться с осторожностью, gluPerspective но с точки зрения скорости воспроизведения она является оптимальной Обратите внимание, что здесь отсутствует начальный сдвиг по оси Z:

procedure TfrmGL.FormResize(Sender: TObject);

begin glViewport (0, 0, C i r t. d h C\ ientHei ght) ;

le.Wit, glLoadIdentity;

giuOrtho2D (-2, 2, —2, 2 ) ;

// задаем перспективу glRotatef (30.0, 1.0, 0.0, 0.0);

// поворот объекта -- ось X qlRotattif (60.0, O.G, 1.0, 0.0);

// поворот объекта - ось Y InvalidateRect(Handle, nil, False);

end;

Куб рисуется вокруг глаза наблюдателя и проецируется на плоскость экрана.

Согласно установкам этой команды передняя и задняя части нашего куба частично обрезаются.

Следующая команда, которую мы рассмотрим, пожалуй, наиболее популяр на в плане использования для первоначального задания видовых парамет ров. Команда giuPerspective, как ясно из ее названия, также находится в библиотеке glu. Проект примера содержится в подкаталоге ЕхО9, а полу чающаяся в результате работы программы картинка показана на рис. 3.6.

Смысл аргументов команды поясняется в комментариях:

procedure TfrmGL.ForreResize(Sender: TObject);

begin glViewport(0, 0, ClientWidnh, ClientHeight);

glLoadldentity;

OpenGL, Графика в проектах Delphi 9b ••";

ллпм перспективу Г _:stjtie ;

f - : b :c. v ;

30. 0, / / угол видимости в направлении оси Y С], "•"т: Width / Client Нет qht, // у:-on видимости в направлении оси X ''.г i.0, // одсстояние от наблюдателя до ближней плоскости отсечения 10.0);

// расстояние от наблюдателя до дальней плоскости отсечения "rans\=tef (0.0, G.C, -10.0);

// перенос - ось Z •,. t - (30,0, 1.0, 0.0, 0.0) ;

/ / поворот — ось X r:a;

L :.. l a i o L {60.0, 0.С, 1.0, 0.0);

// поворот LnvaIiJdtnRect (Handle, Fa.se;

;

Замечание В главе 4 мы узнаем, как соотносятся аргументы команд giuPer.spec u v e и С перспективами, конечно, надо попрактиковаться. Настоятельно реко мендую разобраться с примером из подкаталога ЕхЮ. Клавиши управления курсором позволяют манипулировать значениями первых двух аргументов команлы.п;

-Ре г spec I ive. При уменьшении первого аргумента происходит приближение глаза наблюдателя к сиене, уменьшение второго аргумента при водит к тому, что сиена растягивается в поперечном направлении (рис. 3.7).

Замечание ^ Как правило, в качестве значения второго аргумента команды gluPerspecii vc, так называемого аспекта, задают отношение ширины и высоты области вывода.

В проекте из подкаталога Exll я объединил все примеры на изученные команды установки видовых параметров (рис. 3.8). Вы имеете возможность cuix: pa:s уяснить различия между этими способами подготовки сцены.

gluPertpective Рис. 3.7. Изменения в видовых установках Рис. 3.8. Команды задания приводят к трансформации объектов видовых параметров чн экране Глава 3. Построения в пространстве Библиотека glu располагает еще одной вспомогательной командой, имею щей отношение к рассматриваемой теме — giuLookAt. У нее девять аргумен тов: координаты позиции глаза наблюдателя в пространстве, координаты точки, располагающейся в центре экрана, и направление вектора, задаю щего попорот сцены (вектор "up").

При использовании этой команды можно обойтись без начальных операций со сдвигом и поворотом системы координат. Ее работу демонстрирует проект из подкаталога Ех12 (рис. 3.9).

Р и с. 3. 9. Командой gluLookAt: удобно пользоваться при перемещениях точки зрения в пространстве Рис. 3. 1 0. Команду g l u L o o k A t нужно изучить основательно При задании параметров вида ограничиваемся минимумом команд:

glLoadlcentity;

gluPerspective (50.0, ClientWidth / ClientHeight, 2.0, 10.0);

4 Ък 1 ? I' 98 OpenGL. Графика в проектах Delphi gluLookAt (2.7, 2, 2.5, 0.4, 0.5, 0.5, 0, 0, 1);

InvalidateRect(Handle, nil, False);

На рис. 3.10 показаны экранные формы, выдаваемые программой из подка талога Ех13.

В них можно менять значения всех аргументов команды giuLockAt, и по скольку этих аргументов сравнительно много, я создал вспомогательную форму, в полях редактирования которой выводятся и задаются пользовате лем координаты всех девяти аргументов. Рекомендую обязательно попрак тиковаться с этим примером, чтобы "почувствовать" работу параметров. Об ратите внимание, что, как подчеркивается в документации, вектор "up" не должен быть параллельным линии, соединяющей точку зрения и контроль ную точку.

Матрицы OpenGL При Обсуждении Команд glRotatef и giTranslatef МЫ уже обращали ВНИ мание на то, что их действие объясняется с позиций линейной атгебры. На пример, про команду giTranslatef в соответствующем файле справки гово рится, что эта команда умножает текущую матрицу на матрицу переноса.

Аналогично glRotatef сводится к операции перемножения текущей матрицы на матрицу поворота. Многие изученные нами команды, действие которых я объяснял по их функциональному смыслу, в действительности описываются с помощью базовых понятий раздела математики, изучающего вопросы, свя занные с геометрическими операциями, например, такими, как проекция.

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

Я сознательно не включил в книгу изложение математических основ для всех подобных команд, поскольку замыслил ее прежде всего как практиче ское руководство по компьютерной графике. Мне кажется, что многие чита тели не очень хотели бы особо углубляться в дебри формул. Это отнюдь не значит, что я пытаюсь принизить значение математической грамотности.

Просто мой опыт преподавания подсказывает, что очень многие програм мисты предпочитают руководства, делающие упор на практике.

К счастью, существует масса литературы по компьютерной графике, уде ляющей много внимания математике, где подробно рассказывается об опера циях перемножения матриц и прочих подобных вопросах. Если вы все-таки испытаете необходимость в более основательной теоретической подготовке, найти подходящее пособие не составит большого труда.

Глава 3. Построения в пространстве 99_ Однако и в нашей практической книжке без представления о некоторых специальных терминах не обойтись. Ограничимся самым необходимым.

В OpenGL имеется несколько важных матриц. Матрица модели ("modelview matrix") связана с координатами объектов. Она используется для того, чтобы в пространстве построить картину как бы видимую глазу наблюдателя. Дру гая матрица, матрица проекций ("projection matrix"), связана с построением проекций пространственных объектов на плоскость.

Матрица проекций, имея координаты точки зрения, строит усеченные ("clip") координаты, по которым после операций, связанных с перспективой, вычисляются нормализованные координаты в системе координат устройства ("normalized device coordinates"). После трансформаций, связанных с об ластью вывода, получаются оконные координаты.

Координаты вершин в пространстве и на плоскости проекций четырехмер ные, помимо обычных координат есть еще w-координата. Поэтому матрица модели и матрица проекций имеют размерность 4x4.

Перенос и поворот системы координат сводится к операции перемножения матриц, связанных с текущей системой координат, и матриц переноса и по ворота. Библиотека OpenGL располагает набором команд, связанных с эти ми операциями, а также имеет универсальную команду для перемножения матриц: giMuitMatrix. При желании и наличии математической подготовки этой командой можно заменить команды переноса, поворота и ряд других.

Посмотрим, как это делается.

В проекте из подкаталога Ех14 команда начального переноса заменена коман дой giMultMatrix. Для этого введен массив 4x4, хранящий матрицу переноса:

mt : Array [0..3, 0..3] of G L f l o a t ;

Матрица переноса заполняется нулями, кроме элементов главной диагона ли, которые должны быть единицами, и последней строки, содержащей век тор переноса. В примере перемещение осуществляется только по оси 2:

mt [О, О;

:= 1;

mt [1, 1] := 1;

mt [2, 2] :=- 1;

mt [3, 3] := 1;

mt [3, 2] := -8;

Стартовый сдвиг теперь осуществляется так:

glMultMatrixf (@rnt) ;

Если надо вернуться к исходной позиции, текущая матрица заменяется мат рицей с единицами по диагонали и равными нулю всеми остальными эле ментами, единичной матрицей. Это и есть действие команды giLcadidentity.

Она является частным случаем более универсальной команды < 100 OpenGL. Графика в проектах Delphi предназначенной для замены текущей матрицы на заданную, ссылка на ко торую передается в качестве аргумента.

Без примера эти команды не усвоить, поэтому загляните в подкаталог Ех15.

Массив mt аналогичен единичной матрице. Команда g:r,oadident: ty отсут ствует, вместо ее вызова используется явная загрузка единичной матрицы:

glLoadMatrixf (Prat) ;

После знакомства с матричными операциями становится яснее технический смысл команд g.iPushMatrix и giPopMarrix, запоминающих в стеке текущую матрицу и извлекающих ее оттуда. Такая последовательность манипуляций выполняется быстрее, чем вызов giLoadMatrix. To же самое можно сказать и по поводу giLoadidentity, т. е. единичная матрица загружается быстрее командой glLoadlderiLity, Ч М qlLoadMatirix.

С Замечание ) Чем реже вы пользуетесь командами манипулирования матрицами, тем быст рее будет работать программа. Но учтите, что если на сцене присутствует не больше пары десятков объектов, все манипуляции с матрицами съедают один кадр из тысячи.

Узнать, какая сейчас установлена матрица, можно с помощью команды GJGai. Во всех наших предыдущих примерах мы задавали параметры вида применительно к матрице, установленной по умолчанию. Определим, какая это матрица.

Подкаталог Ех!б содержит проект, который нам в этом поможет. Обработчик Resize формы дополнен выводом в заголовке окна имени текущей матрицы:

Y-т. T wrk : GLUIr.t;

begin glGeuIntegerv (G1_MATRI"X_MCDE, @wrk) ;

сазе wrk of GL MOCELVIEW : C a p t i o n : = ' GL_MODELVIEW' ;

GL_ PROJECTION : Cap!, i o n := ' GL_PROJECTION' ;

end;

Запустив проект, выясняем, что но умолчанию в OpenGL установлена мат рица модели.

Итак, во всех предыдущих примерах операции производились над матрицей модели.

В любой момент мы можем выяснить знамение этой матрицы. Проиллюст рируем примером — проектом из подкаталога Ех17. При создании формы массив 4x4 заполняется матрицей модели:

glGetFloatv (GL_MODELVIEW MATRIX, @mt);

Глава 3. Построения в пространстве При выборе пункта меню появляется вспомогательное окно, в котором вы водится текущая матрица модели (рис. 3.11).

Рис. 3. 1 1. Вывод содержимого матрицы модели При первом появлении окна эта матрица совпадает с единичной матрицей:

по главной диагонали единицы, все остальные элементы равны нулю. Коман да giLoadidentity в этой программе также заменена явной загрузкой матрицы.

В проекте имеется возможность варьировать загружаемую матрицу, по нажа тию на кнопку "ОК" она устанавливается в модели.

Сейчас у вас имеется прекрасная возможность попрактиковаться в матрич ных операциях. Например, числа на главной диагон&чи являются масштаб ными множителями по осям. Поменяйте первые из этих двух чисел произ вольно для масштабирования по осям X и Y.

( Замечание ^ Для одного из примеров следующей главы нам важно уяснить, что нулевое значение первого или второго из диагональных элементов приведет к проекции сцены на плоскость.

Если вы внимательно прочитали этот раздел, то полученных знаний о мат рицах теперь достаточно для того, чтобы нарисовать все что угодно. Оста лось узнать еще одну команду — giMatrixMode. Она позволяет установить текущую матрицу.

Проекты всех предыдущих примеров подходят только для простейших про странственных построений, таких как рисование каркаса кубика. Для более сложных программ они не годятся из-за одного упрощения.

Для корректного вывода пространственных фигур параметры вида задаются при установленной матрице проекции, после чего необходимо переключить OpenGL. Графика в проектах Delphi ся в пространство модели. То есть обычная последовательность здесь, на пример, такая:

glViewport (0, 0, Clier.tWidth, C l i e n t H e i g h t ) ;

gLMatrixMode (GL_PROJECTION);

glLoadldentity;

glFrustum (-1, 1, - 1, 1, 3, 10);

giMatrixMode (GL_MODELVIEW);

glLoadldentity;

Замечание На простейших примерах мы не почувствуем никакой разницы и не поймем, что же изменилось. Позже я попробую показать, с чем связана необходимость вы полнения именно такой последовательности действий.

Напоминаю, что параметры вида обычно помещаются в обработчике изме нения размеров окна. Стартовые сдвиги и повороты обычно располагают ся здесь же, а код воспроизведения сцены заключается между командами glPushMatrix И glPopMatrix.

Иногда поступают иначе: код воспроизведения начинается с giLoac:der.ti-y.

а далее идут стартовые трансформации и собственно код сцены.

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

Сейчас мы рассмотрим пару примеров на темы предыдущей главы, которые мы не могли рассмотреть раньше из-за того, что в них используются коман ды задания вида. Начнем с проекта из подкаталога Ех18 — модификации классической программы, поставляемой в составе OpenGL SDK. Программа рисует точку и оси системы координат (рис. 3.12).

Р и с. 3. 1 2. Результат работы проекта Point Test Глава 3. Построения в пространстве Клавишами управления курсором можно передвигать точку, нажатием кла виши 'W размер точки можно уменьшать, если же нажимать эту клавишу вместе с , то размер точки увеличивается. Первая цифровая клавиша задает режим сглаживания точки. Обратите внимание, что при установлен ном режиме сглаживания размер получающегося кружочка ограничен неко торыми пределами, для точек больших размеров он не вписывается точно в квадрат точки. Если точнее, то в примере рисуется две точки — вторая рисуется зеленым цветом посередине первой. Вторая точка не изменяется в размерах и всегда выводится несглаженной, но с единичным размером.

Пример можно использовать в качестве простого теста, скорость передви жения большой по размеру точки позволяет оценить возможности компью тера.

Посмотрите внимательно, как в этом примере задаются видовые параметры.

Здесь интересно то, что плоскости отсечения привязаны к текущим разме рам окна:

glViewport(0, 0, ClientWidth, ClientHeight);

glMatrixMode (GLPROJECTION) ;

glLoadldentity;

gluOrt±x2D(-ClientWidth/2, ClientWidth/2, -ClientHeight/2, ClientHeight/2);

glMatrixMode(GL_MODELVIEW);

glLoadldentity;

Теперь при изменении размеров окна картинка не масштабируется, а изме няются размеры видимой части пространства. Если точку поставить вблизи границы окна, при уменьшении его размеров точка пропадает, выходит за пределы видимости. В примерах предыдущей главы в такой ситуации точка перемешалась внутрь окна пропорционально его размерам.

Координаты точки хранятся в массиве трех вещественных чисел, вершина воспроизведения задается командой с окончанием V. Аргументом в этом случае является указатель на массив:

glBegin(GLPOINTS) ;

glVertex3fv (@point);

glEnd;

Замечание Напоминаю, что эта — векторная — форма команд является оптимальной по скоростным показателям.

Следующий пример, проект из подкаталога Ех19, тоже может использовать ся в качестве простого теста скоростных характеристик компьютера.

Здесь рисуется серия отрезков прямых, наподобие разметки циферблата часов. В начале и в конце каждого отрезка рисуются точки.

OpenGL. Графика в проектах Delphi В примере видовые параметры опираются на конкретные числа:

q] Viewport (0, 0, ClientWidth, С! ientHeighO ;

glKatrixMcde(GL_PROJECTION;

;

glLoadlder.tity;

gluOrtho2D (-П5, 17Ь, -175, 175);

glMatrixMode(GLJYTODELVIEW);

glLoadldentity;

Поэтому при изменении размеров окна картинка масштабируется так, что вся сиена всегда вписывается в экран.

Клавиша 'W все так же позволяет регулировать ширину линий, первые две цифровые клавиши отведены для управления двумя режимами воспроизве дения: первый режим включает штриховку линий, второй задаст сглажива ние отрезков.

Управляя этими тремя параметрами, можно получать разнообразные кар тинки, например такую, как приведена на рис. 3.13.

Рис. 3.13. Получить такие узоры на самом деле легко Поработав с данным примером, вы должны уяснить для себя, что и для сглаженных отрезков есть ограничение — по ширине.

Также полезно разобраться, как в этом примере рисуется система отрезков.

Два массива залают координаты начала и конца единственного отрезка, этот отрезок рисуется в цикле, и каждый раз происходит поворот на пять градусов:

glLi neWid.th (size) ;

// ширина отрезка Г"i.dl // режим, задающий штриховку отрезков roe tb.cn у 1 Enable (GL_L!r-JE_STIPP\,Ы) /,' использовать штриховку else giDisable(GL_LINE_STIPPLE);

// не использовать штриховку Tf :tiode2 // режим, задающий сглаженность отрезков then glEnable (GL LINE_SMOOTH) /7 сглаживать отрезки else glD.i sable (GL_LINE_SMOOTH) ;

// не использовать сглаженность glPushMatrlx;

// запоминаем систему кооодинат Глава 3. Построения в пространстве For i := 0 to 71 do begin // цикл рисования 12 отрезков glRctatef(5.О, 0, 0, 1);

// поворот на пять градусов glColor3f(1.0, 1.С, 0.0);

// цвет отрезков -- желтых glBegin(GL_LINE_STRIP);

// примитив - отрезок gIVertex3fv f@pntA);

// указатель на начало отрезка glVertex3fv(@pntB);

// указатель на конец отрезка glEni;

glColor3f(0.0, 1.0, 0.0);

// цвет точек — зеленый glBegin (GL_POINTS) ;

// примитив -- ТОЧКИ g.LVertex3fv (@pntA) ;

// точка в начале отрезка glVertex3fv(ispntB);

// точка в конце отрезка glEnd;

end;

glPopMatrix;

// возвращаемся в первоначальную систему координат Буфер глубины При создании контекста воспроизведения в число параметров формата пик селов входят размеры разделов памяти, предоставляемой для нужд OpenGL.

или буферов. Помимо буферов кадра, в OpenGL присутствуют еще три бу фера: буфер глубины, буфер трафарета и вспомогательный буфер.

Для специальных нужд могут использоваться еше буфер выбора и буфер об ратной связи, они подготавливаются пользователем по мере надобности.

Работа с буферами будет нами подробно изучена в соответствующих разде лах книги. В этом разделе мы познакомимся с буфером глубины.

Как ясно из его названия, он используется для передачи пространству. При воспроизведении каждого пиксела в этот буфер записывается информация о значении координаты Z пиксела, так называемая оконная Z. Если на пик сел приходится несколько точек, на экран выводится точка с наименьшим значением этой координаты.

При пространственных построениях отказ от использования буфера глуби ны приводит к неверной передаче пространства. Посмотрим, в чем тут дело.

Для удобства отладки я написал процедуру, строящую оси координат и по мечающую оси буквами X, Y и Z:

procedure Axes;

var Color ;

Array [1..4] of GLFloat;

begin alPusbKatrix;

OpenGL. Графика в проектах Delphi glGetFloatv (GL_CURRENT_COLOR, @Color) glScalef (0.5, 0.5, 0.5);

glColor3f (0, 1, 0);

gIBegin (GL_LINES);

glVertex3f (0, 0, 0);

glVertex3f (3, 0, 0);

glVertex3f (0, 0, 0);

glVertex3f {0, 3, 0);

glVertex3f {0, 0, 0 ) ;

gIVertex3f (0, 0, 3);

glEnd;

// буква X gIBegin (GL^LINES) ;

glVertex3f (3.1, -0.2, 0.5);

glVertex3f (3.1, 0.2, 0.1};

glVertex3f (3.1, -0.2, 0.1);

glVertex3f (3.1, 0.2, 0.5);

glEnd;

// буква Y gIBegin (GL^LINES) glVertex3f (0.0 3.1 0.0) ;

glVertex3f (0.0 3.1 -0 • 1, ;

glVertexjf (0.0 3.1 0.0);

glVertex3f (0.1 3.1 0.1);

glVertex3f (0.0 3.1, 0.0);

glVertex3f (-0.1, 3. 1, 0 •1);

alEnd;

// буква Z gIBegin (GL_LINES);

glVertex3f (0.1, -0.1, 3.1);

gIVertex3f (-0.1, -0.1, 3.1);

giVertex3f (0.1, 0.1, 3.1) ;

glVert:ex3f (-0.1, 0.1, 3.1);

glVertex3f (-0.1, -0.1, 3.1);

glVertex3f (0.1, 0.1, 3.1);

glEnd;

// Восстанавливаем значение текущего цвета glColor3f (Color [1], Color [2], Color [3];

glPcpMatrix;

end;

Глава 3. Построения в пространстве Обратите внимание, что оси рисуются зеленым цветом, а цветовые установ ки запоминаются во вспомогательном массиве, по которому они восстанав ливаются в конце работы процедуры.

Оси выходят из точки (0. 0, 0) и визуализируются лишь в положительном направлении. Проект находится в подкаталоге Ех20. В качестве основы взят пример giFrustum, в который добавлен вызов вышеописанной процедуры и убрано контурное отображение куба. Результат работы программы приведен на рис. 3.14. Видно, что пространство передается некорректно, куб пол ностью загораживает оси координат, хотя оси должны протыкать грани куба.

J* Пространство Пространство Рис. 3.14. Без использования буфера Рис. 3.15. Теперь правильно:

глубины пространство сцены оси протыкают грани куба передается некорректно В следующем примере, проекте из подкаталога Ех21, та же сцена выводится верно (рис. 3.15).

После получения контекста воспроизведения сообщаем системе OpenGL о том, что необходимо корректировать построения в соответствии с глубиной:

glEnabJe (GL_DEPTH_TEST);

// включаем режим тестирования глубины Код сцены начинается с очистки двух буферов: буфера кадра и буфера глу бины:

g l C l e a r (GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);

// + буфер глуСинь:

Точно так же, как перед очередным построением необходимо очистить по верхность рисования, для корректного воспроизведения требуется очистить буфер пространства. Эти действия, которые мы впервые выполнили в этом примере, будут использоваться в большинстве последующих примеров.

Замечание J) О содержимом буфера глубины мы будем говорить еще неоднократно.

108 OpenGL. Графика в проектах Delphi С буфером Глубины СВЯЗаНЫ Две КОМаНЛЫ: qlDepthFunc И glDepthRurgr-i. ХоТЬ они применяются довольно редко, представление о них иметь не помешает.

Первая из этих команд задает правило, по которому происходит сравнение значения оконного Z перед выводом пиксела. По умолчанию установлено значение GL_LESS — выводить на экран точки с минимальным значением оконной Z. Остальные значения приводят чаще всего к тому, что вообще ничего не будет выведено.

Вторая команда задает распределение оконной координаты Z при переподе из нормализованных координат в оконные. На рис. 3.16 приведен результат работы программы (проект из подкаталога Ех22), где такое распределение установлено в обратное принятому по умолчанию:

glDepthRange (1, 0);

! / * Пространство Рис. 3. 1 6. В любой момент Рис. 3. 1 7. На сцене появился можно увидеть то, что скрыто источник света от глаза наблюдателя Источник света Предыдущие примеры вряд ли могут удовлетворить кого-либо в силу своей невыразительности. Рисуемый кубик скорее угадывается, все грани покрыты монотонным цветом, за которым теряется пространство. Теперь мы подо шли к тому, чтобы увеличить реализм получаемых построений.

Вот в следующем примере кубик рисуется более реалистично — рис 3 проект из подкаталога Ех23.

При создании окна включается источник света:

glEnable (GL_LIGHTING);

// разрешаем работу с освещеннос glEnable (GL LIGHTO);

// включаем источник Глава 3. Построения в пространстве Это минимальные действия для включения источника света. Теперь в сцепе присутствует один источник спета с именем 0.

При необходимости можно "установить" несколько источников, для этого точно так же используется команда glEnabie, например:

glEnabie (GL_LIGHT1);

// включаем источник света Пока нет смысла использовать дополнительные источники света, это никак не повлияет на получаемые картинки, поскольку все добавляемые источни ки света используют установки, принятые по умолчанию, и ничем не отли чаются друг от друга.

При рисовании каждой стороны куба задается вектор нормали, используе мый для расчета цветовых параметров каждого пиксела. Для сокращения кода из шести сторон куба я оставил три непосредственно видимые наблю дателю.

glBegin 'GLjQUADS);

glNormal3f(0.0, 0.0, 1.0);

glVertex3f(1.0, 1.0, 1.0) ;

glVeitex3f(-1.0, 1.0, 1.0) ;

glVertex3f(-1.0, -1.0, I.0);

glVeitex3f(1.0, -1.0, 1.0);

glEnd;

glBegin(GL_QUADS);

glNormai3f(-1.0, 0.0, 0.0);

glVertex3f(-1.0, 1.0, 1.0);

glVercex3f[-1.0, 1.0, -1.0);

glVertex3f(-1.0, -1.0, -1.0);

glVertex3f(-1.0, -1.0, 1.0);

glEnd;

glBegin(GL_QUADS);

glNormal3f(0.0, 1.0, 0.0) ;

glVertex3f(-1.0, 1. 0, - 1. 0 ) ;

gIVertex3f(-1.0, 1. 0, 1. 0 ) ;

glVertex3f(1.0, 1.0, 1.0);

glVerr.ex3f (1.0, 1.0, -1.0);

glEnd;

Теперь поговорим о некоторых деталях.

Во-первых, выясним, какое максимальное число источников света мы мо жем использовать. Проект из подкаталога Ех24 в заголовке окна выводит это число, получаемое при создании окна, с помощью команды giGet:

glGetlntcgerv (GLMAX_LIGHTS, @wrk) ;

Caption := InrToStr (wrk);

110 OpenGL. Графика в проектах Delphi Вектора нормалей строятся перпендикулярно каждой стороне куба. В силу того, что наш кубик строится вокруг точки (0, 0, 0), аргументы д..мсгг^13г в данном случае совпадают с точкой пересечения диагоналей каждой грани куба. Чтобы уяснить, насколько важно верно задавать вектор нормали, посмотрите пример, располагающийся в подкаталоге Ех25.

Здесь рисуется только передняя грань кубика, тремя клавишами управления курсором можно менять координаты вектора нормали. При этом меняется вид картинки: освещенность площадки передается в соответствии с текущим значением вектора нормали.

Вектор нормали не обязательно должен исходить именно из середины пло щадки, достаточно того, чтобы он был параллелен действительному вектору нормали к площадке. Это иллюстрирует проект из подкаталога Ех26, где теми же клавишами можно передвигать площадку в пространстве, а вектор нормали задается единожды при создании окна:

glNormal3f(-1.0, 0.0, 0.0);

Где бы ни располагалась в пространстве площадка, она освещается едино образно.

Замечание По умолчанию источник света располагается где-то в бесконечности, поэтому освещенность площадки не меняется вместе с ее перемещением.

В примере из подкаталога Ех27 клавишей <курсор влево> задается поворот площадки в пространстве вокруг оси Y, чтобы можно было взглянуть на площадку с разных точек зрения. Если мы смотрим на заднюю сторону площадки, то видим, что она окрашивается черным цветом. В некоторых ситуациях необходимо, чтобы при таком положении точки зрения наблюда теля примитив не отображался вообще, например, при воспроизведении объектов, образующих замкнутый объем, нет необходимости тратить время на воспроизведение примитивов, заведомо нам не видимых, раз они повер нуты к нам задней стороной. Запомните, как это делается, разобрав проект из подкаталога Ех28.

Здесь площадка не рисуется, если повернута к наблюдателю задней сторо ной. Для этого необходимо включить отсечения задних сторон многоуголь ников:

glEnable (GL_CULL FACE);

Команда giCuiiFa^e позволяет задавать, какие стороны при этом подверга ются отсечению, передние или задние. Понятно, что по умолчанию пред лагается отсекать задние стороны. Противоположное правило отсечения можно установить так:

g l C u l l F a c e

Глава 3. Построения в пространстве Объемные объекты Подчеркну еше раз, что для объемных построений используются все те же десять изученных нами во второй главе примитивов.

В следующем примере строится объемный объект на базе тестовой фигуры, знакомой нам по первой главе (рис. 3.18). Проект расположен в подкатало ге Ех29.

Рис. 3. 1 8. Теперь деталь стала объемной Шестнадцать отдельных многоугольников образуют то, что наблюдателю представляется единым объемным объектом.

В проекте введена переменная, ответственная за режим воспроизведения детали:

mode : POINT, LIKE, FILL) = LINE;

В зависимости от значения этой переменной устанавливается режим рисо вания многоугольников:

case mode of POINT : glPolygonMode (GL_FRONT_AND_BACK, GL_POINT);

LINE : glPolygonMode (GL_FRONT_AND_BACK, GL_L.INE) ;

FILL : glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);

end;

Режим можно менять, нажимая на первые три цифровые клавиши, а кла виши управления курсором позволяют изменять положение точки зрения в пространстве.

В этом примере деталь получается разноцветной. При включенном источ нике света для того, чтобы включить учет текущего цвета примитивов, необ ходимо вызвать команду glEnabie с соответствующим аргументом:

glEnable (GL_COLOR_MATERIAL);

112 OpenGL. Графика в проектах Delphi Попутно обращу ваше внимание на то, что если объект приближается черес чур близко к глазу наблюдателя и пересекает ближнюю плоскость отсечения, в нем появляется дырка, сквозь которую можно заглянуть внутрь объекта.

Л Замечание Необходимо сказать, что при рисовании очень больших объектов происходят сильные искажения, связанные с перспективой, поэтому рекомендуется объек ты масштабировать таким образом, чтобы их линейные характеристики лежали в пределах 101).

Надстройки над OpenGL Существует несколько надстроек над OpenGL, представляющих собой набор готовых команд для упрощения кодирования. Стандартной надстройкой, поставляемой вместе с OpenGL, является библиотека glu, физически рас полагающаяся в файле glu32.dll. Мы уже изучили несколько команд этой библиотеки, и в дальнейшем продолжим ее изучение. Помимо этой стан дартной надстройки наиболее популярной является библиотека glut. Для программистов, пишущих на языке С, эта библиотека особенно привле кательна, поскольку является независимой от операционной системы. Ее применение значительно упрощает кодирование программ, поскольку вся черновая работа по созданию окна, заданию формата пиксела, получению контекстов и пр. выполняется с помощью вызовов библиотечных функций.

Вот пример начальной части программы, где с использованием функций библиотеки glut создается окно с заданными параметрами:

qlutlniLDisplayMoc.e (GLUT_DOUBLE j GLUT_RGB I GLUT DEPTH);

glutLnitWindowSize(400, 4 0 0 ) ;

q m t l n i t W i n d o w P o s i t i o n (50, 50) ;

g±uzCreateWindow(ergv[0]);

Программисты, работающие с Delphi, также могут пользоваться этой биб лиотекой. В приложении я привожу адрес, по которому можно получить заголовочный файл для подключения библиотеки. Однако при программи ровании на Delphi мы не получим независимости от операционной систе мы, а из команд библиотеки чаще всего программистов интересует только набор функций для построения некоторых объемных фигур.

Поэтому вместо нестандартной библиотеки я предпочитаю использовать модуль DGLUT.pas — перенос на Delphi исходных файлов библиотеки glut.

Во многих последующих примерах будут встречаться обращения к этому модулю, соответствующие команды начинаются с префикса glut. Например, для рисования куба с единичной длиной ребра вместо двух десятков строк теперь достаточно одной:

ulutSolidCube (1.0);

Глава 3. Построения в пространстве Помимо куба, модуль (и библиотека) содержит команды воспроизведения сферы, тора, конуса и некоторых правильных многогранников, таких как тетраэдр и додекаэдр. Есть здесь и команда для рисования классического объекта для тестовых программ машинной графики — чайника.

Правильные многогранники строятся как совокупность многоугольников.

о том, как создаются остальные объекты этой библиотеки, мы поговорим позднее.

Для получения представления о модуле DGLUT разберите несложный при мер, проект из подкаталога ЕхЗО.

По выбору пользователя можно построить любой объект модуля в одном из режимов: точками, линиями или сплошной поверхностью. Для задания типа объекта и режима воспроизведения введены переменные типа "перечис ление":

mode : (POINT, LINE, FILL) - FILL;

glutobj : (CUBE, SPHERE, CONE, TORUS, DODECAHEDRON, ICOSAHEDRON, TETRAHEDRON, TEAPOT) = CUBE;

По умолчанию заданы значения, соответствующие кубу со сплошными гра нями. При воспроизведении сцены устанавливается режим и производится обращение к нужной команде:

case mode of POINT : glPolygonMode (GL_FRONT_AND_BACK, GL_POINT);

LINE : glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);

FILL : glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);

end;

case glutobj of TEAPOT : glutSolidTeapot (1.5);

CUBE : glutSolidCube ( 1 5 ;

..) SPHERE : glutSoiidSphere (1.5, 20, 20);

CONE : glutSolidCone (0.5, 1.5, 20, 20);

TORUS : glutSolidTcrus (0.5, 1.5, 20, 20);

DODECAHEDRON : glutSolidDodecahedran;

ICOSAH5DRON : glutSolidlcosahedron;

TETRAHEDRON : glutSolidTetrahedron;

end;

Нажимая на первые три цифровые клавиши, можно задавать режим, четвер тая клавиша позволяет переключать тип объекта:

If Key = 52 then begin Inc (glutobj);

// установить следующее значение If glutobj > High (glutobj) then glutobj := Low (glutobj);

InvalidateRect(Handle, nil, False);

end;

OpenGL. Графика в проектах Delphi Параметр команды, рисующей чайник, имеет такой же смысл, что и для ку ба, — размер объекта. Для сферы необходимо указать радиус и количество линий разбиения по широте и по долготе.

Г Замечание J Чем больше эти числа, тем более гладкими получаются объекты, но тем боль ше времени требуется для их воспроизведения. Если все предыдущие реко мендации по оптимизации скоростных характеристик дают малоощутимый эф фект, то детализация поверхностей является одним из самых важных факто ров, влияющих на скорость воспроизведения.

Для конуса задаются радиус основания, высота и пара чисел, задающих гладкость построений.

У тора параметры следующие: внутренний и внешний радиусы и все те же два числа, задающих, насколько плавной будет поверхность рисуемой фигуры.

В этом примере режим задается способом, знакомым нам по предыдущим примерам — командой giPoiygonMode. Для каркасного изображения объектов модуль располагает серией команд, аналогичных тем, что мы используем В ЭТОМ Примере, НО С ПрИСТавКОЙ glutWire ВМеСТО g l u t S o l i d.

Следующий пример показывает, как можно манипулировать объектами ис ходного набора, чтобы получить другие объемные фигуры. В подкаталоге Ех31 содержится проект, представляющий модификацию классической про граммы из SDK. В программе моделируется рука робота в виде двух парал лелепипедов (рис. 3.19).

Рис. 3. 1 9. В программе рукой манипулятора можно управлять Я не стал расписывать каждый параллелепипед по шести граням, а просто задал масштаб по трем осям перед воспроизведением куба так, чтобы вытя нуть его в нужную фигуру:

glTiranslatef (-1.0, 0.0, 0.0);

gIRotatef (shoulder, 0.0, 0.0, 1.0);

'"ranslatef (1.0, 0.0, 0.0);

Глава 3. Построений в пространстве glPushMatrix;

// запомнить текущий масштаб glScaief (2.0, 0.4, 1.0);

// для вытягивания куба в параллелепипед glutSolidCube(1.0) ;

// в действительности — параллелепипед glPopMatrix;

// вернуть обычный масштаб // вторая часть руки робота glTranslatef (1.0, 0.0, 0.0);

glRotatef (elbow, 0.0, 0.0, 1.0);

glTranslatef (1.0, 0.0, 0.0);

glPushMatrix;

glScaief (2.0, 0.4, 1.0);

glutSoHdCube(l.O) ;

glPopMatrix;

В программе клавишами , , и можно зада вать относительное положение "суставов" руки, эмулируя управление рукой робота. Первой цифровой клавишей можно менять режим воспроизведения, клавишами управления курсором можно менять положение точки зрения наблюдателя.

Quadric-объекты библиотеки glu Библиотека glu предоставляет набор команд, без которых, в принципе, мож но обойтись, но с их использованием решение многих задач сильно упро щается.

Для упрощения построений некоторых поверхностей второго порядка вво дится серия команд, основой которых являются квадратичные (quadric) объекты — собственный тип этой библиотеки.

Как и раньше, познакомимся с новой темой на примерах, для чего откройте проект gluDisk.dpr в подкаталоге Ех32. То, что получается в результате рабо ты программы, изображено на рис. 3.20. Пример этот является переложени ем на Delphi классической программы из набора примеров OpenGL SDK.

Прежде всего обратите внимание, что видовые параметры задаются в зави симости от пропорций окна, чтобы при любых значениях габаритов окна сцена не выходила за его пределы:

If ClientWidth <= ClientHeight then glOrtho (0,0, 50.0, 0.0, 50.0 * ClientHeight / CiientWidth, -1.0, l O.i else glOrtno (0.0, 50.0 * ClientWidth / Clier.LHeignr., 0.0, 50.C, 1.0, 1.0i;

Для работы с командами библиотеки glu вводится переменная специального типа:

quadObj : GLUquadricObj;

OpenGL. Графика в проектах Delphi Рис. 3.20. Проект иллюстрирует использование quadric-объектов При создании окна вызываем команду, создающую qnadric-объект, без этого действия обращение к объекту приведет к исключениям:

quaaGbj •= gluNewQuadric;

РеЖИМ ВОСПрОИЗВедеНИЯ Объекта задается КОМаНДОЙ giiiQuadrioDrawstyie.

первым аргументом команды указывается имя quadric-объекта. По умолча нию стиль задается сплошным, так что чаще всего нет надобности вызывать эту команду. Она также является аналогом команды giPoiygcnMode и всегда может быть ею заменена, за исключением случая использования с аргумен том GLU_SILHOUETTE. При установлении такого режима рисуется только гра ничный контур фигуры, отдельные сектора не рисуются, как это сделано при рисовании третьего диска рассматриваемого примера.

Диск строится с помощью команды giuDisk. Помимо имени объекта се ар гументами задаются внутренний и внешний радиусы, затем два числа, за дающих число разбиений диска по оси Z и число концентрических окруж ностей при разбиении диска. Смысл этих величин хорошо виден при кар касном режиме воспроизведения, когда в получающейся паутинке хорошо видны отдельные сектора диска.

В этом примере показано, как нарисовать дугу диска, сектор, "кусок пиро га". Это делается с помощью команды g_u?artiaiDisk, первые пять парамет ров которой полностью аналогичны параметрам giuDisk, а остальные задают начатьный угол и угол развертки. Углы задаются в градусах.

По окончании работы память, используемую quadric-объектами, необходимо освобождать. Сделать это нужно до освобождения контекста воспроизведения:

qLuDeleteQuadric (quadObj);

// удаление объекта wqliMakeCurrent (О, О);

wglDelereContext fhrc) ;

Глава 3. Построения в пространстве Л Замечание Согласно файлу справки, обращение к удаленному объекту невозможно. Может быть, вы столкнетесь здесь с тем же неожиданным явлением, что и я: поставь те вызов этой команды сразу же за его созданием и запустите программу.

У меня не возникло никаких исключений, что меня удивило и озадачило. Тем не менее, я все же порекомендую не забывать удалять quadric-объекты.

Библиотека glu имеет средства работы с возможными исключениями, для этого предназначена команда giuQuadricCaiiback. Первый аргумент, как обычно, имя quadric-объекта, вторым аргументом может быть только кон станта GLU_ERROR, третий аргумент — адрес функции, вызываемой при ис ключении.

В заголовочном файле отсутствует описание константы GLU_ERROR, вместо нее можно использовать присутствующую там константу GLUTESSERROR, либо самому определить такую константу.

Замечание Точнее, описание константы не отсутствует, а закомментировано.

Без примера, конечно, не обойтись, им станет проект из подкаталога ЕхЗО.

В примере описаны процедура, которая будет вызываться в случае ошибки, и нужная константа:

procedure FNGLUError;

begin ShowMessage {'Ошибка при работе с quadric-объектом!');

end;

const GLU ERROR - GLU TESS ERROR;

J ^ Замечание Процедура, используемая в таких ситуациях, не может присутствовать в описа нии класса. При описании подобных процедур рекомендую использовать клю чевое СЛОВО s t d c a l l.

Сразу после создания quadric-объекта задается функция, вызываемая при исключениях;

здесь передаем адрес пользовательской процедуры:

gluQuadricCallbackfquadObj, GLUERROR, gFNGLUError) ;

Для того чтобы протестировать программу, создается исключение указанием заведомо неверной константы в команде установки режима:

gluQuadr^cDrawStyle (quadObj, GL_LINE};

Теперь при запуске программы работает наша тестовая процедура (рис. 3.21).

OpenGL. Графика в проектах Delphi Рис. 3. 2 1, Пример на использование команды gluQuadricCallback Замечание Исключение при этом не снимается, так что после этого сообщения появляется сообщение операционной системы об аварийной ситуации. Можно использо вать защищенный режим, чтобы такого сообщения не появлялось, Если при обращении к команде gluQuadricCaiiback в качестве адреса функ ции задать значение, равное nil, возникающие исключения будут снимать ся, а выполнение программы будет продолжаться со строки, следующей за строкой, породившей исключение.

Помимо диска, библиотека располагает командами рисования еще некоторых объектов, например, команда giuCyi.inder предназначена для построения цилиндров и конусов. Параметры команды следующие: имя объекта, радиусы основания и верхней части и два числа, задающих частоту разбиения.

Команда giuSphere, как ясно из ее имени, упрощает построение сферы. У нее четыре аргумента, второй аргумент является радиусом сферы, остальные па раметры трациционны для этой серии команд.

Все объекты библиотеки glu я собрал в одном проекте, располагающемся в подкаталоге Ех34. Этот пример аналогичен примеру на объекты библиоте ки glut: по выбору пользователя рисуется объект заданного типа.

Здесь также демонстрируется действие команды giuQuadricOrientaticn. за дающей направление нормали к поверхности объекта, внутрь или наружу.

Еще можно выяснить, как сказывается на виде объекта работа команды gluQuadricNormais, определяющей, строятся ли нормали для каждой верши ны, для всего сегмента либо вообще не строятся.

Нажимая на первые четыре цифровые клавиши, можно задавать значения параметров: режим, тип объекта, ориентацию нормалей и правило их по строения.

В проекте введены соответствующие перечисления:

mode : {POINT, LINE, FILL, SILHOUETTE) - FILL;

gluobj ;

(SPHERE, CONE, CYLINDER, DISK) = SPHERE;

Глава 3. Построения в пространстве orientation : (OUTSIDE, INSIDE) = OUTSIDE;

normals : (NONE, FLAT, SMOOTH) = SMOOTH;

Первым аргументом всех команд является имя quadric-объекта, все возмож ные константы перечисляются в конструкциях case:

case mode of // режим воспроизведения POINT : gluQuadricDrawStyle (quadObj, GLU_POINT);

// точки LINE : gluQuadricDrawStyle (quadObj, GLU_LINE);

//линии FILL : gluQuadricDrawStyle (quadObj, GLU_FILL);

// сплошным SILHOUETTE : gluQuadricDrawStyle (quadObj, GLU_SILHOUETTE);

// контур end;

case orientation of // направление нормалей INSIDE : gluQuadricOrientation (quadObj, GLUINSIDE) ;

// внутрь OUTSIDE : gluQuadricOrientation {quadObj, GLU_OUTSIDE);

// наружу end;

case normals of // правило построения нормалей NONE : gluQuadricNormals (quadObj, GLU_NONE);

// не строить FLAT : gluQuadricNormals (quadObj, GL0TFLAT) ;

// для сегмента SMOOTH : gluQuadricNormals (quadObj, GLU_SMOOTHj;

// для каждой заршины end;

case gluobj of// тип объекта SPHERE : gluSphere (quadObj, 1.5, 10, 10);

// сфера CONE : gluCylinder (quadObj, 0.0, 1.0, 1.5, 10, 10);

// конус CYLINDER : gluCylinder (quadObj, 1.0, 1.0, 1.5, 10, 10];

// цилиндр DISK : gluDisk (quadObj, O.O, 1.5, 10, 5 ) ;

// диск end;

На рис. 3.22 приводится одна из возможных картинок, получаемых с по мощью этого проекта.

Следующие примеры этого раздела также являются переложением на Delphi классических примеров из SDK.

Рис. 3.22. С помощью этого примера вы можете познакомиться со всеми quadric-объектами OpenGL. Графика в проектах Delphi Первым делом посмотрите проект из подкаталога Ех35 — вступительный пример к нескольким следующим проектам и одновременно простейший пример на использование объектов библиотеки glu.

Здесь просто рисуется сфера, модель звезды, наблюдатель находится над полюсом (рис. 3,23).

Рис. 3. 2 3. Упрощенная модель звезды Проект следующего примера располагается в подкаталоге Ех32, а экранная форма приложении приведена на рис. 3.24.

Здесь моделируется уже планетарная система, клавишами управления кур сором можно задавать положение планеты относительно звезды и угол по лорота ее вокруг собственной оси.

Рис. 3. 2 4. Добавилась планета Глава 3. Построения в пространстве Замечание Начинающим я рекомендую хорошенько разобраться с этим примером, здесь впервые для нас в пространстве присутствует несколько объектов, распола гающихся независимо друг от друга.

На базе одного quad п с -объекта можно строить сколько угодно фигур;

не обязательно для каждой из них создавать собственный объект, если пара метры всех их идентичны.

В этом примере на базе одного объекта рисуется две сферы:

// рисуем солнце gluSphere (quadObj, 1.0, 15, 10);

// рисуем маленькую планету glRotatef (year, 0.0, 1.0, С О ) ;

glTranslatef (2.0, 0.0, 0.0);

glRotatef (day, 0.0, 1.0, 0.0);

gluSphere {quadObj, 0.2, 10, 10);

Следующий пример, проект из подкаталога Ех37, является небольшой мо дификацией предыдущего. Положение точки зрения изменилось так, что модель наблюдается под другим углом — рис. 3.25.

Рис. 3.25. В этом примере смотрим на систему с другой точки зрения Этот пример служит хорошей иллюстрацией на использование команд giPushMat.rix и giPopMatrix: солнце и планета поворачиваются по отдельно сти относительно базовой системы координат:

glPushMatrix;

// рисуем солнце glPushMatrix;

122 OpenGL. Графика в проектах Delphi glRotatef (90.0, 1.0, 0.0, 0.0);

// поворачиваем прямо gluSphere (quadObj, 1.0, 15, 10);

glPopMatrix;

// рисуем маленькую планету glRotatef (year, 0.0, 1.0, 0.0);

glTranslatef (2.0, 0.0, 0.0);

glRotatef (day, 0.0, 1.0, 0.0);

glRotatef (90.0, 1.0, 0.0, 0.0);

// поворачиваем прямо gluSphere (quadObj, 0.2, 10, 10);

glPopMatrix;

Рано или поздно вам потребуется узнать, как в OpenGL можно получить вырезку пространственных фигур, например, полусферу. Следующий при мер (подкаталог Ех38) поможет узнать, как это делается. В нем рисуется четверть сферы — рис. 3.26.

1 ' '" ^'й^ Р и с. 3. 2 6. Совсем несложно получить полусферу или четверть сферы Для вырезки части пространства используется новая для нас команда giciippiane. Для вырезки можно использовать несколько плоскостей эта команда идентифицирует используемые плоскости. Первый аргумент символическое имя плоскости вырезки, второй - адрес массива, задающего эту плоскость. Символические имена начинаются с GL_CLIP PLANE дальше следует цифра, нумерация начинается с нуля.

При каждой вырезке отсекается полупространство, массив задает вектоо определяющий остающуюся часть. Вектор не должен быть обязательно пер пендикулярен осям, как в нашем примере.

Для получения четверти сферы проделываем две вырезки: сначала обрезаем нижнее полупространство, удаляя все вершины с отрицательным значением координаты Y, затем отсекаем левое полупространство, т. е. удаляются вер шины с отрицательным значением координаты X:

cnt os en:Ary[.3 o Gdul =(., 0 0.01;

q ra 0.] f Lobe 00, Глава 3. Построения в пространстве eqn2 : Array [0..3] of GLdouble = (1.0, 0.0, 0.0, 0.0);

// удаление нижней половины, для у < giClipPlane (GL_CLIP PLANEQ, @eqn);

// идентифицируем плоскость отсечения glEnable (GL CLIP PLANED);

// включаем ;

трвутс плоскость отсечения // удаление левой половины, для х < glClipPlane (GL_CLIP_PLANEl, @eqn2);

glEnatle (GL_CLIP_PLANE1);

// включаем вторую плоскость отсечения Если теперь вернуться к библиотеке glut, то можно заметить, что сфера и конус в ней строятся на базе объектов библиотеки glu. Например, процедура для построения каркаса сферы выглядит так:

procedure glutWireSphere( Radius : GLdouble;

Slices : GLint;

Stacks : GLint);

begin ( glutWireSphere } if quadObj = nil then quadObj := gluNewQuadric;

gluQuadricDrawStyle(quadObj, GLU_LINE);

gluQuadricNormals{quadObj, GLU_SMOOTH);

gluSphere(quadObj, Radius, Slices, Stacks);

end;

{ glutWireSphere } Здесь можно подсмотреть несложный прием для определения того, надо ли создавать quadric-объект. Прием основан на том, что тип GLUquadricobj является указателем и его nil-значение соответствует тому, что объект пока еще не создан. Кстати, можете сейчас заглянуть в заголовочный файл opengl.pas, чтобы убедиться, что этот тип является указателем, указателем на пустую запись:

type _GLUquadricObj = record end;

GLUquadrxcObj ~ "_GLUquadricObj;

Заключительным примером раздела станет проект из подкаталога Ех39 — модель автомобиля (рис. 3.27).

Клавишами управления курсором можно вращать модель по осям, клавиши < I use it > и служат для приближения/удаления модели. Пробелом и клавишей ввода можно задавать различные режимы воспроизведения.

В примере используются объекты библиотеки glu и модуля DGLUT. Нет смысла его подробно разбирать, остановимся только на некоторых моментах.

Напоминаю, что для воспроизведения объектов с различным пространст венным положением перед собственно воспроизведением каждого из них система координат перемещается в нужную точку в пространстве. Для удоб ства ориентирования в пространстве перед каждой трансформацией системы •124 OpenGL. Графика в проектах Delphi координат текущую матрицу (систему координат) запоминаем вызовом команды giPushMatrix, затем возвращаемся в эту систему координат вызо вом giPopMatrix. Это будет выполняться быстрее, чем обратные переносы.

но было бы лучше вычислять координаты следующего объекта в текущей системе координат.

Рис. 3.27. Мы можем строить модели и посложнее двух сфер Для разнообразия передние квадратные фары автомобиля строятся с ис пользованием команды giuDisk: если последние два аргумента команды за дать равными четырем, строится ромб, перед построением система коорди нат поворачивается:

glRotatef(45, 0.0, 0.0, 1.0);

giuDisk (quadObj, 0.0, 0.1, 4, 4);

Квадраты задних фар строятся с помощью команды giRect, мы изучали эту команду в предыдущей главе.

Для того чтобы нормаль квадрата была направлена в нужную сторону, пере ворачиваем систему координат:

glRotatef(180, 1.0, 0.0, 0.0);

glRectf (0.1, 0.1, -0.1, -0.1);

Вместо этого можно было бы просто задать нужный вектор нормали:

glNormal3f (0, 0,-1);

Глава 3. Построения в пространстве Эту программу вы можете взять в качестве шаблона, чтобы поупражняться в построениях.

Проектировать системы из множества объектов без использования редакто ров может оказаться трудным делом для новичков. Могу посоветовать вос пользоваться приведенной выше процедурой построения осей текущей сис темы координат: обращайтесь к ней каждый раз, когда необходимо выяс нить, "где я сейчас нахожусь".

Сплайны и поверхности Безье Мы теперь можем без труда рисовать кубики, сферы, цилиндры и многие другие аналогичные фигуры, но, конечно, этого недостаточно, и рано или поздно возникнет потребность нарисовать поверхность произвольной фор мы. В этом разделе мы узнаем, как это сделать.

Подход, предлагаемый библиотекой OpenGL для изображения криволиней ных поверхностей, традииионен для компьютерной графики: задаются ко ординаты небольшого числа опорных точек, определяющих вид искомой поверхности. В зависимости от способа расчета опорные точки могут лежать на получаемой поверхности, а могут и не располагаться на ней.

Сглаживающие поверхности называются сплайнами. Есть много способов построения сплайнов, из наиболее распространенных нас будут интересо вать только два: кривые Безье (Bezier curves, в некоторых книгах называются "сплайны Бежье") и В-сплайны (base-splines, базовые сплайны).

Изучение этой темы начнем с простейшего, с двумерных кривых.

Операционная система располагает функциями GDI, позволяющими стро ить кривые Безье.

В примере — проекте из подкаталога Ех40 — модуль OpenGL не использует ся, это пример как раз на использование функций GDI. Он является моди фикацией одного из проектов первой главы, но теперь рисуется не квадрат и круг, а кривая Безье по четырем точкам — рис. 3.28.

Кривая Безье Рис. 3.28. функции GDI позволяют строить кривые Безье Опорные вершины заданы в массиве четырех величин типа TPoint этот тип вводится в модуле windows.pas:

OpenGL. Графика в проектах Delphi Const Array [0..3] of TPoint = Points (x:100;

y:90;

;

y:5), (x:20;

y:70), (x:80;

Собственно рисование кривой состоит в вызове функции GDI poiyBezier, первый аргумент которой — ссылка на контекст устройства, затем указыва ется массив опорных точек, последний аргумент — количество используе мых точек:

PolyBezier (dc, Points, 4) ;

Построение для большей наглядности дополнено циклом, в котором окруж ностями визуализируются опорные точки:

For i : G to 3 do = Ellipse (dc, Points ]i)-x — 3, Points [i].у — 3, Points.i].x + 3, Points [i].y + 3);

В случае четырех опорных точек кривая всегда будет начинаться точно в первой точке и приходить в последнюю точку. Если их переставить места ми, вид кривой не изменится, что не произойдет и если переставить места ми вторую и третью опорные точки. Опорные точки могут располагаться в пространстве произвольно, т. е. не требуется, чтобы они, например, рав номерно располагались по интервалу. Если необходимо продолжить кривую, добавляется по три точки для каждого последующего сегмента.

Теперь посмотрим, как нарисовать кривую Безье, используя команды OpenGL. Откройте проект из подкаталога Ех41. Получаемая кривая показа на на рис. 3.29.

Рис. 3. 2 9. Кривая Безье, построенная с помощью функций библиотеки OpenGL В обработчике создания формы задаются параметры так называемого одномерного вычислителя, и включается этот самый вычислитель:

glMaplf (GL_MAP1_VERTEX_3, 0.0, l.C, 3, 4, @ctrlpointsl;

glEnable (GL_MAP1_VERTEX3) ;

Первый параметр команды giMapl — символическая константа, значение соответствует случаю, когда каждая контрольная точка GL_MAPI_VEP.TEX_ Глава 3. Построения в пространстве представляет собой набор трех вещественных чисел одинарной точности, т. е. координаты точки. Значения второго и третьего аргументов команды определяют конечные точки интервала предварительного образа рассчиты ваемой кривой. Величины ноль и один для них являются обычно исполь зуемыми, подробнее мы рассмотрим эти аргументы чуть ниже.

Четвертый параметр команды, "большой шаг", задает, сколько чисел содер жится в считываемой порции данных. Как говорится в документации, кон трольные точки могут содержаться в произвольных структурах данных, лишь бы их значения располагались в памяти друг за другом.

Последние два параметра команды — число опорных точек и указатель па массив опорных точек.

Для построения кривой можно использовать точки или отрезки: вместо команды, задающей вершину, вызывается команда gir;

va] coord, возвраща ющая координаты рассчитанной кривой:

glBegin (GL_LINE_STRIP) ;

For i := 0 t o 30 do g l E v a l C o o r d l f (i / 3 0. 0 ) ;

glEnci;

Аргумент команды — значение координаты и. В данном примере соединя ются отрезками тридцать точек, равномерно расположенных на кривой.

Теперь выясним правила отображения интервала. Если в этом примере тре тий параметр команды giMapif задать равным двум, то на экране получим половину первоначальной кривой. Для получения полной кривой надо при воспроизведении взять интервал в два раза больший:

glBegin(GL_LINE_STRIP);

For i : 0 to 60 do = glEvalCoordif(i / 30.0);

glEnd;

Если же этот параметр задать равным 0.5, то при отображении интервала с и в пределах от нуля до единицы получаемая кривая не будет останавливаться на последней опорной точке, а экстраполироваться дальше. Если в этом нет необходимости, конечное значение параметра цикла надо взять равным 15.

Чтобы действительно разобраться в подобных вопросах, надо обязательно попрактиковаться, посмотреть, какие кривые строятся для различных набо ров опорных точек. Здесь вам поможет проект из подкаталога Ех42, где сре ди четырех опорных точек имеется одна выделенная. Клавишами управле ния курсором можно менять положение выделенной точки, при нажатии на пробел выделенной становится следующая точка набора. Выделенная точка рисуется красным.

128 OpenGL. Графика в проектах Delphi Обратите внимание, что простой перерисовки окна при изменении в масси ве опорных точек недостаточно, необходимо заново обратиться к командам, "заряжающим" вычислитель, чтобы пересчитать кривую:

If Key = VK_SPACE then begin // выделенной становится следующая точка набора selpoint := selpoint + 1;

If selpoint > High (selpoint) then selpoint := Low (selpoint);

InvalidateRect(Handle, nil, False);

end;

If Key = VK_LEFT then begin // сдвигаем выделенную точку влево ctrlpoints [selpoint, 0] := ctrlpoints fselpoint, 0] — 0.1;

// пересчитываем кривую по измененному массиву опорных точек glMaplf(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4, Pctrlpoints);

glEnable(GL_MAP1_VERTEX_3) ;

InvalidateRect(Handle, nil, False);

// перерисовка окна end;

С помощью этого примитивного редактора можно построить замысловатые фигуры и заодно получить представление о кривых Безье.

{ Замечание ^ Не получится расположить все четыре точки на кривой, если только это не ли нейная функция.

С помощью команды giGetMapfv в любой момент можно получить полную информацию о текущих параметрах вычислителя. Не думаю, что вы часто будете обращаться к этой команде, но на всякий случай приведу пример на ее использование (проект из подкаталога Ех43). Клавишами и можно менять текущее значение параметра вычислителя и2, в за головке окна выводятся значения ul и и2. Эти значения приложение полу чает от OpenGL:

wrk : Array [0..1] of GLfloat;

begin giGetMapfv (GL_MAP1_VERTEX_3, GL_DOMAIN, @wrk) ;

Caption := FloatToStr (wrk[0]) + ', ' + FloatToStr(wrk[1]);

Из файла справки вы можете узнать, как получить значения всех остальных параметров вычислителя.

Построить кривую можно и другим способом. Посмотрим пример из подка талога Ех44, отличающийся от предыдущего примера на кривые Безье сле дующим: сразу после включения вычислителя вызывается команда, строя щая одномерную сетку, т. е. рассчитывающая координаты набора точек на интервале:

glMapGridlf (30, 0, 1);

Глава 3. Построения в пространстве Первый аргумент — количество подинтервалов, далее задается интервал по координате и. После того как сетка построена, вывод ее осуществляется од ной командой:

glEva.lMeshl (GL_LINE, 0- 10) ;

, Первый аргумент— режим воспроизведения, отрезками или точками, осталь ные аргументы задают номера первой и последней точек рассчитанной сетки.

Получив представление о кривых, мы можем перейти к поверхностям Безье.

Соответствующий пример располагается в подкаталоге Ех45, а результат ра боты программы показан на рис. 3.30.

Рис. 3.30. Классический пример на построение поверхности Безье Массив опорных точек содержит координаты шестнадцати вершин. Работа программы начинается с установки параметров вычислителя:

glMap2f

poin glEnable (GL_MAP2VERTEX_3) ;

glMapGna2f (20, 0.0, 1.0, 20, 0.0, 1.0);

У команды giMap2f аргументов больше, чем у giMapif, но теперь нам легко понять их смысл. Первый аргумент — константа, определяющая тип рассчи тываемых величин, в данном случае это координаты точек поверхности. По следний аргумент — указатель на массив контрольных точек поверхности.

Второй и третий параметры задают преобразования по координате и по верхности. Четвертый аргумент, как и в предыдущем случае, залает, сколько вещественных чисел содержится в порции данных — здесь мы сообщаем, что каждая точка задана тремя координатами. Пятый аргумент — количество точек в строке структуры, хранящей данные.

Следующие четыре аргумента имеют смысл, аналогичный предыдущим че тырем, но залают параметры для второй координаты поверхности, коорди наты v. Значение восьмого аргумента ст&чо равно двенадцати путем пере 130 OpenGL. Графика в проектах Delphi множения количества чисел, задающих координаты одной вершины (3), на количество точек в строке массива (4).

После задания параметров вычислителя он включается вызовом команды giEnabic, после чего вызывается одна из пары команд, позволяющих по строить поверхность — команда giMapGrid2f, рассчитывающая двумерную сетку. Первый и четвертый аргументы этой команды определяют количество разбиений по каждой из двух координат поверхности, остальные параметры имеют отношение к отображению интервалов.

Собственно изображение поверхности, двумерной сетки, осуществляется вызовом второй команды из тандема:

glEvalMesh2 (GL_FILL, О, 2G, 0, 20);

Первый аргумент команды задает режим воспроизведения, следующие две пары чисел задают количество подинтервалов разбиения по каждой коорди нате поверхности. В примере мы берем по 20 разбиений, столько же, сколь ко задано в команде g±MapGrid2f, чтобы не выходить за пределы интервалов, но это не обязательно, можно брать и больше.

Если смысл параметров, связанных с отображением интервалов, вам кажет ся не совсем ясным, рекомендую вернуться к примеру по кривой Безье и еше раз его разобрать.

Замечу, что режим воспроизведения можно варьировать также с помощью команды glPoIygonMode.

Обратите внимание, что в рассматриваемом примере используется режим автоматического расчета нормалей к поверхности:

glEnable (GL_AUTO_JJORMAL);

Без этого режима поверхность выглядит невыразительно, но его использо вание допускается только в случае поверхностей, рассчитываемых вычисли телем, В проекте введены два режима: один управляет тем, как строится поверх ность — сплошной или линиями. Второй режим задает, надо ли выводить опорные точки. Нажимая на клавиши ввода и пробела, можно менять теку щие значения этих режимов.

При нажатой кнопке мыши при движении курсора поверхность вращается по двум осям, что позволяет хорошо рассмотреть ее с разных позиций. Для осуществления этого режима введен флаг, булевская переменная Down, которая принимает истинное значение при удерживаемой кнопке мыши, и две вспомогательные переменные, связанные с экранными координатами указателя.

В момент нажатия кнопки запоминаются координаты курсора;

при движе нии курсора сиена поворачивается по двум осям на угол, величина которого зависит от разницы текущей и предыдущей координат курсора:

Глава 3. Построения в пространстве procedure TfrmGL. FonnMouseMove {Sender: TObject;

S i f : TSbiftStat tit Y: Integer);

begin If Down then begin // кнопка мыши нажата glRotatef (X - wrkX, 0.0, 1.0, 0.0), поворот по горизонтали экрана g^Rotatef (Y - wrkY, 1.0, 0.0, 0.0), поворот пс вертикали коала InvalidateRect(Handle, nil, False!;

пеоеоисовать зкоан // запоминаем координаты курсора wrkX := X;

wrkY := Y;

end;

end;

Но при изменении размеров окна система координат возвращается в перво начальное положение.

Точно так же, как и в случае с кривой Безье, для воспроизведения поверх ности МОЖНО ВОСПОЛЬЗОВаТЬСЯ КОМанДОЙ glEvalCoord2i, На рис. 3.31 приведен результат работы примера из подкаталога Ех46. где на основе все той же поверхности строится множество отрезков, наложение которых на экране приводит к получению разнообразных узоров, называе мых узорами муара.

Рис. 3. 3 1. Узор получается наложением отрезков, лежащих на поверхности Безье Отрезки строятся по вершинам, предоставленным вычислителем:

glBegin ;

GL_LINESTRIP) ;

For i : 0 to 30 do = For j : 0 to 30 do = glEvalCoord2f (i / 30, j / 30);

glEnd;

•\32 OpenGL. Графика в проектах Delphi Мы уже изучили множество параметров команды gi.Enable. задающей ре жимы воспроизведения и, в частности, позволяющей использовать вычис лители. Я должен обязательно привести пример на команду, позволяющую определить, включен сейчас какой-либо режим или вычислитель — коман ду qiisEnabied. Ее аргумент — константа, символ определяемого режима, а результат работы, согласно документации, имеет тип GLbooLear.. Мы знаем о небольшой проблеме Delphi, связанной с этим типом, так что для вас не должно стать откровением то, что обрабатывать возвращаемое значение мы будем как величину булевского типа.

Приведу здесь простой пример, в котором до и после включения режима окрашивания поверхностей выводится сообщение о том, доступен ли этот режим' II". n i s E r. a b l e d (GL_COLOR_MATERIAL) - TRUE t h e n ShowMessage ('COLOR_MATERIAL is e n a b l e d ' ) e l s e ShowMessage ('COLOR_MATERIAL is d i s a b l e d ' ) ;

Соответствующий проект располагается в подкаталоге Ех47.

В этом разделе мы рассмотрели, как в OpenGL строятся кривые и поверхно сти Безье, позже рассмотрим еще несколько примеров на эту тему.

NURBS-поверхности Один из классов В-сплайнов, рациональные В-сплайны, задаваемые на не равномерной сетке (Non-Uniform Rational B-Spline, NURBS), является стан дартным для компьютерной графики способом определения параметриче ских кривых и поверхностей.

Библиотека gin предоставляет набор команд, позволяющих использовать этот класс поверхностей. Будем знакомиться с соответствующими команда ми непосредственно на примерах и начнем с проекта из подкаталога Ех48.

где строится NURBS-кривая по тем же опорным точкам, что и в первом примере на кривую Безье. Вид получающейся кривой тоже ничем не отли чается от кривой, приведенной на рис. 3.29.

Для работы с NURBS-поверхностями в библиотеке glu имеются переменные специального типа, используемые для идентификации объектов:

re u hN rb : g j ;

При создании окна объект, как обычно, создается:

theNurb :

- с UiNewNurbsRen.de r e r;

А в конце работы приложения память, занимаемая объектом, высвобождается:

qluDcleteNurbsRenderer (theNurb);

Глава 3. Построения в пространстве ) ( Замечание В отличие от quadric-объектов, удаленные NURBS-объекты действительно бо лее недоступны для использования.

Для манипулирования свойствами таких объектов предусмотрена специаль ная команда библиотеки, в примере она используется для задания гладкости поверхности и режима воспроизведения. Гладкость кривой или поверхности задается допуском дискретизации: чем меньше это число, тем поверхность получается более гладкой:

gluNurbtProperty (theNurb, GLU_SAMPLING_TOLERANCE, 25.0);

В отличие от других объектов, NURBS-поверхности рассчитываются каж дый раз заново при каждом построении. В этом легко убедиться, например, следующим образом: увеличьте допуск дискретизации раз в десять и изме няйте размер окна. При каждой перерисовке кривая получается разной.

Собственно построение кривой осуществляется следующей командой:

gluNurbsCurve (theNurb, 8, @curveKnots, 3, @ctrlpoints, 4, GL_MAP1 VER?EX_3);

Первый аргумент— имя NURBS-объекта, вторым аргументом задается ко личество параметрических узлов кривой, третий аргумент — указатель на массив, хранящий значения этих узлов. Следующий параметр — смещение, т. е. сколько вещественных чисел содержится в порции данных, далее следу ет указатель на массив опорных точек. Последний аргумент равен порядку (степени) кривой плюс единица.

В документации указывается, что количество узлов должно равняться коли честву опорных точек плюс порядок кривой. Количество опорных точек достаточно взять на единицу больше степени кривой, квадратичная кривая однозначно определяется тремя точками, кубическая — четырьмя и т. д.

Так что для построения квадратичной кривой необходимо задавать шесть узлов:

gluNurbsCurve (theNurb, 6, @curveKnots, 3, @CtripointS, 3, GL M P _ V R F X 3 ;

A1_ET,_) Значения параметрических узлов и массиве или другой структуре, хранящей данные, должны быть упорядочены по неубыванию, т. с. каждое значение не может быть меньше предыдущего. Обычно значения первой половины узлов берутся равными нулю, значения второй половины задаются единич ными, что соответствует неискаженной кривой, строящейся на всем интер вале от первой до последней опорной точки.

Прежде чем мы сможем перейти к NURBS-поверхности, рекомендую само стоятельно поработать с этим примером, посмотреть на вид кривой при раз личных значениях параметров. Не забывайте о упорядоченности этих значе OpenGL. Графика в проектах Delphi ний, и приготовьтесь к тому, что их набор не может быть совершенно про извольным: в некоторых ситуациях кривая строиться не будет.

Теперь мы можем перейти к поверхностям, и начнем с проекта из подката лога Ех49 — модификации классического примера на эту тему, в котором строится холмообразная NURBS-поверхность (рис. 3.32).

Рис. 3.32. Классический пример на использование NURBS-поверхности Первым делом замечу, что здесь появился новый для нас режим:

glEnable (GL_NORMALIZE);

Сделано это из-за того, что поверхность при построении масштабируется, и чтобы автоматически рассчитанные нормали "не уплыли", и используется этот режим.

Режим воспроизведения меняется по нажатию клавиши ввода, для его уста новки ИСПОЛЬЗуеТСЯ та Же Команда gluNurbsProperty:

If solid then gluNurbsProperty(theNurb, GLU_DISPLAY_MODE, GLU_FILL) else gluNurbsProperty(theNurb, GLU_DIS?LAY_MODE, GLU_OUTLINE POLYGON);

Команда собственно построения заключена в специальные командные скобки:

gluBeginSurface {theNurb);

gluNurbsSurface (theNurb, S, @knots, 8, @knots, 4 * 3, 3, @ctrl.pcunts, 4, 4, GL_MAP2VERTEX_3) ;

g l u E n d S u r f a c e (theNurb}, Глава 3. Построения в пространстве 135_ В данном примере эти скобки не обязательны, поскольку они обрамляют единственную команду.

Если вы внимательно разобрали примеры предыдущего раздела, то боль шинство параметров команды giuNurbsSurface не должны вызывать вопро сов, они аналогичны параметрам команд для построения поверхности Безье.

Так, шестой и седьмой параметры задают "большой шаг" по каждой коорди нате, ассоциированной с поверхностью, т. е. сколько вещественных чисел содержится в строке структуры данных и сколько вещественных чисел за дают отдельную точку. Восьмой параметр — адрес массива контрольных то чек, а последним параметром задается символическая константа, опреде ляющая тип возвращаемых значений;

в данном случае ими являются трех мерные координаты вершин.

В примере задано шестнадцать контрольных точек, располагающихся рав номерно по координатам X и Y в пределах квадрата, третья координата для точек, лежащих на границе квадрата, равна —3, для внутренних опорных точек эта координата равна 7. Таким способом массив заполняется для по лучения холмообразной поверхности. Если по заданным опорным точкам построить поверхность Безье, то увидим точно такой же холмик, как и в рассматриваемом примере.

Отличает NURBS-поверхности то, что параметризируемы. Так, предпослед ние два параметра задают степень (порядок) поверхности по координатам и и v. Задаваемое число, как сказано в документации, должно быть на еди ницу больше требуемой степени. Для поверхности, кубической по этим ко ординатам, число должно равняться 4, как в нашем примере. Порядок нель зя задавать совершенно произвольным, ниже мы разберем имеющиеся огра ничения.

Второй параметр команды — количество узлов в параметризации по и-ма правлению, третьим параметром задается адрес массива, хранящего значе ния узлов. Третий и четвертый параметры команды имеют аналогичный смысл, но для второго направления.

Массивы узлов должны заполняться значениями, упорядоченными по не убыванию.

Как сказано в файле справки, при заданных uknot_count и vknot_count коли чествах узлов, uorder и vorder порядках количество опорных точек должно равняться (uknot_coum — uorder) x (vknoi_couni — vorder). Так что при изме нении порядка по координатам необходимо подбирать и все остальные па раметры поверхности.

Если вы хотите подробнее узнать о параметризации и ее параметрах, то об ратитесь к литературе с подробным изложением теории NURBS-поверх ностей.

В данном примере используется один массив для задания узлов по обоим направлениям, а в проекте из подкаталога Ех50 используется два отдельных OpenGL. Графика в проектах Delphi массива — для каждой координаты задаются свои значении узлов. По верхность строится не на всем интервале, а на части его, т. с. происходит подобие отсечения.

Чаще всего используются "кубические" NURBS-поверхности. Для иллюст рации построения поверхностей других порядков предназначен проект из подкаталога Ех51, где берется "квадратичная" поверхность.

Библиотека glu предоставляет также набор команд для вырезки кусков NURBS-поверхностей. Примером служит проект из подкаталога Ех52. Опор ные точки поверхности располагаются в пространстве случайно, а затем из поверхности вырезается звездочка — рис. 3.33.

Рис. 3.33. Команды библиотеки glu позволяют строить невыпуклые многоугольники Для хранения точек на границе вырезаемой области — звездочки — введен массив:

tLLr: Array [0..20, 0..1] of GLfioat;

--r.

Массив заполняется координатами точек, лежащих поочередно на двух вло женных окружностях:

procedure InitTrim;

i: Integer;

be a.in For i := 0 to 20 do If Odcl(i) then begin // нечетные точки — на внешней окружности trim [i, 0] := 0.5 * cos (i * Pi / 10) + 0.5;

гrim [i, 1] :- 0.5 * sin (i * Pi / 10) + 0.5;

end else begin // четные точки — на внутренней окоужност>!

Lrirn [i, 0] := 0.25 * cos (i * Pi / 101 + 0.5;

r.rim

.

en':;

end;

Глава 3. Построения в пространстве Внутри операторных скобок построения NURBS-поверхности велел за коман дой giuNurbsSurface задаем область вырезки:

gluBeginTrim (theNurb);

GLU MAPI TRIM giuPwlCurve (theNurb, 21, @trim, gluEndTrim (theNurb);

Pages:     | 1 || 3 | 4 |   ...   | 5 |



© 2011 www.dissers.ru - «Бесплатная электронная библиотека»

Материалы этого сайта размещены для ознакомления, все права принадлежат их авторам.
Если Вы не согласны с тем, что Ваш материал размещён на этом сайте, пожалуйста, напишите нам, мы в течении 1-2 рабочих дней удалим его.