Миллер Т. DirectX 9 с управляемым кодом. Программирование игр и графика. 2005. 386 стр.

There is still time to download: 30 sec.



Thank you for downloading from us :)

If anything:

  • Share this document:
  • Document found in the public.
  • Downloading this document for you is completely free.
  • If your rights are violated, please contact us.
Type of: pdf
Founded: 08.04.2020
Added: 01.05.2020
Size: 5.01 Мб

Том Миллер
Managed DirectX*9
Программирование графики и игр

**омпэ*>

Предисловие Боба Гейнса
Менеджера проекта DirectX SDK корпорации Microsoft

SAMS [Pi]
KICK START

Managed DirectX 9
Управляемый DirectX9 расширяет
возможности программирования игр и
графики.
Книга позволяет изучить возможности использования
Управляемого DirectX при разработке различных
графических и мультимедийных приложений. В данной
книге рассмотрены как основы программирования 3D-
графики, так и более сложные разделы, например,
управление уровнями детализации mesh-объектов,
использование высокоуровневого языка шейдеров и
символьной анимации.
В книге уделено достаточное внимание таким важным
вопросам, как управление звуком и устройствами ввода
или добавление звуковых эффектов и джойстика с
обратной связью.
Материал книги "Managed DirectX 9" направлен в
большей степени на непосредственное создание
полнофункциональных мультимедийных приложений,
нежели на изучение излишнего языкового синтаксиса.
Мы полагаем, что читатель этой книги уже знаком с
языком С# (или Visual Basic .NET) и средой .NET Runtime.
Автор этой книги имеет огромный опыт разработки
приложений с помощью DirectX с Управляемым кодом и
является своего рода первоисточником информации в
данной области.
ТОМ Миллер является ведущим разработчиком API
Managed DirectX. В течении последних четырех лет он
участвовал в разработке DirectX API, включая SDK и
DirectX для Visual Basic. Перед этим он работал в группе
разработчиков Visual Basic и Office корпорации Microsoft.
KICK START
Содержание прилагаемого CD диска:
• DirectX 9 SDK
• Исходные тексты программ на С# и

Visual Basic.NET

• .NET Runtime версии 1.1.
КАТЕГОРИЯ: Программирование.
ОХВАТЫВАЕТ: Программирование графики и
компьютерных игр с помощью Управляемого DirectX 9.
УРОВЕНЬ пользователя: Средний.

Том Миллер
DirectX 9
с управляемым

кодом

Программирование игр
и графика

KICK START

Издательский Дом «КомБук»
Москва, 2005

Содержание

Предисловие 14
Об авторе 15
Посвящается 16
Будем признательны за ваши отзывы и пожелания! 17
Введение 18
ЧАСТЬ I

ВВЕДЕНИЕ В КОМПЬЮТЕРНУЮ ГРАФИКУ

Глава 1. Введение в Direct3D 24
Глава 2. Выбор подходящего устройства 48
Глава 3. Введение в технологию рендеринга 57
Глава 4. Более совершенные технологии рендеринга 76
Глава 5. Рендеринг Меsh-объектов 91
Глава 6. Использование Управляемого DirectX для
программирования игр 106
ЧАСТЬ II

ОСНОВНЫЕ КОНЦЕПЦИИ ПОСТРОЕНИЯ ГРАФИКИ

Глава 7. Использование дополнительных свойств и возможностей
Mesh-объектов 144
Глава 8. Введение в ресурсы 162

6 Содержание
Глава 9. Применение других типов Mesh 177
Глава 10. Использование вспомогательных классов 193

ЧАСТЬ III

БОЛЕЕ СОВЕРШЕННЫЕ МЕТОДЫ

ПОСТРОЕНИЯ ГРАФИКИ

Глава 11. Введение в программируемый конвейер, язык
шейдеров 216
Глава 12. Использование языка шейдеров HLSL '237
Глава 13. Рендеринг скелетной анимации 257
ЧАСТЬ IV

ЗВУК И УСТРОЙСТВА ВВОДА

Глава 14. Добавление звука 276
Глава 15. Управление устройствами ввода 291
ЧАСТЬ V

2D ГРАФИКА

Глава 16. Приложение Direct3D для 2D-графики 308
Глава 17. Использование DirectDraw для рендеринга
2D-графики 320
ЧАСТЬ VI

ДОБАВЛЕНИЕ СЕТЕВЫХ ВОЗМОЖНОСТЕЙ

Глава 18. Организация сети с равноправными узлами
с помощью DirectPlay 332
Глава 19. Создание сессии Client/Server 350

Содержание 7
Глава 20. Особенности более совершенного использования
сетей 366
Глава 21. Методы достижения максимального
быстродействия 379

ЧАСТЬ VII

ПРИЛОЖЕНИЯ

Приложение А. Использование сборок диагностики 386
Приложение В. Воспроизведение музыки и видео 389

Алфавитный указатель 393

Оглавление

Предисловие 14
Об авторе 15
Посвящается 16

Участники работы 16

Будем признательны за ваши отзывы и пожелания! 17
Введение 18

История Управляемого DirectX 18
Включенные пространства имен 20
Выбор программы 21

ЧАСТЬ I. ВВЕДЕНИЕ В КОМПЬЮТЕРНУЮ ГРАФИКУ.... 23
Глава 1. Введение в Direct3D 24

Начало работы 24
Устройство Direct3D 25
Создание трехмерного треугольника 32
Автоматический сброс устройства во время изменения размеров
окна 40
Создание освещения 41
Состояния устройства и преобразования 44
Свопинг-связки и рендеры 44
Краткие выводы 46

Глава 2. Выбор подходящего устройства 48

Адаптеры системы 48
Поддержка аппаратного устройства 53
Проверка возможностей устройства 54
Краткие выводы 56

Глава 3. Введение в технологию рендеринга 57

Использование вершинных буферов 57
Текстурирование объектов 68
Краткие выводы 74

Оглавление 9

Глава 4. Более совершенные технологии рендеринга 76

Рендеринг с использованием примитивов различного типа 76
Использование индексных буферов 82
Использование буферов глубины или Z-буферов 87
Краткие выводы 90

Глава 5. Рендеринг «Меsh»-объектов 91

Определение Mesh-объектов 91
Использование материалов и освещения 94
Использование Mesh-объектов для рендеринга сложных
моделей 98
Краткие выводы 105

Глава 6. Использование Управляемого DirectX для
программирования игр 106

Выбор игры 106
Программирование игры 107
Добавление движущегося автомобиля в используемую сцену.... 118
Добавление препятствий 124
Последние штрихи 135
Краткие выводы 142

ЧАСТЬ П. ОСНОВНЫЕ КОНЦЕПЦИИ ПОСТРОЕНИЯ

ГРАФИКИ 143

Глава 7. Использование дополнительных свойств
и возможностей Mesh-объектов 144

Создание копий Mesh-объектов 144
Оптимизация данных Mesh-объекта 146
Упрощение существующих Mesh-объектов 149
Объединение вершин в Mesh-объектах 156
Создание нескольких объектов из одного 158
Краткие выводы 161

Глава 8. Введение в ресурсы 162

Класс ресурсов 162
Использование вершинных и индексных буферов 163
Механизм Locking, блокировка используемых буферов 164
Управление процедурой блокировки 167
Использование текстурных ресурсов 169
Блокировка текстур и получение описаний 171
Краткие выводы 176

10 Оглавление

Глава 9. Применение других типов Mesh 177

Упрощение Mesh-объектов 177
Управление степенью детализации, класс прогрессивных
Meshes-объектов 181
Рендеринг патч-объектов. Тесселяция объектов 185
Примеры тесселированных объектов 190
Краткие выводы 192

Глава 10. Использование вспомогательных классов 193

Рисование линий 193
Отображение текста 196
Рендеринг на поверхности 201
Рендеринг текстур Environment Maps 205
Краткие выводы 214

ЧАСТЬ III. БОЛЕЕ СОВЕРШЕННЫЕ МЕТОДЫ

ПОСТРОЕНИЯ ГРАФИКИ 215

Глава 11. Введение в программируемый конвейер,
язык тендеров 216

Рендеринг треугольника с использованием программируемого
конвейера 216
Использование шейдеров для рендеринга, использование
техник «TECHNIQUE» 225
Использование программируемого конвейера для рендеринга
mesh-объектов 228
Использолвание языка HLSL для создания пиксельного
шейдера 230
Краткие выводы 236

Глава 12. Использование языка шейдеров HLSL 237

Использование простых формул для моделирования анимации ... 237
Объединение цветов текстуры с цветами поверхности 239
Текстуры освещения 244
Моделирование световых бликов 247
Краткие выводы 256

Глава 13. Рендеринг скелетной анимации 257

Создание иерархической системы фреймов 257
Загрузка объектов с анимацией 262
Рендеринг анимированных объектов 267
Краткие выводы 274

Оглавление 11

ЧАСТЬ IV. ЗВУК И УСТРОЙСТВА ВВОДА 275

Глава 14. Добавление звука 276

Включение пространства имен SOUND 276
Загрузка и проигрывание статических звуков 276
Использование ЗD-звука 281
Управление слушателем 285
Использование звуковых эффектов 287
Краткие выводы 290

Глава 15. Управление устройствами ввода 291

Обнаружение устройств 291
Использование клавиатуры 294
Использование устройства мыши 299
Использование игровых клавиатур и джойстиков 301
Устройства обратной связи 303
Краткие выводы 306

ЧАСТЬ V. 2D ГРАФИКА 307
Глава 16. Приложение Direct3D для 2D-графики 308

Создание полноэкранного устройства отображения 308
Рендеринг спрайтов 310
Анимация спрайтов 315
Краткие выводы 319

Глава 17. Использование DirectDraw для рендеринга
2D-графики 320

Создание полноэкранного устройства DirectDraw 320
Анимация спрайтов 327
Краткие выводы 330

ЧАСТЬ VI. ДОБАВЛЕНИЕ СЕТЕВЫХ

ВОЗМОЖНОСТЕЙ 331

Глава 18. Организация сети с равноправными узлами
с помощью DirectPlay 332

Адреса DirectPlay 332
Создание Р2Р-соединения 334
Начало сеанса 337
Использование модели событий 341
Работа в сети 344

12 Оглавление
Обработка потерянных сессий 347
Краткие выводы 349

Глава 19. Создание сессии Client/Server 350

Создание выделенного сервера 350
Создание соединения клиент-сервер 353
Отслеживание моментов присоединения и выхода из сети 357
Передача пакетов данных по сети 359
Формирование отклика клиента 363
Обработка отключения сервера 365
Краткие выводы 365

Глава 20. Особенности более совершенного использования
сетей .-366

Модели событий и обработчики 366
Определение пропускной способности и статистики сети 368
Запуск приложений, использующих концепцию «Lobby» 371
Создание лобби-приложения 374
Добавление голосового чата 374
Краткие выводы 378

Глава 21. Методы достижения максимального
быстродействия 379

Преобразование типов в объекты 379
Побочные эффекты моделей событий 380
Эффективность методов 383
Краткие выводы 384

ЧАСТЬ VII. ПРИЛОЖЕНИЯ 385
Приложение А. Использование сборок диагностики 386

Перечисление всех опций в системе 386
Проверка отдельных пунктов 388

Приложение В. Воспроизведение музыки и видео 389

Воспроизведение звукового файла 389
Воспроизведение видео файла в отдельном окне 390
Использование видео файла в качестве текстуры 390

АЛФАВИТНЫЙ УКАЗАТЕЛЬ 393

Введение

DirectX API является мощным программным интерфейсом, позволя­
ющим разработчикам компьютерной графики писать быстродействую­
щие приложения, используя стандартизированный набор интерфейсов.
Первый выпуск DirectX совпал с выходом операционной системы
Windows 95 и назывался «Games SDK» (средства SDK для разработки
игр). С тех пор было выпущено более восьми новых версий API, однако,

они предназначались только для разработчиков, использующих языки про­

граммирования С и C++, поэтому существовала целая группа разработ­
чиков, которые не имели удобного доступа к функциональным возмож­
ностям DirectX.

История Управляемого DirectX

Первый выпуск Управляемого DirectX пришелся на 20 декабря 2002
(первая версия DirectX 9), однако проект продолжал находиться в разра­
ботке еще в течение некоторого времени. Позднее, во время разработки
циклов для DirectX 8.1 и продолжению работы над DirectX для Visual
Basic, мы начали прогон бета-версии Visual Studio.NET, и для нас сразу
стала очевидна актуальность и перспективность данного направления. Я
продолжил работу над прототипом «DirectX .NET», который впоследствии
стал называться Управляемым DirectX.
Вначале предполагалось, что Управляемый DirectX будет столь же
мощным, как и API. Ранее пользователи DirectX для Visual Basic не мог­

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

API. Частично это было связано непосредственно со временем выполне­
ния процедур на Visual Basic, а частично с нехваткой ресурсов библиотек

DLL.

В DirectX 8 мы попробовали устранить некоторые из этих проблем,
удалив интерфейсные уровни для большинства характеристик API,
Direct3D. Вместо имеющихся proxi DLL библиотек, которые сортирова­
ли или маршализировали данные, мы переместили Direct3D API непос­
редственно в библиотеку типов (OLE library). Правда, это совсем незна­
чительно улучшало характеристики, а также чрезмерно усложняло ин­
терфейс API, особенно для разработчиков на Visual Basic, на которых мы
ориентировались.

Введение
19
После выпуска DirectX 8 стало очевидно, что интерфейс API не со­
всем удобен в использовании. Примеры были сложны для понимания, и
код не напоминал привычные приложения на Visual Basic.
Большинство разработчиков, использующих Visual Basic, нашли API
слишком сложным в применении, а разработчики на C++ не видели при­
чин переключаться на API, поскольку для них это было неудобно и невы­
годно. До какого-то момента мы были интересны только домашним эн­
тузиастам, а студии-разработчики компьютерных игр даже не знали о
нашем существовании. Поэтому было необходимо направить работу над
нашим новым API на достижение быстродействия, а также удобства его
использования, что явилось бы достаточно вескими причинами для пе­
рехода из C++ кода, на котором писались многие программы, на С#. Та­
ким образом, была намечена концепция для разработки Управляемого
DirectX.
На Конференции Разработчиков Компьютерных Игр в Сан-Хосе в
2002 г. была представлена первая альфа-версия Управляемого DirectX на
базе версии DirectX 8.1., написанная исключительно на С# .
В этой версии имелось большинство базовых компонентов DirectX,
включая DirectMusic, который был исключен из окончательной версии
Управляемого DirectX. Единственными компонентами DirectX, не пред­
ставленными в первой альфа-версии, были DirectDraw и DirectShow, глав­
ным образом вследствие того, что мы не решили окончательно, включать
эти компоненты или нет.
Оглядываясь назад, на первую версию, можно без сомнения предпо­
ложить, что она была перспективной. Эта версия демонстрировала дос­
таточную оперативность Управляемого DirectX, и отзывы, которые мы
получили от пользователей, были на удивление положительны, хотя ра­
бочие характеристики этого уровня были еще недостаточно высоки. В
некоторых случаях мы смогли бы получить качество выполнения, соот­
ветствующее родному API, но даже при прокрутке простого сценария
создания кубической текстуры версия с управляемым кодом существен­
но проигрывала в скорости по сравнению с версией на C++.
Мы потратили еще несколько месяцев на подготовку следующего ва­
рианта — первой бета-версии DirectX 9. Мы сосредоточили внимание на
самых острых проблемах, добавили поддержку DirectDraw и удалили
поддержку DirectMusic. Мы также включили в команду разработчиков,
знакомых с С#. Полученная нами по результатам нашей работы обратная
реакция была быстрой и однозначной — эксплуатационные характерис­
тики были замечательные. Управляемый DirectX отличался от других уп-

20
Введение

равляемых API и напоминал скорее интерфейс COM API. Все компонен­
ты среды .NET Runtime остались общими, тогда как библиотеки Управ­
ляемого DirectX полностью изменились. Перед данным проектом мы ста­
вили две задачи: быстрота и простота в управлении. Стало очевидно, что
мы не учли последнего.
Полная перестройка API началась сразу после выхода первой бета-
версии. Мы обсуждали необходимые вопросы и с командой разработчи­
ков среды .NET runtime, и с пользователями бета-версии. В результате
мы собрали мнения всех заинтересованных источников и смогли спокой­
но выяснить и устранить недостатки данной версии. Я составил список
параметров и требований, которых было необходимо придерживаться.
Некоторые изменения были достаточно просты в осуществлении, напри­
мер, константы или имена структур в DirectX (и СОМ вообще). Другие
изменения были более сложными, в частности, добавление реестров к
классам. Мы выпустили вторую бета-версию и с тревогой ждали обрат­
ную реакцию от наших пользователей.
К счастью, отзывы были положительными. Мы предприняли шаги в
правильном направлении, и разработка интерфейса API продвигалась к
реальному продукту.
За месяц до появления заключительной версии DirectX 9 один из ва­
риантов бета-версии был разослан пользователям по почте. Это был не
полный комплект SDK, но он включал в себя Управляемый DirectX API.
Мы даже не представляли, как пользователи будут работать с этим без
каких-либо образцов и документации. Это было серьезным испытанием
для нас. Обратная реакция, которую мы получили, была положительной.
Люди отправляли на соответствующие форумы и Web-сайты статьи, опи­
сывающие, как использовать API.
Когда в декабре вышла заключительная версия Управляемого DirectX 9,
стало ясно, что мы добились желаемого результата.

Включенные пространства имен

Управляемый DirectX API имеет достаточно большой список имен,
namespaces, разделяющих функциональные возможности различных ком­
понентов DirectX. Имеется также универсальное пространство имен
«Microsoft.DirectX», которое размещает базовые возможности. Полный
список пространства имен, включенных в Управляемый DirectX, пере­
числен в таблице 1.

Введение
21

Таблица 1. Пространство имен Управляемого DirectX
Microsoft.DirectX
Microsoft.DirectX.Direct3D
Microsoft.DirectX.DirectDraw
Microsoft.DirectX.DirectPlay
Microsoft.DirectX.DirectSound
Microsoft.DirectX.Directlnput

Microsoft.DirectX. AudioVideoPlayback

Microsoft.DirectX.Diagnostics
Microsoft.DirectX.Security
Microsoft.DirectX.Security.Permissions
Корневой каталог, содержит все общие
коды

Direct3D API графика, так же как вспомогательная библиотека D3DX
Графика DirectDraw API
Сетевой DirectPlay API.
Аудио DirectSound API.
Пользовательский вход в Directlnput API
API простого звукового и видео
воспроизведения

Простая диагностика API
Контроль доступа на глубокие уровни
DirectX

Классы разрешения для защиты доступа в DirectX

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

Выбор программы

Прежде чем начать описание работы с Управляемым DirectX, мы хо­
тели бы обратить внимание на некоторые моменты.
Первое, что нам понадобится для работы, — редактор исходного кода
и среда разработки. Я бы рекомендовал Visual Studio.NET 2003, поддер­
живающий объекты Microsoft. Независимо от типа редактора, понадо­
бится версия 1.1 среды .NET runtime, которую вы можете установить с
прилагаемого CD диска.

22
Введение

Также понадобится установленный DirectX 9.0 SDK Update. Я бы ре­
комендовал DirectX 9.0 Software Development Kit Update, включенный в
указанный CD диск. Там же можно найти множество примеров, а также
документацию на Управляемый DirectX.
Графические объекты, описываемые в первых разделах книги, долж­
ны запускаться и работать на любой современной графической карте.
Однако, более сложные объекты требуют установки более совершенных
видеокарт, способных работать с программами текстурирования, с вер­
шинными и пиксельными шейдерами. Карта GeForce3 является подходя­
щей для таких задач, однако, я бы порекомендовал карту, способную ра­
ботать с шейдером модели 2.0 (например, Radeon 9700 и выше).
Описывая принципы программирования Управляемого DirectX, мы
подразумеваем, что читатель знаком с данной тематикой. В противном
случае, книга может быть достаточно сложна для восприятия. Книга пред­
назначена для разработчиков компьютерной графики, имеющих навыки
и опыт работы с DirectX, которые могут найти здесь дополнительную
информацию относительно создания более продвинутых мультимедий­
ных приложений, использующих Управляемый DirectX. Код и алгорит­
мы, приводимые в тексте этой книги, написаны на языке С#, но на ком­

пакт-диске могут быть приведены версии процедур, написанные на Visual

Basic.NET. Компакт диск содержит и другие исходники программ, как на
языке С#, так и на Visual Basic.NET. Также DirectX 9 SDK Update можно
загрузить с сайта http://msdn.microsoft.com.
Теперь мы можем приступить к рассмотрению принципов работы и
программирования с помощью Управляемого DirectX.

ЧАСТЬ I

ВВЕДЕНИЕ В КОМПЬЮТЕРНУЮ

ГРАФИКУ

Глава 1. Введение в Direct3D
Глава 2. Выбор подходящего устройства
Глава 3. Введение в технологию рендеринга
Глава 4. Более совершенные технологии рендеринга
Глава 5. Рендеринг «Меsh»-объектов
Глава 6. Использование Управляемого DirectX для
программирования игр

24
Часть I. Введение в компьютерную графику

Глава 1. Введение в Direct3D

Добавление трехмерной графики является одним из наиболее попу­
лярных аспектов мультимедийного приложения. Используя современные
мощные системы обработки и графический процессор GPU, можно ото­
бражать самые реалистичные сцены в реальном масштабе времени. Уп­
равляемый Direct3D позволяет разработчикам компьютерных игр просто
и быстро формировать на экране сложные элементы графики и мульти­
пликации. В этой главе мы охватим следующие моменты.
• Создание Direct3D устройств.
• Рендеринг или визуализация изображения в различных коорди­
натных системах (экранные и обычные координаты).
Добавление освещения к отображаемому полигону.

Начало работы

Перед запуском своего первого приложения в среде Managed Direct3D
необходимо сделать следующее:
1. Загрузить приложение Visual Studio.NET и создать новый проект
(new project).
2. Выбрать в качестве пространства проекта или программы среду
Visual C#, создать новое окно приложений (понадобится также место для
рендеринга и стандартных форм Windows).
3. Придумать и записать имя нового проекта.
После того, как мы создали новый проект, необходимо убедиться, что
к проекту добавлены необходимые ссылки на Управляемый DirectX, что
позволит в дальнейшем использовать его компоненты. Для этого, исполь­
зуя меню проекта, кликните на команду добавления Add References и

добавьте приложения MicrosoftDirectX и Microsoft.DirectX.Direct3D.

Пока это все, что может понадобиться нам на первом этапе.
Теперь, прежде чем начать использовать Управляемый DirectX, необ­
ходимо добавить два новых элемента в директиву «using», позволяющих
автоматически идентифицировать используемые нами компоненты. Это
можно сделать, открыв окно записи кода для главной формы Windows в
вашем приложении (по умолчанию forml.cs) и добавив следующие стро­
ки в конце операторов «using»:

using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;

Последние описанные действия являются необязательными. Просто
они позволяют не классифицировать каждый раз объекты перед их ис-

Глава 1. Введение в Direct3D
25

пользованием. Итак, мы готовы к написанию первого приложения с по­
мощью Управляемого DirectX.

Устройство Direct3D

Выполнение всех графических операций в Direct3D определяется клас­
сом устройства. Можно полагать, что этот класс аналогичен графическо­
му устройству и графической карте, установленной на компьютере.
Устройство является первостепенным относительно всех других гра­
фических объектов в сценарии. Компьютер может иметь или не иметь
графические устройства, при этом, используя приложение Direct3D, мож­
но управлять работой некоторых или большинства из них.
Существуют три типа конструктора программ, которые могут исполь­
зоваться для создания устройства. Пока мы будем использовать только
один из них, а остальные рассмотрим позднее. Данный конструктор вклю­
чает следующие параметры:

public Device (System.Int32 adapter, Microsoft.DirectX.Direct3D.DeviceType
deviceType, System.Windows.Forms.Control renderWindow,
Microsoft.DirectX.Direct3D.CreateFlags behaviorFlags,
Microsoft.DirectX.Direct3D.PresentParameters presentationParameters )

Первый параметр adapter (адаптер) относится к тому физическому
устройству, которое мы хотим классифицировать.
Каждое устройство в компьютере имеет идентификатор адаптера (от
О до числа, на единицу меньшего, чем число имеющихся устройств).
Нулевое значение для параметра adapter подразумевает установку уст­
ройства по умолчанию.

ПЕРЕГРУЗКИ ОПЕРАЦИЙ В КОНСТРУКТОРЕ УСТРОЙСТВ

Вторая перегрузка для устройства идентична первой, за исключе­

нием параметра renderWindow, который принимает указатель IntPtr

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

ный указатель IntPtr, который является неуправляемым СОМ указа­

телем для интерфейса IDIRECT3DDEVICE9. Она может использовать­

ся при необходимости работы с неуправляемым приложением по­

средством управляемого кода.

Следующий параметр DeviceType (тип устройства) сообщает прило­
жению Direct3D, какой тип устройства мы хотим создать. Обычно, значе­
нием этого параметра является опция DeviceType.Hardware, подразуме­
вающая использование аппаратного устройства. Другой вариант значе-

26 Часть I. Введение в компьютерную графику
ния — опция DeviceType.Reference, которая позволяет использовать до­
полнительное или эмулированное устройство растеризации (rasterizer),
реализующее все возможности Direct3D Realtime, но работающее чрез­
вычайно медленно. Эту опцию целесообразно использовать главным об­
разом для отладки программных задач или для проверки параметров при­
ложений, не поддерживаемых вашей видеокартой.
ИСПОЛЬЗОВАНИЕ ПРОГРАММНЫХ УСТРОЙСТВ

Следует обратить внимание, что эмулированный rasterizer постав­

ляется только с DirectX SDK, при использовании DirectX Runtime эта

опция будет недоступна. Последнее значение — DeviceType.Software

позволяет использовать программный rasterizer.

Параметр renderWindow (окно рендеринга) связывает окно с создан­
ным устройством. Поскольку класс управления окнами содержит деск­
риптор окна, это облегчит использование соответствующего класса в ка­
честве окна рендеринга. Для этого параметра можно использовать фор­
му, панель, или любой другой производный класс. На данном этапе мы
будем использовать только формы.
Следующий параметр behaviorFlags (флажки режимов) используется
для управления режимами устройства после его создания. Большинство
значений списка CreateFlags может быть объединено, что позволит при
необходимости установить множественные режимы работы устройства.
Некоторые из этих флажков являются взаимоисключающими, однако, об
этом будет рассказано позже. Пока мы будем использовать флажок
SoftwareVertexProcessing, передающий всю обработку вершин централь­
ному процессору. Несмотря на то, что таким образом операции выполня­
ются медленнее, чем при использовании графического процессора, на­
дежнее будет использовать именно такой подход, т.к. не всегда известно
наверняка, поддерживает ли наша графическая плата этот режим.
Последний параметр presentationParameters управляет представлени­
ем данных на экране. Посредством этого класса можно управлять любы­
ми параметрами отображаемых данных. Позже мы коснемся деталей этой
структуры, а сейчас уделим внимание значениям Windowed и SwapEjfect.
Значение Windowed является логической переменной, определяющей,
работает ли устройство в полноэкранном (значение в оконном режиме (значение «true»-«истина»).
Значение SwapEffect используется для описания режима работы бу­
ферной подкачки. Если вы выбрали значение SwapEffectFlip, будет со­
здан вторичный буфер и произойдет копирование, независимо от состоя­
ния первичного буфера на данный момент. Значение SwapEffect.Copy
сходно со значением Flip, но потребует от программиста установки зна-

Глава 1. Введение в Direct3D
27

чения «1» для числа вторичных буферов. В данном случае мы выберем
опцию SwapEffect.Discard, которая просто сбрасывает содержимое буфе­
ра, если он не готов к представлению.
Теперь, когда у нас имеется эта информация, мы можем создать уст­
ройство, вернувшись к нашему коду. Сначала мы должны определить
объект, используемый нашим приложением, и добавить к нему новую
переменную (private variable) «device». Для этого включите следующую
строку в раздел определения класса:

private Device device = null;

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

///


/// We will initialize our graphics device here
///

public void InitializeGraphics))
(
// Set our presentation parameters
PresentParameters presentParams = new PresentParameters()
presentParams.Windowed = true;
presentParams.SwapEffeet = SwapEffect.Discard;
// Create our device
device = new Device(0, DeviceType.Hardware, this,
CreateFlags.SoftwareVertexProcessing, presentParams);
1

Таким образом, мы определяем параметр предоставления presentParams,

в котором устанавливаем описанные выше значения (Windowed и
. SwapEffect), и затем создаем устройство. Нулевое значение параметра
adapter подразумевает установку устройства по умолчанию. В результате
мы создали фактическое аппаратное устройство, в противоположность
устройству, эмулированному программными средствами.
Следует обратить внимание, что в рассмотренном коде использова­
лось ключевое слово «this», подразумевающее наше текущее окно ренде­
ринга. Поскольку наше приложение, и в особенности этот класс, являют­
ся своего рода винформой, мы просто используем его. Как уже упомина­
лось, мы возложили вершинную обработку на наш центральный процес­

сор.

Теперь осталось переписать основной метод для вызова процедуры
инициализации InitializeGraphics:

28 Часть I. Введение в компьютерную графику

static void Main()
(
using (Forml frm = new Forml())
(
// Show our form and initialize our graphics engine

frm.Show();

frm.InitializeGraphics();

Application.Run(frm);

I

i

Что мы здесь сделали? Сначала, мы добавили оператор или директиву.
«using» для создаваемой формы. Это гарантирует размещение нашей
формы в каталоге, когда приложение оставляет область этого блока. За­
тем, мы добавили команду Show, для того чтобы гарантировать, что окно
загружено и отображено (и таким образом создан хэндл окна) прежде,
чем мы попытаемся создать наше устройство. Затем мы вызвали функ­
цию инициализации устройства и использовали стандартный алгоритм
для нашего приложения. Теперь мы можем скомпилировать это первое
приложение в Direct3D и запустить его.
Следует добавить, что созданное приложение довольно простое. Оно
создает устройство, но фактически ничего с ним не делает, и глядя на это
выполняемое приложение, мы не можем сказать, что оно как-то отлича­
ется от первоначально созданного пустого С# проекта. Необходимо пе­
реписать его и отобразить что-нибудь на нашем экране.
Классы Windows-form имеют встроенный метод, позволяющий отсле­
живать момент, когда необходимо обновить или «перерисовать» окно —
это метод OnPaint (можно также использовать приложение Paint). Доба­
вим этот метод в наш код рендеринга. Нет смысла делать сейчас какие-то
сложные вещи, попробуем просто очистить окно и заполнить его чистым
цветом. Добавьте следующий код к определению класса:

protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)

{

device.Clear(ClearFlags.Target, System.Drawing.Color.CornflowerBlue,
l.Of, 0);

device.Present();

}

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

Глава 1. Введение в Direct3D 29
Вторым параметром является цвет, используемый при очистке наше­
го окна. После того как устройство очищено, мы можем обновить состо­
яние дисплея. Данную процедуру будет выполнять метод представления
Present. Существует несколько различных вариантов данного метода, один
из них, показанный здесь, использует всю область устройства. Другие
перегрузки мы обсудим позже.
Запустив приложение, мы увидим окно, заполненное синим цветом
(цвет василька). Можно изменять размеры окна или разворачивать его на
весь экран, и каждый раз окно будет заполняться синим цветом. Несмот­
ря на то, что наше новое устройство уже что-то из себя представляет,
созданное приложение все еще довольно скучно. Можно было сделать то
же самое, просто установив цвет фона формы в конструкторе програм­
мы. Теперь попробуем нарисовать еще что-нибудь.
Основным объектом, используемым в трехмерной графике, является
треугольник, он же является элементарным полигоном при построении
изображений. С достаточным количеством треугольников можно пред­
ставить и отобразить что угодно, даже гладкие изогнутые поверхности.
Таким образом, в качестве нашего первого рисунка можно выбрать треу­
гольник. Чтобы упростить процедуру, будем рисовать треугольник, ис­
пользуя экранные координаты. Для этого нам необходимо, во-первых,
сформировать данные, включающие информацию о треугольнике, во-вто­
рых, дать команду устройству для выполнения процедуры рисования,
другими словами, вызвать метод рисования.
К счастью, Управляемый DirectX уже имеет встроенную конструкцию
для хранения и обработки информации об указанных треугольниках. В
составе имен Direct3D существует класс вершин CustomVertex, который
размещает используемые в Direct3D различные сборки вершин в форма­
те «CustomVertex». Структура вершинного формата содержит данные в
понятном для Direct3D виде. Мы коснемся этого вопроса позже, а сейчас
будем использовать для нашего треугольника структуру TransformedCo-
lored — преобразование цветов. Эта структура сообщает Direct3D runtime,
что наш треугольник не требует каких-либо преобразований, например,
вращения или перемещения, поскольку мы будем определять или уста­
навливать его положение посредством экранных координат. Данная струк­
тура включает цветовые параметры для каждой вершины треугольника.
Вернемся к методу OnPaint и добавим следующий код после вызова Clear:

CustomVertex.TransformedColored[j verts = new
CustomVertex.TransformedColored[3];
verts[OJ.SetPosition(new Vector4 (this. Width / 2. Of, 50. Of, 0.5f, 1.0 f).) ;
verts[0].Color = System.Drawing.Color.Aqua.ToArgb();
verts[lJ.SetPosition(new Vector4(this.Width - (this.Width / 5.Of),
this.Height -

(this.Height / 5.Of), 0.5f, 1.Of));

30 Часть I. Введение в компьютерную графику
verts [I] .Color = System.Drawing.Color.Black.ToArgb();
verts[2].SetPosition(new Vector4(this.Width / 5.Of, this.Height -
(this.Height / 5.Of)

, 0.5f, l.Of));

verts [2] .Color = System.Drawing.Color.Purple.ToArgb();

Так как каждый элемент массива, который мы создали, представляет
одну точку в нашем треугольнике, таким образом будет создано три эле­
мента. Затем, используя структуру Vector4, мы вызываем метод SetPosition
для каждого элемента массива. Местоположение преобразованной вер­
шины определяется значениями X и Y в координатах экрана (относи­
тельно начала координат окна 0,0), а также значениями глубины Z и rhw-
(обратная величина «homogenous w»). Последние два значения для на­
шей выборки игнорируются. Структура Vector4 очень удобна для зада­
ния информации о треугольнике.
Далее мы устанавливаем цвет каждой вершины. Следует обратить
внимание на то, что мы должны вызвать используемый для этого метод
задания стандартных цветов ToArgb. В приложении Direct3D подразуме­
вается, что цвета будут определяться 32-разрядными целыми числами, и
данный алгоритм преобразует базовый цвет в этот формат.
Важно помнить и то, что для определения координат нашего треу­
гольника мы используем ширину и высоту текущего окна и должны это
учитывать при изменении размеров треугольника.
Теперь, когда мы определили данные треугольника, необходимо со­
общить приложению Direct3D о том, что мы готовы начать рисование, и
указать, каким образом мы будем это делать. Для этого можно использо­
вать следующий код, добавляющийся в процедуру OnPaint:

device.BeginScene ();

device.VertexFormat = CustomVertex.TransformedColored.Format;

device.DrawUserPrimitives(PrimitiveType.TriangleList, 1, verts);

device.EndScenef);

Здесь команда BeginScene уведомляет Direct3D о том, что мы собира­
емся что-то нарисовать, и определяет его «готовность к этому». Далее,
мы должны сообщить, что именно мы собираемся нарисовать. Метод
VertexFormat устанавливает для приложения Direct3D runtime использу­
емый нами в дальнейшем формат непрограммируемого конвейера (фор­

мат «fixed function pipeline»). В данном случае для рисования мы исполь­

зуем преобразованный и цветной вершинный формат. О непрограммиру­
емом конвейере мы расскажем позднее.
Функция или метод DrawUserPrimitives определяет место, где разме­
щается рисунок. Что же означают параметры этой функции? Первый па­
раметр — это тип примитива, который мы планируем рисовать. Суще-

Глава 1. Введение в Direct3D 31

ствуют различные примитивы, которые нам доступны, но сейчас, для про­

стоты, мы будем рисовать набор треугольников TriangleList. Второй па­
раметр — число треугольников, которые мы хотим нарисовать, или дру­
гими словами, общее число вершин, разделенное на три. Для случая од­
ного треугольника, это значение равно «1». Последний параметр этой
функции означает, какие данные Direct3D будет использовать при рисо­
вании. В нашем случае это вершины.
Последняя команда EndScene сообщает приложению Direct3D runtime
об окончании процедуры рисования. Эта команда должна присутство­
вать всегда, если использовалась команда BeginScene.
Теперь можно компилировать и запускать наше новое приложение.
Обратите внимание, что на цветном фоне теперь нарисован треугольник.
Цвета вершин треугольника задаются нами в программе, а на изображе­
нии цвета внутри треугольника плавно изменяются от одного к другому.
Direct3D автоматически интерполирует цвета. Для практики попробуйте
изменить базовые цвета и почувствуйте результат.
Если вы уже опробовали работу нового приложения, то, наверное, за­
метили некоторые особенности.
Например, при уменьшении размера окна его содержимое не обнов­
ляется, и никаких действий не происходит. Причина в том, что Windows
не рассматривает уменьшение размера окна как случай, когда вам необ­
ходимо перерисовать целое окно. В конце концов, вы просто удалили
часть информации, которая была отображена, при этом вы не стерли дан­
ные, который там находились.
К счастью, есть простой способ обойти эту особенность. Мы можем
сообщить Windows, что нам всегда необходимо окно, цвет которого бу­
дет обновляться. Это легко реализовать, аннулируя окно в конце метода

OnPaint.

this.Invalidate();

Может показаться, что мы сломали наше приложение! В результате
выполнения этой командной строки мы видим главным образом пустой
экран, и наш мерцающий треугольник. И этот эффект проявляется более
отчетливо, когда вы изменяете размеры вашего окна. Что же произошло?
Оказывается, Windows пытается обработать ситуацию и перерисовывает
текущую форму нашего окна после аннулирования, окрашивая и вне­
шнюю сторону объекта. Его легко зафиксировать, изменяя параметр style
созданного нами окна. Для этого в конструкторе формы замените сег­
мент «TODO» следующей строкой:

this.SetStyLe(ControlStyles.ALlPaintinglnWmPaint | ControlStyles.Opaque,

true);

32
Часть I. Введение в компьютерную графику
Теперь, когда мы запускаем приложение, все работает нормально.
Подразумевается, что при выполнении этого приложения полное закра­

шивание должно происходить внутри объекта (сообщение WmPaint класса

Win32), и что наше окно будет не прозрачно. Это гарантирует, что ника­
кого бесконтрольного закрашивания вне пространства нашего окна не
произойдет. Обратите внимание, что если при изменении размеров окно
попадает в невидимую область, приложение выполняться не будет.

Создание трехмерного треугольника

Созданное нами в предыдущем параграфе приложение не является
трехмерным. Оно касается только плоского цветного треугольника, на­
рисованного внутри окна, которое можно легко создать с помощью гра­
фического интерфейса GDI. Теперь возникает вопрос, как можно создать
реалистичный объект в трехмерном пространстве? Для этого нужно из­
менить наше существующее приложение.
Если вспомнить, что раньше, когда мы формировали данные нашего
треугольника, мы использовали нечто, называемое преобразованными
координатами (transformed coordinates). Эти координаты, как известно,
лежат в пространстве экрана и легко определяются. А что если использо­
вать непреобразованные координаты? Они и составляют наибольшую
часть сцены в современной 3D-иrpe.
Когда мы определяем эти координаты, нам необходимо позициониро­
вать каждую вершину не в экранном пространстве, а в пространстве ми­
ровых координат. Можно представить внешнее пространство, как беско­
нечное трехмерное Декартово пространство, в любом месте которого мы
можем размещать объекты. Теперь давайте модифицируем наше прило­
жение и нарисуем непреобразованный треугольник.
Вначале мы изменим данные нашего треугольника, чтобы использо­
вать один из типов непреобразованных вершинных форматов. В этом
случае нас волнует местоположение и цвет нашей вершины, поэтому мы
выбираем команду CustomVertex.PositionColored. Замените ваш код для
данных треугольника на следующий:

CustomVertex.PositionColored[] verts = new CustomVertex.PositionColored[3];
verts[0].SetPosition(new Vector3(0.0f, l.Of, l.Of));
verts[0].Color = System.Drawing.Color.Aqua.ToArgb();
verts[l].SetPosition(new Vector3(-l.Of, -l.Of, l.Of));
verts[1].Color = System.Drawing.Color.Black.ToArgb();
verts[2].SetPosition(new Vector3(l.Of, -l.Of, l.Of));
verts [2] .Color = System.Drawing.Color.Purple.ToArgb();

Измените также свойства вершинного формата VertexFormat:

.лава 1. Введение в Direct3D 33

device.VertexFormat = CustomVertex.PositionColored.Format;

Теперь, если вы запустите приложение, ничего не произойдет, и вы
вернетесь назад, к вашему цветному экрану. Прежде, чем выяснить при­
чину, давайте займем одну минуту, чтобы описать последние действия.
Легко заметить, что мы переписали наши данные для использования вме­
сто них структуры PositionColored. Эта структура будет сохранять вер­
шину в пространстве внешних координат, а также цвет каждой вершины.
Поскольку вершины не являются преобразованными, мы используем
класс Vector3 вместо класса Vector4, который мы использовали с преоб­
разованным объектом.
Элементы Vector3 структурируют карту непосредственно в координа­
тах мирового пространства (координаты X, Y, и Z). Мы также должны
удостовериться, что приложению Direct3D известно о том, что мы изме­
нили тип рисуемых данных. Таким образом, чтобы использовать новую
непреобразованную и цветную вершину, мы изменяем наш непрограм­
мируемый конвейер («fixed function pipeline»), модифицируя свойства вер­
шинного формата VertexFormat.
Почему же ничего не отображается, когда мы запускаем наше прило­
жение? Проблема в том, что, располагая нашу вершину в мировом про­
странстве, мы не дали Direct3D никакой информации относительно того,
как он должен ее отобразить. Мы должны добавить в сцену камеру, кото­
рая может определять и рассматривать нашу вершину. В преобразован­
ных координатах камера была не нужна, потому что размещение верши­
ны в экранном пространстве однозначно определяло ее местоположение.

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

дое преобразование определяется матрицей 4x4, которую вы можете пе­
реслать в Direct3D. Преобразование проекции используется для опреде­
ления того, как сцена проецируется на экран. Один из самых простых
способов создания матрицы проекции состоит в использовании функции
PerspectiveFovLH в классе Matrix.
Таким образом, в результате выполнения описанных процедур созда­
ется матрица проекции левой системы координат.
Что означает левая система координат, и какое это имеет значение? В
обычной Декартовой системе координат положительная ось X направле­
на слева направо, тогда как положительная ось Y направлена вверх. Тре­
тьей координатой является ось Z. В левой системе координат положи­
тельная ось Z направлена от вас, в то время как в правой системе коорди­
нат, положительная ось Z направлена к вам. Это легко запомнить, если
направить пальцы руки по направлению оси X, а большой палец — по
направлению оси Y, как показано на рис. 1.1. Другими словами, если,
глядя из конца вектора Z, поворот от оси X к оси Y осуществляется про-
:
Зак.
604

34
Часть I. Введение в компьютерную графику
тив часовой стрелки — это правая система координат, если по часовой
стрелке — левая система координат.

Левая система координат Правая система координат

Y

*-Х

Рис. 1.1. Трехмерная система координат
Приложение Direct3D использует левую систему координат. Если вы
пишете код для правой системы координат, необходимо сделать две вещи.
Сначала нужно перестроить порядок треугольников таким образом, что­
бы они расположились по часовой стрелке от передней стороны (вскоре
мы объясним данную процедуру). Затем использовать матрицу масшта­
бирования внешнего пространства относительно отрицательной оси Z.
вы можете сделать это путем перестановки членов М31, М32, МЗЗ и М34
матрицы вида. Затем вы можете использовать версию RH матричной фун­
кции для построения матрицы правой системы.
Теперь, создавая новое приложение, мы будем использовать только
левую систему координат, с которой работает Direct3D. Пример для на­
шей функции матрицы проекции имеет вид:

public static Microsoft.DirectX.Matrix PerspectiveFovLH ( System.Single

fieldOfViewY,

System.Single aspectRatio , System.Single znearPlane , System.Single
zfarPlane )

Преобразование проекции используется для описания сцены, пред­
ставленной в виде усеченной пирамиды (frustum), где внутренняя часть
пирамиды является просматриваемой областью нашей сцены. Два пара­
метра в нашей функции, ближняя и дальняя плоскости (znearPlane и

zfarPlane) описывают пределы этой пирамиды, причем дальняя плоскость

является основанием, а ближняя плоскость проходит по месту отсечения
вершины пирамиды, рис.1.2. Параметр поля зрения определяется углом
при вершине пирамиды, рис.1.3, а форматное соотношение сторон —
аналогично форматам телевидения, например, широкоформатное теле­
видение имеет соотношение 1.85. Можно понимать этот параметр как
отношение ширины изображения к высоте. Следует отметить, что

Глава 1. Введение в Direct3D
35

Direct3D прорисовывает только те объекты, которые заключены внутри
усеченной пирамиды.

передняя
плоскость
отсечения

видимое
пространство

задняя
плоскость
отсечения

Рис. 1.2. Визуализируемое видимое пространство

местоположение
камеры
>Z

Рис. 1.3. Определение поля зрения
Итак, теперь попробуем добавить камеру к нашей сцене, поскольку
без камеры мы не сможем выполнять описанные выше преобразования:

public static Microsoft.DirectX.Matrix LookAtLH(Microsoft.DirectX.Vector3

cameraPosition,

Microsoft.DirectX.Vector3 cameraTarget , Microsoft.DirectX.Vector3
cameraUpVector )

36 Часть I. Введение в компьютерную графику
Эта функция достаточно очевидна. Требуются три параметра, кото­
рые описывают свойства камеры. Первый параметр — положение каме­
ры во внешней системе координат. Следующий параметр — местополо­
жение того объекта во внешней системе координат, на который должна
смотреть камера. Последний параметр — направление камеры, в нашем

случае «Up» — вверх.

С описанием преобразования проекции и преобразования вида,
Direct3D теперь имеет достаточно информации, чтобы отобразить наш
недавно созданный треугольник. Давайте изменим наш код, чтобы ото­
бразить некий объект. Мы добавим новую функцию SetupCamera (уста­
новка камеры) в нашу процедуру OnPaint сразу после вызова очистки
Clear. Тело этой функции будет включать следующее:

private void SetupCamera()
device.Transform.Projection = Matrix.PerspectiveFovLHl(float)Math.PI / 4,
this.Width / this.Height, i.Of, 100.Of);
device.Transform.View = Matrix.LookAtLH(new Vector3(0,3, 5.Of), new

Vector3(),

new Vector3(0,1,0));
i

Как вы можете видеть, мы создаем матрицу преобразования проек­
ции для нашего устройства, чтобы обозначить приложению Direct3D об­
ласть наблюдения. Затем мы определяем нашу матрицу вида и задаем
информацию о положении камеры. Добавьте обращение к этой функции
в нашу процедуру OnPaint после вызова очистки Clear и запустите еще
раз наше приложение.
Что мы видим теперь? Мы нарисовали наш треугольник, но теперь он
оказался весь черный, даже при том, что мы определили цвета этого тре­
угольника. Еще раз, проблема заключается в различии между предвари­
тельно преобразованным треугольником (pretransformed), который мы
нарисовали в первом приложении, и нашим непреобразованным треу­
гольником теперь. В непреобразованной среде приложение Direct3D по
умолчанию использует освещение, чтобы определить конечный цвет пик­
села каждого примитива в сцене. Так как мы не используем никакого
освещения в нашей сцене, нет никакой внешней засветки на нашем треу­
гольнике, и поэтому он кажется черным. Если мы уже определили цвет и
хотим, чтобы наш треугольник появился, можно пока просто выключить
освещение в сцене, вы можете выполнить это, добавив следующую стро­
ку в конце вызова функции SetupCamera:

device.RenderState.Lighting = false;

Глава 1. Введение в Direct3D
37

ИСПОЛЬЗОВАНИЕ СОСТОЯНИЙ РЕНДЕРИНГА В УСТРОЙСТВЕ

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

зоваться для управления различными сценами в конвейере ренде­

ринга. Мы обсудим часть из них в последующих главах.

Теперь при запуске приложения мы увидим треугольник, напоминаю­
щий наш первый, предварительно преобразованный треугольник. Мо­
жет показаться, что, выполнив немалое количество действий, мы верну­
лись в ту же самую точку, где мы находились еще до перехода к нашим
непреобразованным треугольникам. Какие реальные преимущества мы
получили от проведения этих изменений? Главное заключается в том,
что теперь мы имеем треугольник в реальном трехмерном пространстве,
это предпочтительнее, чем просто рисунок в координатах экрана.
Для более значимого восприятия того, что мы действительно имеем
трехмерное изображение треугольника, попробуем вращать его. Как же
это можно сделать? Это достаточно просто, мы должны изменить преоб­
разование пространства.
Преобразование пространства используется в устройстве для преоб­
разования объектов, нарисованных в пространстве моделей, где каждая
вершина определена относительно модели, расположенной во внешнем
пространстве. Преобразованием пространства может быть любая комби­
нация перемещения, вращения и масштабирования. Так как на данном
этапе мы хотим просто вращать наш треугольник, то для этого мы вы­
полним единственное преобразование. Каждое преобразование характе­
ризуется своей матрицей. У матричного объекта может быть множество
функций, позволяющих выполнять эти преобразования. Добавьте следу­
ющую строку к вашей функции SetupCamera:

device.Transform.World - Matrix.Rotations((float)Math.PI / 6.Of);

Эта строка сообщает приложению Direct3D о типе используемого пре­
образования для каждого рисуемого объекта. В данном случае это вра­
щение нашего объекта относительно оси Z. Угол поворота задается стро­
го в радианах. В библиотеке функций Direct3DX, которую мы добавим
позже к нашему проекту, существует вспомогательная функция

Geornetry.DegreeToRadians.

Пока мы выбрали произвольный угол вращения, чтобы просто пока­
зать сам эффект. В результате мы видим на экране наш треугольник, по­
вернутый вокруг- оси Z.
Теперь попробуем вращать треугольник непрерывно.

38 Часть I. Введение в компьютерную графику
Для этого произведем следующее преобразование пространства:
device.Transform.World = Matrix.RotationZ((System.Environment.TickCount

/ 450.Of)

/ (float)Math.PI);

В результате этого мы видим треугольник, медленно вращающийся
вокруг оси Z.
Движение кажется немного прерывистым, но это вызвано дискретно­
стью параметра TickCount. Данный параметр в системном классе пред­
ставляет из себя некоторый дополнительный интерфейс для метода
GetTickCount в интерфейсе приложений Win32 API, который имеет врем
менную разрешающую способность приблизительно 15 миллисекунд. Это
означает, что значение, приведенное здесь, изменяется с приращением
приблизительно 15 мс, что и вызывает это прерывистое поведение. Мы
легко можем сгладить вращение при наличии нашего собственного счет­
чика, использующего свое приращение, отличное от TickCount. Добавь­
те новое значение переменной угла в виде числа с плавающей точкой.
Тогда изменение вашего преобразования будет иметь следующий вид:

device.Transform.World = Matrix.RotationZ(angle / (float)Math.PI);
angle += O.lf;

Теперь треугольник вращается более плавно. Управлять вращением
(или другим перемещением) в этом случае не рекомендуется, так как при­
ращение переменной зависит от скорости изменения кода рендеринга. С
ростом быстродействия современных компьютеров, привязывая ваш код

рендеринга к переменной, можно получить приложение, работающее либо

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

зом:
device.Transform.World = Matrix.RotationAxis(new Vector3(angle /
((float)Math.PI * 2.Of),
angle / ((float)Math.PI * 4.Of), angle / ((float)Math.PI * 6.Of)),
angle / (float)Math.PI);

Глава 1. Введение в Direct3D 39
Главное различие между этой строкой программы и предыдущей —
это новая вызываемая функция RotationAxis. При вызове этой функции
мы сначала определяем ось, вокруг которой мы хотим вращать треуголь­
ник, и угол вращения, используя простую математическую формулу для
каждой оси. Теперь можно запустить это новое приложение и увидеть
результат нашего преобразования.
Увы, теперь наш треугольник начинает вращаться вокруг своих осей,
постоянно исчезая на мгновение, а затем вновь появляясь. Однако, мы
уже сталкивались с похожей ситуацией, связанной с освещением неви­
димых поверхностей.
При отображении фигур отдельные поверхности или стороны объек­
та оказываются вне поля зрения камеры и не прорисовываются. Такой

процесс называется back face culling, другими словами, устранение не­

видимых поверхностей (при двумерном изображении трёхмерных объек­
тов). Теперь для приложения runtime осталось определить, насколько и
какая часть поверхности попадает в поле зрения камеры. Быстрый взгляд
на опции culling в Direct3D дает хорошую подсказку. Имеются в наличии
три опции culling: none, clockwise и counterclockwise (соответственно:
никак, по часовой стрелке и против часовой стрелки). В случае выбора

варианта по часовой стрелке или против часовой стрелки, исходные объек­

ты, чьи вершины расположены в противоположном порядке, не рисуют­

ся.

Глядя на наш треугольник, можно видеть, что вершины располагают­
ся против часовой стрелки, рис. 1.4. Следует отметить, что такой порядок
в DirectX выбирается по умолчанию.

Рис. 1.4. Порядок вершинных доменов

Итак, когда мы знаем, как работает алгоритм исключения невидимой
поверхности, стало очевидно, что для нашего простого приложения мы
просто не нуждаемся в тех объектах, которые будут исключены. Суще­
ствует простое состояние рендера (render state), которое управляет режи­
мом отбора и устранения. Добавьте следующую строку к нашему вызову
функции SetupCamera:

40
Часть I. Введение в компьютерную графику
device.RenderState.CullMode = Cull.None;
Теперь, когда приложение запущено, все должно работать так, как мы
ожидали. Мы имеем плавно вращающийся неисчезающий треугольник.
Впервые мы получили реальное трехмерное приложение. Прежде чем
продолжить, попробуем слегка изменить размеры окна. Обратите внима­
ние на то, как при этом ведет себя треугольник, его положение и направ­
ление вращения не изменились.

Автоматический сброс устройства во время

изменения размеров окна

Любой, кто когда-либо писал приложение Direct3D на языке C++ или
DirectX для Visual Basic, знает, что при изменении окна вашего приложе­
ния устройство должно сброситься или перезапуститься, иначе прило­
жение Direct3D продолжит рендеринг используемой сцены с тем же са­
мым пространственным разрешением, что и раньше, и в результате изоб­
ражение будет скопировано (и соответственно вытянуто, чтобы запол­
нить окно) в измененное окно.
Управляемый DirectX способен контролировать процедуру изменения
форм окон и автоматически перезапускать устройство при изменении
окна. Для этого существует опция, называемая DeviceResizing (измене­
ние окна устройства), формирующая код или процедуру автоматическо­
го сброса устройства. Устанавливая данную опцию и определяя значе­
ние «true» для отмены (Cancel) класса обработчика событий EventArgs,
вы можете сбросить этот параметр в момент изменения окна. Добавьте
следующую функцию к вашему примеру:

private void CancelResize(object sender, CancelEventArgs e)

1

e. Cancel = true;

}

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

device.DeviceResizing += new CancelEventHandler(this.CancelResize);

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

Глава 1. Введение в Direct3D 41
две секции добавленного нами кода. Заданный по умолчанию режим
Управляемого DirectX отрабатывает процедуру изменения размеров уст­
ройства, и мы можем воспользоваться преимуществом этого режима.

Создание освещения

Теперь, когда мы создали вращающийся треугольник, мы можем до­
бавить освещение. Мы уже кратко упомянули об освещении ранее, когда
наш треугольник стал полностью черным после того, как мы использо­
вали непреобразованные треугольники. Фактически в тот момент мы
полностью выключили освещение в нашем сценарии. Первое, что мы
должны сделать, это — включить освещение, для этого необходимо ус­
тановить значение «true» в операторе освещения:

device.RenderState.Lighting = true;

Вы могли бы просто удалить эту строку, поскольку для устройства по
умолчанию установлено значение «lighting on» — освещение включено,
но оставим это для наглядности. Запуская приложение теперь, легко за­
метить, что мы опять вернулись к черному вращающемуся треугольнику.
Нам необходимо вначале определить свет и уже потом включить его.
Обратите внимание, что класс устройства имеет прикрепленный «свето­
вой» массив, каждый член которого определяет различные свойства све­
та. Если мы хотим «настроить» первоначальный свет в нашей сцене и
включить его, следует добавить следующий код в наш метод OnPaint сра­
зу после кода определения нашего треугольника:

device.Lights[0].Туре = LightType.Point;
device.Lights[0].Position = new Vector3();
ievice.Lights[0].Diffuse = System.Drawing.Color.White;
device.Lights[0] .Attenuation() = 0.2f;
device.Lights[0].Range = 10000.Of;

device.Lights[0].Commit));

device.Lights[0].Enabled = true;

Вначале определяется, какой тип освещения мы хотим отобразить. Мы
выбрали точечный источник света, который излучает во всех направле­
ниях одинаково, подобно свече или спирали лампы накаливания. Суще­
ствует также направленное или параллельное освещение. Например, на­
ходясь на Земле, можно думать о Солнце, как о направленном источнике
света, если учесть расстояние от Солнца до Земли (хотя в действительно­
сти. Солнце скорее является точечным источником, испускающим расхо­
дящиеся в пространстве световые волны). Направленный свет характе-
глвчется только направлением и цветом и исключает все другие свето-

42 Часть I. Введение в компьютерную графику
вые коэффициенты, как-то: затухание и диапазон, и является наиболее
предпочтительным в вычислительном аспекте его использования. Мож­
но отметить еще один тип светового источника — световое пятно (тип
источника, излучающего конический пучок световых лучей), который,
как следует из его названия, используется для получения светового пят­
на на объекте подобно тому, что вы наверняка часто видели на концерте
при освещении сцены. Учитывая большое количество коэффициентов в
таком варианте освещения (местоположение, направление, конический
угол и так далее), такое освещение более громоздко при использовании
его в вычислительных операциях.
Продолжим. Далее мы хотим установить положение нашего точечно-,
го источника освещения. Так как координаты центра нашего треугольни­
ка составляют (0, 0, 0), мы можем там же расположить и наш источник
света. Это можно сделать с помощью конструктора параметров
parameterless класса Vector3. Мы устанавливаем диффузный компонент
осветителя diffuse для получения рассеянного белого света, так чтобы
поверхность нормально освещалась. Далее мы задаем параметр затуха­
ния attenuation, определяющий изменение интенсивности света при из­
менении расстояния. Диапазон освещения range — это максимальное рас­
стояние, в пределах которого распространяется свет. В данном случае
установленный диапазон значительно превышает наши потребности. В
программном пакете DirectX SDK (включенном в CD диск) содержится
дополнительная информация о математических нюансах проблем осве­

щения.

Итак, мы применили свет к нашему устройству и включили его. Если
посмотреть на параметры освещения, можно обратить внимание, что один
из них является логической переменной и называется Deferred (Задер­
жанный). По умолчанию его значением является «false», и поэтому мы
использовали параметр Comit, чтобы запустить эту опцию. Установка
указанного параметра в значение «true» позволяет не вызывать оператор
Comit. Необходимо всегда проверять, что ваше освещение установлено и
включено, это позволит предвидеть результаты при выполнении прило­

жения.

Если вы запустите ваше приложение еще раз, то обратите внимание,
что даже после определения и установки освещения треугольник все еще
остается черным. Причина этого кроется в том, что приложение Direct3D
не может освещать объект, не имея нормали к каждой его поверхности.
Нормаль представляет собой вектор, перпендикулярный передней сто­
роне объекта, рис. 1.5.

Глава 1. Введение в Direct3D
43

Вершина 2-\

\
Вектор нормали

Вершина 1 -Передняя сторона объекта
Рис. 1.5. Нормаль к плоскости вершин
Зная это, добавим нормаль к нашему треугольнику. Замените код со­
здания треугольника на следующий:

CustomVertex.PositionNormalColored[] verts=new
CustomVertex.PositionNormalColored[3];
verts[0].SetPosition(new Vector3(0.0f, l.Of, l.Of));
verts[0].SetNormal(new Vector3(O.Of, O.Of, -l.Of));
verts[0].Color = System.Drawing.Color.White.ToArgbf);
verts [l].SetPosition(new Vector3(-1.0f, -l.Of, l.Of));
verts [1]. Set-Normal (new Vector3(0.0f, O.Of, -l.Of));
verts[1].Color = System.Drawing.Color. White.ToArgb();
verts[2].SetPosition(new Vector3(1.0f, -l.Of, l.Of));
verts[2].SetNormal(new Vector3(0.0f, O.Of, -l.Of));
verts[2] .Color = System.Drawing.Color. White.ToArgb();

Кроме того, нам также следует изменить сам формат вершин, чтобы
согласовать наши новые данные:

device.VertexFormat = CustomVertex.PositionNormalColored.Format;

Единственным значительным изменением между этим набором дан­
ных и предыдущим является добавление нормали и того факта, что цвет
каждой вершины определяется как белый. Итак, мы определили вектор
нормали для каждой вершины, который направлен перпендикулярно пе­
редней поверхности. Поскольку положение наших вершин относитель­
но оси Z не изменилось (l.Of), при изменении координат в плоскости X и
Y, перпендикулярный вектор попал бы в область отрицательных значе­
ний оси Z. Запуская теперь наше приложение, можно увидеть, что треу-

Вершина 1 •
'•Передняя сторона объек

44 Часть I. Введение в компьютерную графику
гольник перевернут и освещен. Попробуйте изменить цвет диффузного
компонента, чтобы увидеть, как освещение воздействует на сцену. Обра­
тите внимание на то, что, если вы устанавливаете красный цвет диффуз­
ного компонента, треугольник окажется освещенным красным светом.
Поэксперементируйте со значением этого компонента, чтобы получить
различные цветовые варианты.
Следует помнить одну вещь: свет рассчитывается по отношению к
вершине, поэтому при использовании полигонов с малым количеством
вершин (например, отдельного треугольника), освещение будет менее
реалистичным. В последующих главах мы обсудим более совершенные
методы освещения, такие как освещение пиксела. Такое освещение ото-,
сражает гораздо более реалистичную картину.

Состояния устройства и преобразования

Два элемента, которые мы использовали в нашем коде, до сих пор не
были применены к нашему устройству для выполнения каких-либо пре­
образований. Имеются три различных варианта состояния устройства:
состояние отображения (оно же состояние рендера), состояние сэмплера
и состояние текстуры. Последние два состояния, использующиеся для
текстурирования, мы рассмотрим достаточно скоро. Класс состояния рен­
дера может изменяться в течение того времени, пока Direct3D произво­
дит растеризацию сцены. Существует много различных изменяемых па­
раметров и методов этого класса, включая освещение и устранение неви­
димых поверхностей, которые мы уже использовали в нашем приложе­
нии. Другими опциями, которые вы можете устанавливать в пределах
состояния рендера, являются fill mode (покадровый режим с сеткой) и
различные параметры режима тумана или дымки. Мы обсудим большин­
ство этих опций и процедур в последующих главах.
Как уже упоминалось раньше, существует матрица преобразования
одной системы координат в другую. В устройстве используются три глав­
ных преобразования: общее (мировая матрица), преобразование вида и
преобразование проекции. Однако, есть и другой тип преобразования,
который можно дополнительно использовать для изменения состояния
текстур, поддерживающий до 255 мировых матриц.

Свопинг-связки и рендеры

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

Глава 1. Введение в Direct3D
45

Свопинг-связка представляет собой ряд буферов, управляющих рен­
дерингом. Есть вторичный буфер, определяющий, где выполнить рисо­
вание в пределах этой последовательности. Когда свопинг-связка, создан­
ная с помощью метода SwapEffect.Flip готова, данные вторичных буфе­
ров передаются на первичный буфер, с которого будет считывать данные
ваша графическая плата. В то же самое время третичный буфер стано­
вится новым вторичным буфером, а предыдущий первичный буфер «пе­
ремещается» в неиспользованный третичный буфер, рис.1.6.
Операция перемещения flip изменяет местоположение данных, счи­
тываемых видеокартой, и перекачивает старые данные назад в текущее
положение вторичного буфера. Для DirectX 9 этот термин используется в
общем смысле для сообщения, что вторичный буфер модифицируется
как дисплей. В оконном режиме операции перемещения представляют
собой копирование данных, подразумевая, что наше устройство не уп­
равляет всем дисплеем, а только его частью. В конечном счете, результат
остается тем же самым. В полноэкранном режиме, используя Swap­
Effect.Flip осуществляется фактическое перемещение. Некоторые драй­
веры также осуществляют операции SwapEffect.Discard или Swap-
Effect.Copy перемещения в полноэкранном режиме.
первичный вторичный буфер буфер

до перемещения

третичный
буфер

С

Рис. 1.6. Связи вторичных буферов во время операций перемещения
Если вы создали свопинг-связку, используя SwapEffect.Copy или
SwapEffect.Flip, это гарантирует, что любое существующее обращение
не будет воздействовать на вторичный буфер свопинг-связки. Приложе­
ние runtime воспримет это, создавая при необходимости дополнитель­
ные скрытые буферы. Чтобы избежать этого, рекомендуется использо­
вать операцию SwapEffect.Discard. Этот режим позволяет драйверу оп­
ределять наиболее эффективный способ представления вторичного бу-

46 Часть I. Введение в компьютерную графику
фера. Стоит отметить, что при использовании SwapEffectDiscard необ­
ходимо убедиться в полной очистке вторичного буфера перед запуском
новых операций рисования. Во время отладки приложение runtime за­
полнит вторичный буфер случайными данными, если предварительно не
будет вызвана функция очистки.

ИСПОЛЬЗОВАНИЕ МУЛЬТИВЫБОРОК (МУЛЬТИ-СЭМПЛИНГА)

В ВАШЕМ УСТРОЙСТВЕ

Если вы планируете использовать при рисовании сглаживание по-,

верхностей (или мульти-сэмплинг), вам необходимо использовать

операцию SwapEffect.Discard. Попытка использовать любую другую

операцию будет неудачной.

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

это в следующих главах.

Краткие выводы

Нарисовав треугольник в нашей сцене, а затем вызвав соответствую­
щую процедуру, мы определили и задали вращение треугольнику. При
этом, мы выполнили следующие действия.
Создали Direct3D устройство, прикрепленное к нашей винформе.
• Нарисовали отдельный цветной треугольник в нашем окне.
Задали вращение треугольнику.
Осуществили простое освещение нашей сцены.
Результат выполнения описанных процедур представлен на рис.1.7.

Глава 1. Введение в Direct3D
47

Рис. 1.7. Вращающийся трехмерный треугольник

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

48 Часть I. Введение в компьютерную графику

Глава 2. Выбор подходящего устройства

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

ства.

Возможности и свойства рассматриваемых устройств.

Адаптеры системы

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

ческой и видео информации. Самые последние платы ATI, nVidia, и Matrox

имеют сдвоенные выходы, эти карты позволяют поддерживать работу
нескольких мониторов.
Устройства, созданные в приложении Direct3D, завязаны на исполь­
зуемый адаптер. В данном случае мы можем подразумевать адаптер как
отдельное аппаратное устройство компьютерной графики, соединяемое
с монитором. Современная карта ATI Radeon 9700 является отдельным
физическим адаптером, имеет два выхода для монитора (DVI и VGA), и
таким образом, распознается приложением в Direct3D как два адаптера.
Иногда при работе с приложениями необходимо узнать, сколько уст­
ройств и какие из них находятся на данный момент в системе и принима­
ют участие в выполнении игры.
В сборках Direct3D существует статический класс, именуемый класс
«Manager», который можно использовать для идентификации адаптеров
и имеющихся в системе устройств. Самая первая характеристика в клас­
се Manager — список адаптеров в системе. Этот параметр может рабо­
тать по-разному. Например, он сохраняет значение счетчика «count», со­
общающего о количестве адаптеров в системе. Каждый адаптер может

быть индексирован непосредственно (например, Manager.Adapters[0]), или

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

Глава 2. Выбор подходящего устройства 49
ими режимов отображения. Загрузите Visual Studio, и выполните следу­

ющее:

1. Создайте новый проект Windows Form Project для С#, назвав его
как угодно, например, для типового кода — «Enumeration» — «Перечис­

ление».

2. Добавьте ссылку на сборки Microsoft.DirectX.Direct3D и Micro­
soft.DirectX, а также директивы «using» для этих сборок.
3. В представлении проекта для созданной формы windows, добавьте
к вашему приложению управление TreeView, находящееся в панели ин­

струментов.

4. Выберите управление TreeView на вашей форме, и нажмите кла­
вишу F4 (или щелкните правой кнопкой мыши, и выберите пункт
Properties — Свойства). В свойствах TreeView установите параметр Dock
в значение «Fill». В этом случае окно будет всегда заполняться полнос­
тью, даже если оно было изменено.
Теперь необходимо добавить функцию, которая просканирует все адап­
теры в системе и выдаст некоторую информацию относительно поддер­
живаемых режимов каждого из них. Добавьте следующие строки где-
нибудь в вашем классе:

/
/ We will fill our tree view here
/

public void LoadGraphics()
foreach(Adapter-Information ai in Manager.Adapters)
TreeNode root = new TreeNode(ai.Information.Description);
TreeNode driverlnfo = new TreeNode(string.Format

("Driver information: {0} - {1}",

ai.Information.DriverName,
ai.Information.DriverVersion) );
// Add the driver information to the root node

root.Nodes.Add(driverlnfo) ;

// Get each display mode supported
TreeNode displayMode = new TreeNode(string.Format
("Current Display Mode: (0}x{i}x{2}\
ai.CurrentDisplayMode.Width,
ai.CurrentDisplayMode.Height,

ai.CurrentDispIayMode.Format));

foreach(DisplayMode dm in ai.SupportedDisplayModes)
TreeNode supportedNode = new TreeNode(string.Format
("Supported: (0} x (1 }x {2}",.
dm.Width, dm.Height, dm.Format));

50 Часть I. Введение в компьютерную графику

displayMode.Nodes.Add(supportedNode);

}
// Add the display modes

root.Nodes.Add(displayMode);

// Add the root node

treeViewl.Nodes.Add(root);

Управлять выполнением этого алгоритма довольно просто. Чтобы уз­
нать, что происходит, процедуру выполнения можно всегда прервать.
Сначала идет поиск всех адаптеров в системе. Механизм «Foreach», ис­
пользуемый в С#, делает этот программный цикл на удивление простым.
Для каждого адаптера в системе цикл выполнится один раз и заполнит
структуру Adapterlnformation для данного адаптера.
Структура Adapterlnformation имеет несколько значений:

public struct Adapterlnformation
(
int Adapter;
DisplayMode CurrentDisplayMode;
AdapterDetails Information;
AdapterDetails GetWhqllnformationO;
DisplayModeEnumerator SupportedDisplayModes;

}

Значение Adapter относится к номеру адаптеру, который вы использу­
ете при создании устройства. Порядковые номера адаптера отсчитыва-
ются от нулевого индекса с номером ordinals, равным числу адаптеров в
вашей системе. Два значения параметра AdapterDetails возвращают иден­
тичные результаты, за одним лишь исключением. В отличие от
GetWhqlrnformation, в функции Information не возвращается подробная

информация о WHQL (Лаборатории по сертификации аппаратных средств

для работы в среде Windows). Извлечение этой информации может быть
весьма долгим, поэтому целесообразно отделить данную операцию.
Структура AdapterDetails содержит более подробную информацию
непосредственно об адаптере, включая его описание и информацию о
драйвере. Приложения могут использовать эту структуру для некоторых
типов аппаратных средств, хотя это не всегда является необходимым.
Последние два члена этой структуры возвращают параметры струк­
тур DisplayMode, которые могут использоваться для определения различ­
ных режимов работы дисплея, включая ширину и высоту визуального

Глава 2. Выбор подходящего устройства 51
отображения, также как частоту обновления и используемый формат.
Значение CurrentDisplayMode возвращает информацию о режиме визу­
ального отображения в используемом адаптере, в то время как Supported-
DisplayModes возвращает список всех режимов визуального отображе­
ния, поддерживаемых данным адаптером.
Итак, мы используем описание устройства, обнаруженного системой,
для создания корневой папки в нашей разветвленной схеме. Затем мы
добавляем папку или строку, которая будет включать имя драйвера и но­
мер версии (полученные из той же системы) в качестве ответвлений или
в качестве второго уровня этой корневой папки, и добавляем второй уро­
вень схемы, включающий текущие параметры режима визуального ото­
бражения адаптера.
Затем мы добавляем в разветвленную схему дочерние узлы или до­

черние папки с данными о поддерживаемом формате и режиме этого адап­

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

using (Forml frm = new Forml())

{

frm.LoadGraphics lb-

Application.Run(frm) ;

}
При выполнении данного приложения на экране появится окно, соот­
ветствующее рис.2.1.
Как видно из рисунка, этот список содержит список режимов и фор­
матов, поддерживаемых устройством. При заполнении структуры пара­
метров форматы могут использоваться как форматы вторичного буфера.
Перечисляемые форматы описываются с помощью буквенно-цифрового
кода. Символ представляет тип данных; номер — число битов поддержи­
ваемых данных. Некоторые из символов могут быть следующие:
А — alpha, альфа
X — unused, неиспользуемый
R — red, красный
G — green, зеленый
В — blue, синий
L — luminance, яркость
Р — palette, палитра

52
Часть I. Введение в компьютерную графику

Рис. 2.1. Разветвленная схема режимов адаптера

Полная сумма всех битов в формате определяет полный размер фор­

мата. Например, формат X8R8G8B8, рис.2.1, означает 32-разрядный фор­

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

синий) и с неиспользованными 8 битами.

ФОРМАТЫ ДЛЯ ВТОРИЧНЫХ БУФЕРОВ И ДИСПЛЕЕВ
В большом списке форматов, есть несколько подходящих для ис­
пользования в качестве вторичного буфера или формата дисплея.
Некоторые из них:
A2R10G10B10 A1R5G5B5
A8R8G8B8 X1R5G5B5
X8R8G8B8 R5G6B5
Форматы дисплея могут быть теми же, что и форматы вторичных
буферов, за исключением тех, которые содержат символьный ком­
понент. Единственный формат, который может использоваться с
символьной компонентой для дисплея, —- это формат A2R10G10B10,
но только в полноэкранный режиме.
Обратите внимание, что, поскольку эти форматы поддерживаются
приложением Direct3D в качестве форматов вторичных буферов, не­
посредственно адаптер может не поддерживать их. Для нашего при­
мера, единственными поддерживаемыми форматами, которые мы
получили, были X8R8G8B8 и R5G6B5.

Глава 2. Выбор подходящего устройства
53

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

Поддержка аппаратного устройства

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

public static System.Boolean CheckDeviceType ( System.Int32 adapter ,
Microsoft.DirectX.Direct3D.DeviceType checkType ,
Microsoft.DirectX.Direct3D.Format displayFormat ,
Microsoft.DirectX.Direct3D.Format baciBufferformat ,
System.Boolean windowed , System.Int32 result )

Данная функция позволяет быстро определить, поддерживает ли ваше
устройство используемый тип формата. Первый параметр — adapter, те­
стируемый адаптер. Второй — checktype, тип проверяемого устройства
(как правило, это DeviceType.Hardware). Окончательно определяются ото­
бражаемый формат displayFormat и формат вторичного буфера Ьаск-
BufferFormat, а затем, режим работы (оконный (windowed) или полноэк­
ранный). Последний параметр — дополнительный, при использовании
он возвратит целочисленный код (HRESULT в СОМ) функции. Данный
алгоритм возвращает значение «true», если данный тип устройства под­
держивается, в противном случае возвращает значение «false».

ПРЕОБРАЗОВАНИЕ ОПРЕДЕЛЯЕМОГО ФОРМАТА

Важно обратить внимание, что в оконном режиме формат вторич­

ного буфера не должен соответствовать формату режима визуаль­

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

соответствующее цветовое преобразование. Метод CheckDevi­

ceType возвращает соответствующие результаты, независимо от

того, доступен данный формат или нет, также для определения это­

го напрямую возможно использование метода CheckDeviceFormat-

Conversion класса Manager. В оконном режиме вы можете исполь­

зовать формат Format.Unknown.

54 Часть I. Введение в компьютерную графику
Было бы весьма полезно знать заранее те типы форматов, которые вы
будете использовать. Это освобождает от необходимости перебирать все
возможные форматы и устройства.

Проверка возможностей устройства

Различные возможности аппаратных средств описываются термином
«capability» — возможность. В приложении Direct3D runtime имеется оп­
ция, которая перечисляет все реализуемые возможности используемого
устройства. Как только устройство создано, вы можете использовать оп­
цию устройства capability для определения поддерживаемых возможно­
стей. Если устройство еще не создано, вы так же можете узнать возмож­
ные поддерживаемые характеристики этого устройства с помощью оп­
ределенного метода класса Manager.
Теперь можно добавить к нашему приложению код, который выдаст
описание свойств и возможностей каждого адаптера в нашей системе.
Однако, мы не можем добавить список возможностей к имеющейся раз­
ветвленной схеме драйверов и параметров из-за их большого числа. Са­
мый простой способ показать эти данные состоит в использовании тек­
стового поля.
Теперь вернемся в процедуру view нашей формы и попробуем пере­

ключать параметры разветвленной схемы представления от позиции «Fill»

до позиции «Left». Уменьшите размер окна вполовину. Теперь добавьте
текстовое поле к окну, установите параметр Dock в положение «Fill».
Также убедитесь, что строка «Multiline» установлена в положение «true»,
и параметр прокрутки «Scrollbars» установлен в положение «Both» для
текстового поля.
Далее нам следует добавить обработчик событий к приложению так,
чтобы он создавал текстовое поле с параметрами обнаруженного адапте­
ра. Для этого необходимо привязать опцию «AfterSelect» к событию об­
наружения адаптера (предполагается, что вы уже знаете, как отслежи­
вать эти события). Используйте следующие команды:

private void treeViewl_AfterSelect(object
sender,System.Windows.Forms.TreeViewEventArgs e)
(
if (e.Node.Parent == null) // root node
(
// Get the device caps for this node

Глава 2. Выбор подходящего устройства
55

textBoxl.Text = е.Node.Text + " Capabilities: \r\n\r\n" +

Manager.GetDeviceCaps

(e.Node.Index, DeviceType.Hardware).ToString().Replace("\n", "\r\n");
Как видите, это достаточно просто. Для корневых папок, которые ото­
бражают названия адаптеров после того, как они выбраны, мы вызываем
функцию Manager.GetDeviceCaps для соответствующего номера адапте­
ра. Параметр ToString этой строки возвращает чрезвычайно большой спи­
сок всех возможностей данного устройства. Выполнение данного прило­
жения приведет к появлению на экране более подробной разветвленной
схемы, см. пример на рис.2.2.

ИСПОЛЬЗОВАНИЕ ОПЦИИ «CAPABILITY» ДЛЯ

НЕПРОГРАММИРУЕМОГО КОНВЕЙЕРА

Многие из возможностей, перечисленных в структуре «capability»

связаны непосредственно с непрограммируемым конвейером (на­

пример, значение MaxActiveLights). Если вы используете програм­

мируемый конвейер, многие из возможностей не будут использо­

ваны в вашей сцене. Позднее мы обсудим различия между не­

программируемым и программируемым конвейерами.

Итак, теперь у нас имеется полный список возможностей, которые
могут поддерживаться устройством. Например, мы можем найти инфор­
мацию, поддерживает ли ваше устройство режим вуализации (fogging),
или узнать максимальное число одновременно выполняемых рендеров.
Структура «Capability» разбита главным образом на две группы. Первая
группа — логические значения, которые определяют, поддерживается ли
данная аппаратная возможность или нет. Например, SupportsAlphaCom-
раге принимает значение «true», если устройство поддерживает тексто­
вые символы. Другая группа класса «Capability» возвращает «фактичес-
ские значения, например значение MaxActiveLights, которое определяет
максимальное число активных подсветок, реализуемых в сцене. Далее
во мере необходимости мы рассмотрим и опишем отдельные возможно­
сти устройства.

56 Часть I. Введение в компьютерную графику

РИС. 2.2. Возможности и режимы обнаруженных устройств

Краткие выводы

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

Глава 3. Введение в технологию рендеринга 57

Глава 3. Введение в технологию

рендеринга

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

Использование вершинных буферов

Приложение Direct3D имеет необходимый для этого механизм — вер­
шинные буферы. Такой буфер, как следует из его названия, является па­
мятью для хранения данных о вершинах. Гибкость вершинных буферов
делает их идеальными в плане геометрических преобразований в исполь­
зуемой сцене. Попробуем усовершенствовать наш треугольник, описан­
ный в первой главе, применяя вершинные буферы.
Создание вершинного буфера достаточно несложно. Существует три
конструктора, которые можно использовать для этого. Рассмотрим по
отдельности каждый из них.

public VertexBuffer ( Microsoft.DirectX.Direct3D.Device device ,

System.Int32

sizeOfBufferInByt.es , Microsoft.DirectX.Direct3D.Usage usage ,
Microsoft.DirectX.Direct3D.VertexFormats vertexFormat ,

Microsoft.DirectX.Direct3D.Pool pool )

public VertexBuffer ( System.Type typeVertexType , System.Int32 numVerts ,
Microsoft.DirectX.Direct3D.Device device ,
Microsoft.DirectX.Direct3D.Usage usage ,
Microsoft.DirectX.Direct3D.VertexFormats vertexFormat ,

Microsoft.DirectX.Direct3D.Pool pool )

Опишем каждый параметр.
• Device — устройство, которое используется в Direct3D для созда­
ния вершинного буфера. Данный буфер будет поддерживаться
только этим устройством.
• SizeOfBufferlnBytes — задаваемый размер вершинного буфера в
байтах. Если вы используете в конструкторе этот параметр, буфер
способен поддерживать любой тип вершин.

58 Часть I. Введение в компьютерную графику
TypeVertexType — задается, если вы хотите, чтобы буфер включал
только один тип вершин. Либо это может быть тип одной из встро­
енных структур вершин в классе CustomVertex, либо тип вершин,
определяемый пользователем. Данное значение не может быть пу­

стым.

NumVerts — максимальное количество вершин, которые вы хоти­
те сохранить в буфере. Это значение должно быть положитель­
ным и ненулевым.
• Usage — определяет, как этот вершинный буфер может использо­
ваться. При создании буфера могут использоваться все значения
данного параметра, за исключением следующих.
DoNotClip — используется для того, чтобы исключить режим
clipping (отсечения) для этого буфера. Используя этот флажок,
необходимо при использовании рендеринга из вершинного
буфера установить параметр clipping состояния рендера в зна­

чение «false».

Dynamic — используется для сообщения приложению, что
вершинный буфер требует использования динамической па­
мяти. Если этот флажок не определен, вершинный буфер яв­
ляется статическим. Статические вершинные буферы обычно
хранятся в видеопамяти, в то время как динамические буфе­
ры хранятся в памяти AGP. Выбор данной опции необходим
для драйверов, чтобы определить, где сохранить данные. Бо­
лее подробно с режимом Dynamic можно ознакомиться в до­
кументации на DirectX SDK.
• Npatches — сообщает, что данный буфер используется для ри­
сования патчей N-Patches.
Points — сообщает, что данный буфер используется для рисо­
вания точек.
RTPatches — сообщает, что данный буфер используется для
рисования примитивов более высокого порядка.
SoftwareProcessing — сообщает, что обработка вершин долж­

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

чае обработка ведется аппаратными средствами.
• WriteOnly — сообщает, что вершинный буфер не будет счи-
тываться в случае, когда нет необходимости считывать дан­
ные вершинного буфера. Данная опция позволяет разгрузить

видеопамять.

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

Глава 3. Введение в технологию рендеринга 59

• Default — вершинный буфер размещен в памяти, объединяет
большинство размещенных в ней данных. Данные располага­
ются либо в видеопамяти, либо в памяти AGP, в зависимости
от параметра использования. Вершинные буферы, созданные
в этом пуле памяти, переопределяются автоматически перед
сбросом устройства.
• SystemMemory — данные вершинного буфера помещаются в
системную память, где являются недоступными для устрой­

ства.

• Scratch — системный пул памяти, не связанный с устройством
и не используемый устройством. Удобен при управлении дан­
ными, при этом не привязан к специфическому формату уст­

ройства.

СОЗДАНИЕ ВЕРШИННЫХ БУФЕРОВ С ПОМОЩЬЮ
НЕУПРАВЛЯЕМЫХ СОМ УКАЗАТЕЛЕЙ
Как и в самом устройстве, в приложении имеется перегрузка для
вершинного буфера, которая принимает указатель IntPtr. Это зна­
чение используется для передачи указателя интерфейса СОМ в не­
управляемый интерфейс IDirect3DvertexBuffer9. Это удобно, когда
вы хотите использовать вершинный буфер, созданный с помощью
внешнего (неуправляемого) источника. Любое другое управляемое
приложение никогда не будет использовать данный конструктор, и
это значение не может быть пустым или нулевым.

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

private Device device = null;
private VertexBuffer vb = null;

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

// Create our device
device = new Device(0, DeviceType.Hardware, this,
CreateFlags.SoftwareVertexProcessing
, presentParams);

60 Часть I. Введение в компьютерную графику
CustomVertex.PositionColored[] verts = new CustomVertex.PositionColored[3];
verts[0].SetPosition(new Vector3(0.Of, I.Of, l.Of));
verts [0] .Color = System.Drawing.Color.Aqua.ToArgb();
verts[l].SetPosition(new Vector3(-1.0f, -l.Of, l.Of));
verts [1] .Color = System.Drawing.Color.Black.ToArgb()
verts[2].SetPosition(new Vector3(l.Of, -l.Of, l.Of));
verts [2] .Color - System.Drawing.Color.Purple.ToArgbO ;
vb = new VertexBuffer(typeof(CustomVertex.PositionCoiored), 3, device,
Usage.Dynamic :
Usage.WriteOnly, CustomVertex.PositionCoiored.Format, Pool.Default);
vb.SetData(verts, 0, LockFlags.None);

Единственные изменения, появившиеся здесь, — две новых строки
после кода создания треугольника. Мы сначала создаем вершинный бу­
фер для записи трех значений вершинной структуры, которые мы уже
объявили. Мы хотим, чтобы буфер был настроен только на запись, был
динамическим и сохранялся только в заданном по умолчанию пуле памя­
ти для увеличения скорости выполнения. Далее необходимо поместить
наш список вершин треугольника в вершинный буфер, используя метод
SetData. Этот метод принимает любой общий объект (подобно методу
DrawUserPrimitives) в качестве первого значения «verts». Второе значе­
ние «offset» — величина смещения размещаемых данных. Поскольку мы
хотим записать все данные, принимаем здесь смещение, равное нулю.
Последний параметр LockFlags.None определяет то, как мы хотим бло­
кировать буфер на то время, пока данные записываются. Различные ме­
ханизмы блокировки мы опишем несколько позже.
При компилировании данного приложения система выдаст сообще­
ние об ошибке компиляции, поскольку функция DrawUserPrimitives при
обращении к OnPaint затребует переменную «verts». Необходимо сооб­
щить Direct3D, что мы хотим рисовать объект именно из нашего вершин­
ного буфера, а не из массива, который мы объявили прежде.
Естественно, такой метод существует. Мы можем вызывать метод
SetStreamSource из устройства, чтобы дать возможность Direct3D считы­
вать наш вершинный буфер при рисовании примитивов. Прототипы для
двух перегрузок этой функции имеют вид:

public void SetStreamSource ( System.Int32 streamNumber ,
Microsoft.DirectX.Direct3D.VertexBuffer streamData ,
System.Int32 offsetlnBytes , System.Int32 stride )
public void SetStreamSource ( System.Int32 streamNumber ,
Microsoft.DirectX.Direct3D.VertexBuffer streamData ,
System.Int32 offsetlnBytes )

Глава 3. Введение в технологию рендеринга 61
Единственным различием между этими двумя перегрузками является
то, что каждая содержит дополнительное значение для размера шага по­
тока. Первый параметр streamNumber — номер потока, который мы бу­
дем использовать для этих данных. В основном мы будем использовать
нулевое значение, однако, позже мы обсудим и множественные потоки.
Второй параметр — вершинный буфер, который содержит данные наше­
го источника. Третий параметр offsetlnBytes — смещение (в байтах) в
вершинном буфере, определяет место в буфере, с которого Direct3D бу­
дет рисовать объект. Параметр размера stride (для одной перегрузки) оп­
ределяет размер каждой вершины в буфере. Если вы создали вершинный
буфер с использованием типа, нет необходимости применять перегрузку
с этим параметром.
Замените обращение к методу рисования drawing следующими стро­

ками:

device.SetStreamSource(0, vb, 0);
device.DrawPrimitives(PrimitiveType.TriangleList, 0, 1);

Как уже отмечалось, мы записываем нулевое значение номера потока
данных вершинного буфера, и поскольку хотим использовать все дан­
ные, выбираем нулевое значение смещения. Обратите внимание, что мы
также изменили фактический вызов создания рисунка. Поскольку мы
имеем все наши данные в вершинном буфере, нет необходимости вызы­
вать метод DrawUserPrimitives (данная функция предназначена для рисо­
вания объектов, данные о которых непосредственно определяются пользо­
вателем). Более универсальная функция DrawPrimitives рисует примити­
вы из нашего потокового источника. Метод DrawPrimitives имеет три
параметра, первый — тип примитива, который мы уже обсудили. Второй
параметр — начальная вершина в потоке. Последний параметр — число
примитивов, которые мы будем рисовать.
Даже эта простая демонстрация отображения треугольника с исполь­
зованием вершинного буфера показывает увеличение быстродействия
приблизительно на 10%, в основном за счет скорости передачи кадров.
Однако, существует определенная проблема, связанная с этим приложе­
нием, появляющаяся при попытке изменить размеры окна. В этом случае
треугольник просто исчезает.
Есть несколько причин, вызывающих такое поведение, о двух из них
уже кратко упоминалось. В предыдущей главе было сказано, что при из­
менении размеров окна устройство автоматически сбрасывалось. Это
означает, что когда после сброса в пуле памяти (например, вершинном
буфере) создается ресурс, этот пул устанавливается автоматически при
сбрасывании устройства. Таким образом, во время изменения окна уст-

62 Часть I. Введение в компьютерную графику
ройство сбрасывается, и устанавливается вершинный буфер. Одной из
изящных особенностей Управляемого DirectX является то, что он авто­
матически воссоздает вершинный буфер после того, как устройство сбра­
сывается, при этом в буфере не будет никаких данных, и, следовательно,
ничего не отобразится на экране.
Вершинный буфер имеет обработчик события «created», который от­
слеживает момент создания буфера и готовности его к заполнению. Для
использования этого обработчика событий необходимо переписать наше
приложение, добавив следующий код:

private void OnVertexBufferCreate(object sender, EventArgs e)
(
VertexBuffer buffer = (VertexBuffer)sender;
CustomVertex.PositionColored[] verts = new
CustomVertex.PositionColored[3];
verts[0].SetPosition(new Vector3(O.Of, l.Of, l.Of ));
verts[0].Color = System.Drawing.Color.Aqua.ToArgb();
verts[l].SetPosition(new Vector3(-1.0f, -l.Of, l.Of));
verts[1].Color = System. Drawing.Color.Black.ToArgb();
verts[2].SetPosition(new Vector3(1.0f, -l.Of, l.Of));
verts[2].Color = System.Drawing.Color.Purple.ToArgb();
buffer.SetData(verts, 0, LockFlags.None);
1

Эта функция имеет стандартное описание обработчика событий, вклю­

чая регистрацию события и список параметров. В нашем случае список
параметров не используется, так что это значение можно проигнориро­
вать. Таким образом, вначале создается вершинный буфер, затем отсле­
живается данное событие, и значение сендера передается назад в вер­
шинный буфер. Далее мы следуем тем же путем, что и в последний раз,
когда создавали наши данные и вызывали метод SetData. Мы должны
переписать код создания треугольника в методе инициализации
InitializeGraphics, используя вместо него следующий две строки:

vb.Created += new EventHandler(this.OnVertexBufferCreate);

OnVertexBufferCreate(vb, null);

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

Глава 3. Введение в технологию рендеринга 63

ВРЕМЯ РАБОТЫ РЕСУРСА

Все графические ресурсы будут размещаться автоматически, если

в течение сброса устройства они сохранены в видеопамяти; одна­

ко, после сброса заново пересоздаются только вершинный и ин­

дексные буферы. Также важно отметить, что все ресурсы размеща­

ются только тогда, когда опознано само устройство.

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

куба. Давайте изменим наш алгоритм создания геометрии, см. листинг 3.1:

Листинг 3.1. Создание куба или параллелепипеда.
CustomVertex.PositionColored[] verts = new

CustomVertex.PositionColored[36];

// Front face
verts[0] = new CustomVertex.PositionColored(-1.0f, l.Of, l.Of,
Color.Red.ToArgb()) ;

verts[l] = new CustomVertex.PositionColored(-1.0f, -l.Of, l.Of,

Color.Red.ToArgb());

verts[2] = new CustomVertex.PositionColored(1.0f, l.Of, l.Of,

Color.Red.ToArgb());

verts[3] = new CustomVertex.PositionColored(-1.0f, -l.Of, l.Of,

Color.Red.ToArgb());

verts[4] = new CustomVertex.PositionColored(1.0f, -l.Of, l.Of,

Color.Red.ToArgb());

verts[5] = new CustomVertex.PositionColored(l.Of, l.Of, l.Of,

Color.Red.ToArgb());

// Back face (remember this is facing *away* from the camera, so vertices
should be
clockwise order)
verts[6] = new CustomVertex.PositionColored(-1.0f, l.Of, -l.Of,

Color. Blue.ToArgb());

verts[7] = new CustomVertex.PositionColored(l.Of, l.Of, -l.Of,

Color.Blue.ToArgb());

64 Часть I. Введение в компьютерную графику

verts[8] = new CustomVertex.PositionColored(-1.0f, -l.Of, -l.Of,

Color.Blue.ToArgb());

verts[9J = new CustomVertex.PositionCoiored(-1.0f, -l.Of, -l.Of,

Color. Blue. ToArgb());

verts[lO] = new CustomVertex.PositionCoiored(1.0f, l.Of, -l.Of,

Color.Blue.ToArgb(l);

verts[ll] = new CustomVertex.PositionColored(1,Of, -l.Of, -l.Of,

Color. Blue. ToArgb());

// Top face
verts[12] = new CustomVertex.PositionColored(-1.0f, l.Of, l.Of,

Color.Yellow.ToArgb());

verts[13] = new CustomVertex.PositionColored(1.0f, l.Of, -l.Of,

Color.Yellow.ToArgb()) ;

verts[14! = new CustomVertex.PositionColored(-1.0f, l.Of, -l.Of,

Color.Yellow.ToArgb());

verts[15J = new CustomVertex.PositionColored(-1.0f, l.Of, l.Of,

Color.Yellow.ToArgb());

verts[16] = new CustomVertex.PositionColored(1.0f, l.Of, l.Of,

Color.Yellow.ToArgb());

verts[17] = new CustomVertex.PositionCoiored(1.0f, l.Of, -l.Of,

Color. Yellow. ToArgb());

// Bottom face (remember this is facing *away* from the camera, so vertices
should be
clockwise order)
verts[18] = new CustomVertex.PositionColored(-1.0f, -l.Of, l.Of,

Color.Black.ToArgb());

verts[19] = new CustomVertex.PositionColored(-1.0f, -l.Of, -l.Of,

Color.Black.ToArgb());

verts[20] = new CustomVertex.PositionColored(l.Of, -l.Of, -l.Of,

Color.Black.ToArgb());

verts[21j = new CustomVertex.PositionColored(-1.0f, -l.Of, l.Of,

Color.Black.ToArgb());

verts[22] = new CustomVertex.PositionColored(1.0f, -l.Of, -l.Of,

Color. Black.ToArgb());

verts[23] = new CustomVertex.PositionCoiored(1.0f, -l.Of, l.Of,

Color.Black.ToArgb());

// Left face
verts[24] = new CustomVertex.PositionColored(-1.0f, l.Of, l.Of,

Color.Gray.ToArgb());

verts[25] = new CustomVertex.PositionColored(-1.0f, -l.Of, -l.Of,

Color.Gray.ToArgb());

verts[26] = new CustomVertex.PositionColored(-1.0f, -l.Of, l.Of,

Color. Gray. ToArgb());

verts[27] = new CustomVertex.PositionColored(-1.0f, l.Of, -l.Of,

Color.Gray.ToArgb());

verts[28] = new CustomVertex.PositionColored(-1.0f, -l.Of, -l.Of,

Color.Gray.ToArgb());

Глава 3. Введение в технологию рендеринга 65

verts[29] = new CustomVertex.PositionColored(-1.0f, l.Of, 1.Of,

Color.Gray.ToArgbO);

// Right face (remember this is facing *away* from the camera, so vertices
should be

clockwise order)
verts[30] - new CustomVertex.PositionColored(1.0f, l.Of, l.Of,

Color.Green.ToArgbO ) ;

verts[31] = new CustomVertex.PositionCoiored(1.0f, -l.Of, l.Of,

Color.Green.ToArgbO );

verts[32] = new CustomVertex.PositionColored(1.0f, -l.Of, -l.Of,

Color.Green.ToArgbO);

verts[33] = new CustomVertex.PositionColored(1.0f, l.Of, -l.Of,

Color.Green.ToArgbf)) ;

verts[34] = new CustomVertex.PositionColoredfl.Of, l.Of, l.Of,

Color.Green.ToArgbO ) ;

verts[35] = new CustomVertex.PositionColored(1.0f, -l.Of, -l.Of,

Color.Green.ToArgbO ) ;

buffer.SetData(verts, 0, LockFlags.None);

В данном методе мы формируем необходимое количество вершин для
создания нашего объекта, в данном случае 36 вершин. При этом вы мо­
жете использовать исходник программы, имеющейся на CD диске. Как
уже упоминалось, кубический объект будет создан из 12 треугольников,
каждый треугольник имеет 3 вершины. Выполнение данного кода анало­
гично процедуре обращения к функции SetData.
Следует отметить, что мы никогда не изменяли первоначальный раз­
мер нашего вершинного буфера. Таким образом, перед выполнением про­
цедуры необходимо внести пару изменений. Перепишите строки следу­
ющим образом:

vb = new VertexBuffer(typeof(CustomVertex.PositionColored), 36, device,
Usage.Dynamic
! Osage.WriteOnly, CustomVertex.PositionColored.Format, Pool.Default);
device.Transform.World = Matrix.RotationYawPitchRoll(angle /
(float)Math.PI, angle /
(float)Math.PI * 2.Of, angle / (float)Math.PI);
device.DrawPrimitives(PrimitiveType.TriangleList, 0, 12);

Главное, что мы здесь делаем, — это изменение размера вершинного
буфера, который мы создали для отображения всех необходимых для рен­
деринга данных. Мы также пытаемся изменить и характер вращения,
чтобы получить более эффектную картинку. Наконец, мы пытаемся ото­
бразить 12 примитивов более эффективно, чем мы отображали наш один
единственный треугольник. Действительно, поскольку наш новый куби­
ческий объект сформирован полностью как ЗD-объект и является полно­
стью заполненным и описанным, у нас больше нет необходимости моде-
З.!к 604

66 Часть I. Введение в компьютерную графику
пировать и отображать обратные невидимые стороны треугольников. Мы
можем использовать заданный по умолчанию в Direct3D режим отбора
(против часовой стрелки). Поэтому необходимо убрать строку, описыва­
ющую режим отбора «cullig», из нашего источника. Затем попробуем по­
вторно выполнить приложение.
Мы получили на экране красочный вращающийся куб с разноцветны­
ми гранями. При этом мы видим каждую грань без пропаданий.
Теперь, если бы вы хотели отобразить более чем один трехмерный
объект в данной сцене, было бы неэффективно создавать несколько вер­
шинных буферов (один буфер для каждого объекта). Существует намно­
го более простой способ делать это.
Будем рисовать фигуру из трех кубических объектов, некоторые гра­
ни которых соприкасаются. Поскольку наши текущие параметры каме­
ры настроены на наш первый куб, для охвата всей сцены мы переместим
камеру немного назад. Измените параметр Look в функции следующим

образом:

device.Transform.View = Matrix.LookAtLH(new Vector3(0,0, 18.Of), new

Vector3(),

new Vector3(0,1,0));

Теперь, переместив назад нашу камеру, мы можем видеть практичес­
ки всю сцену. Отображаемый объект в нашей сцене будет казаться мень­
ше по размеру, так как камера расположена от него дальше. Чтобы нари­
совать еще два кубических объекта, соприкасающихся с первым, мы мо­
жем многократно использовать наш имеющийся вершинный буфер, да­
вая команду приложению Direct3D рисовать ту же самую вершину снова.
Добавьте следующие строки программы после обращения к Draw-
Primitives:

device.Transform.World = Matrix.RotationYawPitchRoll(angle /
(float)Math.PI, angle /
(float)Math.PI / 2.Of, angle / (float)Math.PI * 4.Of) *

Matrix.Translation(5.Of, O.Of, O.Of);

device.DrawPrimitives(PrimitiveType.TriangleList, 0, 12);
device.Transform.World = Matrix.RotationYawPitchRoll(angle /
(float)Math.PI, angle /
(float)Math.PI * 4.Of, angle / (float)Math.PI / 2.Of) *

Matrix.Translation(-5.Of, O.Of, O.Of);

device.DrawPrimitives(PrimitiveType.TriangleList, 0, 12);

Приложение Direct3D уже «знает», какой тип вершин мы планируем
рисовать, поскольку с помощью параметра VertexFormat мы определили

для рисования наш первый куб. Благодаря функции SetStreamSource (пока

только для первого куба) приложению Direct3D также «известно», из ка-

Глава 3. Введение в технологию рендеринга 67
изго вершинного буфера извлекаются данные. Что же необходимо знать
приложению Direct3D, чтобы начать рисовать второй и третий куб? Един­
ственная информация, которая необходима, это — где и что рисовать.
Для этого будем преобразовывать координаты первого куба в про­
странстве мировых координат, другими словами, применим матрицу пре­
образования. Вначале используем вращение, подобно тому, что мы де­
лали, используя функцию SetupCamera (хотя наша функция несколько
отличается, поскольку наши кубические объекты вращаются под раз­
личными углами). Затем преобразуем мировые координаты, это доста­
точно новая операция для нас. Мы умножаем матрицу перемещения
(Matrix.Translation) на нашу существующую матрицу вращения. Мат­
рица перемещения изменяет координаты вершин объекта от одной точ­
ки к другой в мировом пространстве. В итоге, мы хотим переместить
второй кубический объект на пять единиц вправо, а третий объект пе­
реместить на пять единиц влево от нашего первого куба.
Итак, преобразования координат будут выполняться в следующем
порядке: вершина объекта будет сначала вращаться, затем переместится.
При другой последовательности действий результат был бы другим (до­
статочно вспомнить, что умножение матриц слева направо и справа на-
JCBO
дает
различные результаты), поэтому важно помнить порядок опе­
раций при преобразовании координат вершин.
В составе CD-диска включен исходник программы, которая позволяет
рисовать девять кубических объектов быстрее, чем три, которые описа­
ны здесь, рис.3.1.

Рис. 3.1. Раскрашенные кубы

68 Часть I. Введение в компьютерную графику

Текстурирование объектов

Несмотря на использование рендеринга с цветами и подсветкой, объек­

ты все равно выглядят не так реалистично, как хотелось бы. Термин «тек­
стурирование» («texture») при описании нетрехмерных приложений обыч­
но описывает шероховатость или неровность рисуемого объекта. Тексту­
ры в трехмерной сцене — это, по существу, плоские двухмерные bitmap-
рисунки, которые могут использоваться для моделирования текстуры на
примитиве. Например, вы могли бы взять точечный рисунок травы, что­
бы отобразить реалистичный холм, или, возможно, облака, чтобы ото­
бразить небо. Приложение Direct3D может отображать до восьми тек­
стур одновременно для каждого примитива, но пока давайте разберем
одну текстуру на одном примитиве.

Рис. 3.2. Визуализация текстурных координат

В то время как Direct3D использует структуру bitmap в качестве фор­
мата текстуры, любой точечный рисунок, который вы загружаете, может
быть использован для текстурирования объекта. Каким же образом мож­
но преобразовать плоский 2D точечный рисунок в нечто такое, что мо­
жет нарисовать трехмерный объект? Каждый объект, представляемый в
сцене, запрашивает координаты текстуры, которые используются для ото­
бражения каждого тексела (элемента текстуры) в соответствующем пик­
селе на экране в течение процедуры растеризации. Тексел, от английско­
го слова texel, — сокращенное название элемента текстуры, или соответ­
ствующее значение цвета для каждого адреса в текстуре. Под адресом

Глава 3. Введение в технологию рендеринга
69
можно подразумевать номер строки и столбца, называемые «U» и «V»,
соответственно. Обычно это скалярные значения, диапазон которых со­
ставляет от 0,0 до 1,0. Значение 0,0 соответствует верхнему левому углу
расположения текстуры, тогда как 1,1 соответствует правому нижнему
углу расположения текстуры. Центр текстуры соответствует значению

0,5, 0,5, рис.3.2.

Для того чтобы отобразить наши кубические объекты с использова­
нием текстурирования, мы должны изменить вершинный формат нашего
объекта ровно также, как и данные, пересылаемые в графическую карту.
Мы заменим компонент «color» (цвет) данных наших вершин данными
координат текстуры. Для того чтобы иметь наш объект и цветным, и тек­
стурным, мы просто будем использовать текстуру для определения цвета
каждого примитива. Перепишите код создания вершины, как показано в
листинге 3.2:
Листинг 3.2. Данные текстур куба.
CustomV'ertex.PositionTextured[] verts = new
CustomV'ertex.PositionTextured [36];
// Front face
verts[0] = new CustomVertex.PositionTextured(-1.0f, l.Of, l.Of, O.Of,
O.Of);

verts[1] = new CustomVertex.PositionTextured(-1.0f, -l.Of, l.Of, O.Of,

l.Of);

verts[2] = new CustomVertex.PositionTextured(1.0f, l.Of, l.Of, l.Of, O.Of);
verts[3] = new CustomVertex.PositionTextured(-l.Of, -l.Of, l.Of, O.Of,

l.Of);

verts[4] = new CustomVertex.PositionTextured(1.0f, -l.Of, l.Of, l.Of,

l.Of);

verts[5] = new CustomVertex.PositionTextured(1.0f, l.Of, l.Of, l.Of, O.Of);
// Back face (remember this is facing *away* from the camera, so vertices
should be
clockwise order)
verts[6] = new CastomVertex.PositionTextured(-1.0f, l.Of, -l.Of, O.Of,

O.Of);

verts[7] = new CustomVertex.PositionTextured(i.Of, l.Of, -l.Of, l.Of,

O.Of);

verts[8] = new CustomVertex.PositionTextured(-1.0f, -l.Of, -l.Of, O.Of,

l.Of);

verts[9j - new CustomVertex.PositionTextured(-1.0f, -l.Of, -l.Of, O.Of,

l.Of);

verts[10] = new CustomVertex.PositionTextured(l.Of, l.Of, -l.Of, l.Of,

O.Of);

verts[11] = new CustomVertex.PositionTextured(l.Of, -l.Of, -l.Of, l.Of,

l.Of);

70 Часть I. Введение в компьютерную графику

// Top face
verts[12] = new CustomVertex.PositionTextured(-1.0f, l.Of, l.Of, O.Of,

O.Of);

verts[13] = new CustomVertex.PositionTextured(l.Of, l.Of, -l.Of, l.Of,

l.Of);

verts[14] = new CustomVertex.PositionTextured(-1.0f, l.Of, -l.Of, O.Of,

l.Of);

verts[15] = new CustomVertex.PositionTextured(-1.0f, l.Of, l.Of, O.Of,

O.Of);

verts[16] = new CustomVertex.PositionTextured(1.0f, l.Of, l.Of, l.Of,

O.Of);

verts[17] = new CustomVertex.PositionTextured(1.0f, l.Of, -l.Of, l.Of,

l.Of);

// Bottom face (remember this is facing *away* from the camera, so vertices
should be
clockwise order)
verts[18] = new CustomVertex.PositionTextured(-1.0f, -l.Of, l.Of, O.Of,

O.Of);

verts[19] = new CustomVertex.PositionTextured(-1.0f, -l.Of, -l.Of, O.Of,

l.Of);

verts[20] = new CustomVertex.PositionTextured(1.0f, -l.Of, -l.Of, l.Of,

l.Of);

verts[21] = new CustomVertex.PositionTextured(-1.0f, -l.Of, l.Of, O.Of,

O.Of);

verts[22] = new CustomVertex.PositionTextured(1.0f, -l.Of, -l.Of, l.Of,

l.Of);

verts[23] = new CustomVertex.PositionTextured(1.0f, -l.Of, l.Of, l.Of,

O.Of);

// Left face
verts[24] = new CustomVertex.PositionTextured(-1.0f, l.Of, l.Of, O.Of,

O.Of);

verts[25] = new CustomVertex.PositionTextured(-1.0f, -l.Of, -l.Of, l.Of,

l.Of);

verts[26] = new CustomVertex.PositionTextured(-1.0f, -l.Of, l.Of, l.Of,

O.Of);

verts[27] = new CustomVertex.PositionTextured(-1.0f, l.Of, -l.Of, O.Of,

l.Of);

verts[28] = new CustomVertex.PositionTextured(-1.0f, -l.Of, -l.Of, l.Of,

l.Of);

verts[29] = new CustomVertex.PositionTextured(-1.0f, l.Of, l.Of, O.Of,

O.Of);

// Right face (remember this is facing *away* from the camera, so vertices
should be
clockwise order)
verts[30] = new CustomVertex.PositionTextured(1.0f, l.Of, l.Of, O.Of,

O.Of);

Глава 3. Введение в технологию рендеринга 71

verts[31] = new CustomVertex.PositionTextured(1.0f, -1.Of, 1.Of, l.Of,

O.Of);

verts[32] = new CustomVertex.PositionTextured(1.0f, -l.Of, -l.Of, l.Of,

l.Of);

verts[33] = new CustomVertex.PositionTextured(1.0f, l.Of, -l.Of, O.Of,

l.Of);

verts[34] = new CustomVertex.PositionTextured(1.0f, l.Of, l.Of, O.Of,

O.Of);

verts[35] = new CustomVertex.PositionTextured(1.0f, -l.Of, -l.Of, l.Of,

l.Of);

buffer.SetData(verts, 0, LockFlags.None);

Очевидно, что самое большое изменение здесь — тип данных, исполь­
зуемый для сохранения списка вершин. Последние два значения с плава­
ющей точкой, сохраненные в каждой вершине, представляют собой U и V
координаты в текстуре, используемой для отображения примитива. По­
скольку каждая грань куба представляет собой квадрат, текстуры будут
также квадратными, таким образом, имеет смысл отображать каждый
квадрат непосредственно в текстуре. Обратите внимание, что вершина в
верхнем левом углу соответствует техселу 0,0, а вершина в правой ниж­
ней части отображает непосредственно тексел 1,1. При отображении каж­
дая сторона квадрата будет включать текстуру целиком. Для того чтобы
приложение выполнялось без прерываний, необходимо изменить и за­
дать тип данных вершинного буфера:
vb = new VertexBuffer(typeof(CustomVertex.PositionTextured), 36, device,

Usage.Dynamic

j Usage.WriteOnly, CustomVertex.PositionTextured.Format, Pool.Default);
Давайте немного упростим процедуру рисования наших кубов, доба­
вив следующий код:

private void DrawBox(float yaw, float pitch, float roll, float x, float y,
float z,
Texture t)
(
angle += O.Olf;
device.Transform.World = Matrix.RotationYawPitchRol(yaw, pitch, roll) *
Matrix.Translation(x, y, z);
device.SetTexture(0, t);
device.DrawPrimitives(PrimitiveType.TriangleList, 0, 12);

Первые шесть параметров этой функции те же самые, что мы исполь­
зовали в начале. Мы приводим отклонение (yaw), шаг (pitch) и наклон

72 Часть I. Введение в компьютерную графику
(roll) для нашего вращения куба, плюс X, Y, и Z для перемещения куба.
Последний параметр texture t новый для нас, хотя он представляет тек­
стуру для рендеринга нашего объекта. Мы также вызываем метод
SetTexture для устройства, чтобы сообщить приложению Direct3D, ка­
кую текстуру мы хотим использовать при рендеринге этого примитива.
Первый параметр этого метода определяет стадию, на которой мы управ­
ляем текстурой. Если вспомнить, мы уже упоминали о возможности ото­
бражения до восьми текстур для примитива. Таким образом, этот первый
параметр является индексом текстур. Поскольку сейчас мы имеем набор
координат одной текстуры, мы будем всегда использовать в качестве пер­
вого индекса значение 0. Также обратите внимание, что, поскольку мы
изменяем значение «угла» поворота и осуществляем преобразование ко­
ординат, вы можете удалить соответствующие строки из метода

SetupCamera.

Прежде чем изменить наш код рендеринга для вызова новой функ­
ции, мы сначала должны определить те текстуры, которые будем исполь­
зовать. Демонстрационная программа, имеющаяся на CD диске, включа­
ет в себя три текстуры — puck.bmp, ground.bmp, и banana.bmp, прило­
женные в качестве ресурсов в исходном проекте. В меню проекта на­
жмите «Add Existing Item» и добавьте три изображения. После этого не­
обходимо рассмотреть свойства каждого и изменить пункт «Build Action»
(Компоновка) на «Embedded Resource» (Вложенный Ресурс). Теперь мы
должны объявить переменные для наших текстур, добавив их после со­
здания вершинного буфера:

private Texture tex = null;
private Texture texl = null;
private Texture tex2 = null;

Эти текстуры мы будем использовать для рисования нашего объекта.
Необходимо установить их значения до использования трех упомянутых
точечных рисунков, которые мы определили как ресурсы. Добавьте сле­
дующий код сразу после создания вершинного буфера и заполнения дан­
ных:

tex = new Texture(device, new Bitmap(this.GetIype(), "puck.bmp"), 0,

Pool.Managed);

texl = new Texture(device, new Bitmap(this.GetType(), "banana.bmp"), 0,

Pool.Managed);

tex2 = new Texture(device, new Bitmap(this.GetType(), "ground.bmp"), 0,

Pool.Managed);

Данный метод для нашей текстуры включает четыре параметра. Пер­
вый — device, устройство, которое мы будем использовать для выполне-

Глава 3. Введение в технологию рендеринга
73

ния текстуры. Все ресурсы (текстуры, вершинные буферы, и пр.) в сцене
будут связаны с устройством. Следующий параметр — System.Dra­
wing.Bitmap — мы будет использовать для получения данных для этой
текстуры. В этом случае мы используем конструктор bitmap, чтобы заг­
рузить наш файл из ресурсов. Третий используемый параметр мы уже
кратко обсуждали при описании вершинных буферов, в нашем примере
мы присвоили ему значение «О» и пока не используем. Последний пара­
метр — пул памяти, используемый для хранения текстуры. Для удобства
будем использовать управляемый пул. Ниже приведены другие конструк­
торы или методы, доступные для текстур:

public Texture ( System.IntPtr Ip , Microsoft.DirectX.Direct3D.Device

device ,

Microsoft.DirectX.Direct3D.Pool pool )
public Texture ( Microsoft.DirectX.Direct3D.Device device , System.Int32
width ,

System.Int32 height , System.Int32 numLevels ,

Microsoft.DirectX.Direct3D.Usage usage ,
Microsoft.DirectX.Direct3D.Format format ,
Microsoft.DirectX.Direct3D.Pool pool )
public Texture ( Microsoft.DirectX.Direct3D.Device device ,
System.IO.Stream data ,
Microsoft.DirectX.Direct3D.Usage usage , Microsoft.DirectX.Direct3D.Pool

pool )

Первый конструктор принимает указатель IntPtr, который является

неуправляемым указателем СОМ интерфейса для IDIRECT3DTEXTURE9.

Такой шаг используется для достижения функциональной совместимос­
ти с неуправляемым кодом. Следующий конструктор позволяет созда­
вать пустую текстуру («blank» texture), определяя высоту, ширину и зна­
чение уровня детализации. Это иногда более предпочтительно, чем счи­
тывание этих значений из файла. Последний конструктор напоминает тот,
который мы использовали в нашем приложении, только использует по­
ток данных быстрее, чем растровый bitmap объект. Данный поток дол­
жен иметь возможность загружаться в объект System.Drawing.Bitmap для
работы этого конструктора. Существуют и другие интересные функции
для загрузки текстуры в класс TextureLoader, это мы рассмотрим в после­

дующих главах.

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

74
Часть I. Введение в компьютерную графику

// Draw our boxes

DrawBox(angle / (float)Math.PI, angle / (float)Math.PI * 2.Of, angle /
(float)Math.PI /

4.Of, O.Of, O.Of, O.Of, tex);
'DrawBox(angle / (float)Math.PI, angle / (float)Math.PI / 2.Of, angle /
(float)Math.PI *

4.Of, 5.Of, O.Of, O.Of, texl);

DrawBox(angle / (float)Math.PI, angle / (float)Math.PI * 4.Of, angle /
(float)Math.PI /

2.Of, -5.Of, O.Of, O.Of, tex2);

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

рис.3.3.

Рис. 3.3. Текструрированные кубы

Краткие выводы

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

Использовали вершинные буферы для сохранения данных вершин,

и нарисовали несколько примитивов из того же самого буфера.

Глава 3. Введение в технологию рендеринга 75
• Создали текстуры для более реалистичного отображения объек­
тов.
• Включили данные в наш вершинный буфер и отобразили тексту­
ры на примитивах.
В следующей главе мы обсудим более совершенные методы техноло­
гии рендеринга, включая использование индексных буферов, других ти­
пов примитивов и использование буферов глубины (или Z-буферов).

76 Часть I. Введение в компьютерную графику

Глава 4. Более совершенные

технологии рендеринга

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

треугольников.

• Использование индексных буферов для более управляемого рен­

деринга.

Использование буферов глубины — Z-буферов для более реалис­
тичного рендеринга.
Рендеринг с использованием примитивов

различного типа

До сих пор мы рассматривали в качестве типа примитива только на­
бор треугольников. Имеются и другие типы, которые мы можем исполь­
зовать для рисования.
• PointList — набор точек, тип примитива с самоописанием, ото­
бражает на экране объект из набора точек. Вы не можете исполь­
зовать этот тип, когда рисуете индексированные примитивы (ко­
торые мы рассмотрим позже в этой главе), рис.4.1
LineList — набор линий, отображает каждую пару вершин как от­
дельную линию. При использовании этого типа примитива необ­
ходимо иметь для соединения четное число вершин (по крайней

мере, две), рис.4.2.

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

как отдельный, изолированный треугольник. Отбор невидимой по­

верхности определяется текущим состоянием рендера отбора,

рис.4.4.

Глава 4. Более совершенные технологии рендеринга
77

Рис. 4.1. Набор точек
[~vo

\


V2
\V4

V1 \ V5
V3
Рис. 4.2. Набор линий
Рис. 4.3. Набор ломаных линий

78 Часть I. Введение в компьютерную графику
Рис. 4.4. Набор треугольников
TriangleStrip — полоска из треугольников, рисует каждый следу­
ющий треугольник, используя при построении две имеющиеся
вершины предыдущего треугольника. Режим отбора автоматичес­
ки отражает изображение всех четных треугольниках. Поскольку
данный тип использует последние две вершины предыдущего тре­
угольника, вершина полученного треугольника будет расположе­
на с противоположной стороны от соединяющей эти вершины ли­
нии. Это наиболее распространенный тип примитива для слож­

ных трехмерных объектов, рис.4.5.

TriangleFan — веер из треугольников, похож на предыдущий тип
TriangleStrip, за исключением того, что все треугольники исполь­

зуют одну общую вершину, рис.4.6.

Рис. 4.5. Полоска из треугольников

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

Глава 4. Более совершенные технологии рендеринга 79

•V1
•V2
•V3


V4
>V5

Рис. 4.6. Веер из треугольников

Типовая программа, включенная в CD диск, использует вершинный
буфер, который мы создавали в главе 3. Отметим изменения в этой про­
грамме. Поскольку этот код не предусматривает перемещения вершин,
функция преобразования в методе SetupCamera была удалена, также как
и все ссылки на значение угла поворота «angle». Затем была добавлена
следующая константа, определяющая число элементов:

private const int NumberItems = 12;

Значение «12» выбрано произвольно, но с учетом некоторых условий.
Слишком много вершин выглядело бы сейчас громоздко на экране, одна­
ко, все-таки желательно иметь достаточное число вершин, а также чтобы
оно было четным и делилось на три. В этом случае мы можем корректно
использовать примитивы LineList и TriangleList. Затем необходимо изме­
нить алгоритм создания вершинного буфера и функцию OnVertex-
BufferCreate, как приведено в листинге 4.1:

Листинг 4.1. Создание случайных вершин.
vb = new VertexBuffer(typeof(CustomVertex.PositionColored), Numberltems,
device,
Usage.Dynamic \ Usage.WriteOnly, CustomVertex.PositionColored.Format,

Pool.Default);

// Create a list of vertices equal to the number of items
CustomVertex.PositionColored[] verts = new
CustomVertex.PositionColored[Numberltems];
7 Randomly select the position of this vertex.. Keep it within a range of
5.
for(int i = 0; i < Numberltems; i++)

80 Часть I. Введение в компьютерную графику
float xPos = (float)(Rnd.NextDouble() * 5.Of) - (float)(Rnd.NextDouble()

* 5.0f);

float y?os = (float) (Rnd.NextDouble() * 5.Of) - (float) (Rnd.NextDouble()

* 5.Of);

.float zPos = (float) (Rnd.NextDouble() * 5.Of) - (float) (Rnd.NextDouble()

* 5.Of);

verts[i].SetPosition(new Vector3(xPos, yPos, zPos));
verts[i] .Color = RandomColor.ToArgb();
1
buffer.SetData(verts, 0, LockFlags.None);

Здесь нет ничего необычного. Мы изменили наш вершинный буфер,
чтобы установить корректное число вершин (определяемое константой
Numberltems). Затем мы изменили нашу функцию создания вершин, что­
бы расположить значения вершин случайным образом. Вы можете найти
описание параметров «Rnd» и «RandomColor» в исходном тексте на CD

диске

Затем необходимо изменить вызов рисунка. Простой способ показать,
как эти различные типы примитивов взаимодействуют между собой, зак­
лючается в том, чтобы составить последовательность команд, позволяю­
щую просматривать их друг за другом. Это можно организовать, задав
временную задержку между текущим временем (в тактах) и временем
запуска. Добавьте следующие значения переменных в раздел объявления
типов данных:

private bool needRecreate = false;
// Timing information
private static readonly int InitiallickCount =
System.Environment.TickCount;

Данная булева переменная позволит нам перезаписывать наш вершин­
ный буфер в начале каждого цикла, что позволить нам не отображать
многократно одну и ту же вершину. Замените обращение к функции
DrawPrimitives кодом, приведенным в листинге 4.2:

Листинг 4.2. Рендеринг различных типов примитивов.
// We will decide what to draw based on primitives
int index = ((System.Environment.TickCount - InitialTickCount) / 2000) \ 6;
switch (index)

{

case 0: // Points
device.DrawPrimitives(Primitivelype.PointList, 0, Numberltems);
if (needRecreate)

}

Глава 4. Более совершенные технологии рендеринга
81
// After the primitives have been drawn, recreate a new set

OnVertexBufferCreate(vb, null);

needRecreate = false;

}

break;
case 1: // LineList
device.DrawPrimitives(PrimitiveType.LineList, 0, Numberltems / 2);
needRecreate = true;
break;
case 2: // LineStrip
device.DrawPrimitives(PrimitiveType.LineStrip, 0, Numberltems - 1);
break;
case 3: // TriangleList
device.DrawPrimitives(PrimitiveType.TriangleList, 0, Numberltems / 3);
break;
case 4: // TriangleStrip
device.DrawPrimitives(PrimitiveType.TriangleStrip, 0, Numberltems - 2);
break;
case 5: // TriangleFan
device.DrawPrimitives(PrimitiveType.TriangleFan, 0, Numberltems - 2);
break;
}
Это относительно очевидный алгоритм. В зависимости от того, какой
тип примитива мы выбираем в нашем цикле, мы просто вызываем функ­
цию DrawPrimitives с соответствующим типом примитива. Обратите вни­
мание, что для набора точек мы просто используем число вершин в каче­
стве числа используемых точек. Описанные выше LineList и TriangleList
отображают изолированные примитивы, которые для нашего обращения
к DrawPrimitives с этими типами должны иметь число вершин, кратных
числу вершин в отдельном примитиве (два или три, соответственно).
Учитывая тот факт, что каждая последующая линия рисуется из после­
дней точки предыдущей линии, количество отображаемых линий для
примитивов LineStrip должно быть на одну меньше, чем текущее число
вершин. Для примитивов TriangleStrip и TriangleFan это требование по­
хоже, с поправкой на то, что число треугольников должно быть на два
меньше, чем общее число вершин.
Выполнение данного приложения отобразит сначала последователь­
ность точек на экране, а затем соответствующие линии. Затем эти строки
соединятся в сплошную ломаную линию, а далее в набор изолированных
треугольников. В конечном счете, на экране отобразится полоса или, в
другом случае, веер из треугольников. Обратите внимание, размеры то­
чек можно изменять (значение «scale» в установках состояния рендера).
Добавьте следующую строку к вашей функции SetupCamera для того,
чтобы увеличить размер каждой точки в три раза:

82 Часть I. Введение в компьютерную графику

device.RenderState.PointSize = 3.0 f ;

Можно заметить, что точки значительно больше, чем они были перво­

начально.

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

Использование индексных буферов

Если вспомнить наше первое приложение, где мы рисовали куб и со­
здавали данные для 36 вершин, мы имели 2 треугольника для каждой из
шести граней куба; таким образом, мы имели 12 примитивов. Поскольку
каждый примитив имеет 3 вершины, общее число вершин примитивов
равно 36. Однако, в действительности вершин было только 8, для каждо­

го из углов куба.

Сохранение данных одних и тех же вершин для приведенного приме­
ра может показаться не таким убедительным, но в больших приложени­
ях, где вы имеете огромное количество данных, было бы весьма полез­
ным не сохранять многократно одинаковые вершины, экономя при этом
место в памяти. К счастью, Direct3D имеет механизм для решения таких
задач, называемый «индексным буфером».
Исходя из названия, индексный буфер — это буфер для записи индек­
сов в данные вершин. Индексы, сохраненные в этом буфере, могут быть
32-разрядными (целочисленные данные) или 16-разрядными (короткие
данные). При небольшом количестве индексов можно использовать 16-
разрядный формат.
При использовании индексного буфера для отображения примитивов
каждый индекс в буфере соответствует конкретной вершине и ее дан­
ным. Например, треугольник с индексами 0, 1, 6 отобразился бы в соот­
ветствии с данными, сохраненными в этих вершинах. Давайте изменим
наше приложение, рисующее куб, используя при этом индексы. Сначала
изменим функцию создания данных вершин, как показано в листинге 4.3:

Листинг 4.3. Создание вершин для нашего куба.
vb = new VertexBuffer(typeof(CustomVertex.PositionColored), 8, device,
Usage.Dynamic |
Usage.WriteOnly, CustomVertex.PositionColored.Format, Pool.Default);
CustomVertex.PositionColored[] verts = new CustomVertex.PositionColored[8];
// Vertices
verts[0] = new CustomVertex.PositionColored(-1.0f, l.Of, l.Of,

Color. Purple. ToArgb());

Глава 4. Более совершенные технологии рендеринга 83

verts[1] = new CustomVertex.PositionColored(-1.0f, -l.Of, 1.Of,

Color. Red. ToArgb());

verts[2] = new CustomVertex.PositionColored(1.0f, l.Of, l.Of,

Color.Blue.ToArgb());

verts[3] = new CustomVertex.PositionColored(1.0f, -l.Of, l.Of,

Color.Yellow.ToArgb());

verts[4] = new CustomVertex.PositionColored(-1.0f, l.Of, -l.Of,

Color.Gold.ToArgb());

verts[5] = new CustomVertex.PositionColored(1.0f, l.Of, -l.Of,

Color.Green.ToArgb());

verts[6] = new CustomVertex.PositionColored(-1.0f, -l.Of, -l.Of,

Color.Black.ToArgb());

verts[7] = new CustomVertex.PositionColored(l.Of,-l.Of,-l.Of,

Color.WhiteSmoke.ToArgb());

buffer.SetData(verts, 0, LockFlags.None);

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

Листинг 4.4. Данные индексного буфера для создания куба.
private static readonly short[] indices = {
0,1,2, // Front Face
1,3,2, // Front Face
4,5,6, // Back Face
6,5,7, // Back Face
0,5,4, // Top Face
0,2,5, // Top Face
1,6,7, // Bottom Face
1,7,3, // Bottom Face
0,6,1, // Left Face
4,6,0, // Left Face
2,3,7, // Right Face
5,2,7 // Right Face

};
Для простоты чтения индексный список разбивается на три — для
каждого треугольника, которогое мы будем рисовать. Ясно, что лицевая
сторона куба создается из двух треугольников. Первый треугольник ис­
пользует вершину О, 1, 2, в то время как второй треугольник использует

84 Часть I. Введение в компьютерную графику
вершину 1, 3, 2. Точно так же для правой грани куба первый треугольник
использует вершину 2, 3, 7, второй треугольник использует 5, 2, 7. Пра­
вила отбора невидимой поверхности остаются в силе и при использова­
нии индексов.
Тем не менее, имея только список индексов, мы вряд ли сможем что-
то сделать, не изменив наше приложение. Для этого необходимо создать
индексный буфер. Добавьте следующую строку после объявления вер­
шинного буфера:

private IndexBuffer ib = null;

Этот объект будет использоваться и для хранения индексов, и для обес­

печения доступа приложения Direct3D к этим индексам. Данная проце­
дура напоминает использование вершинного буфера, который мы уже
создали, только вместо данных о вершине IndexBuffer содержит индек­
сы. Рассмотрим примеры использования данного объекта, заполнив его
данными. После создания вершинного буфера добавьте код, приведен­
ный в листинге 4.5:

Листинг 4.5. Создание индексного буфера.
ib = new IndexBuffer(typeof(short),
indices.Length,device,Usage.WriteOnly,Pool.Default);
ib.Created += new EventHandler(this.OnlndexBufferCreate);

OnlndexBufferCreate (ib, null);

private void OnlndexBufferCreate(object sender, EventArgs e)
IndexBuffer buffer = (IndexBuffer) sender;
buffer.SetData (indices, 0, LockFlags.None);

}

Обратите внимание, что конструктор для индексного буфера напоми­
нает конструктор для вершинного буфера. Единственное различие — ог­
раничения на параметры типа. Как упоминалось выше, можно использо­
вать как короткие данные (System.Intl6), так и целочисленные значения
(System.Int32) данных. При использовании индексного буфера мы также
вызываем обработчик события и функцию обработчика прерываний для
первого запуска. Затем мы просто заполняем наш индексный буфер не­
обходимыми данными.
Теперь, чтобы использовать введенные данные, необходимо только
вставить код рендеринга. Если вы помните, была функция, именуемая
SetStreamSource, которая сообщала приложению Direct3D, какой вершин­

ный буфер будет использоваться при выполнении рендеринга. Существует

похожая функция и для индексных буферов, однако в этот раз, она ис-

Глава 4. Более совершенные технологии рендеринга 85
пользуется просто как признак, поскольку одновременно использоваться
может только один тип индексного буфера. Установите этот признак сра­
зу после вызова функции SetStreamSource:

device.Indices = ib;

Теперь, когда Direct3D «знает» о нашем индексном буфере, мы долж­
ны изменить вызов рисунка. В данном случае мы пытаемся отобразить
12 примитивов (36 вершин) из нашего вершинного буфера, который ес­
тественно будет работать некорректно, поскольку он включает данные
только о восьми вершинах. Следует вернуться назад и добавить функ­
цию DrawBox:

private void DrawBox(float yaw, float pitch, float roil, float x, float y,
float z)
(
angle += O.Olf;
device.Transform.World = Matrix.RotationYawPitchRolI(yaw, pitch, roll) *
Matrix.Translation(x, y, z);
device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, 8, 0,
indices.Length / 3);
1

Итак, мы изменили вызов процедуры создания рисунка DrawPrimitives
на DrawIndexedPrimitives. Рассмотрим прототип этой функции:

public void DrawIndexedPrimitives (
Microsoft.DirectX.Direct3D.PrimitiveType primitiveType
, System.Int32 baseVertex , System.Int32 minVertexIndex , System.Int32

numVertices ,

System.Int32 startlndex , System.Int32 primCount )

Первый параметр такой же, как и в предыдущей функции, — тип при­
митивов, которые мы собираемся рисовать. Параметр BaseVertex — сме­
щение от начала индексного буфера до первого индекса вершины. Пара­
метр MinVertexIndex — минимальный индекс вершины в этом вызове.
Параметр NumVertices — значение очевидно (число вершин, используе­
мых в течение этого вызова), однако он запускается вместе с параметра­
ми baseVertex и minVertexIndex. Параметр Startlndex определяет место­
положение в массиве для запуска считывания данных о вершине. После­
дний параметр остается тем же самым (число отображаемых примити­

вов).

Таким образом, видно, что мы пытаемся нарисовать 8 вершин, исполь­
зуя индексный буфер, для того чтобы отобразить 12 примитивов для на­
шего куба. Теперь давайте удалим функции DrawPrimitives и заменим их

86 Часть I. Введение в компьютерную графику
следующими строками для нашего метода DrawBox, приведенного в ли­
стинге 4.6:

Листинг 4.6. Рисование кубов.
// Draw our boxes
DrawBoxfangle / (float)Math.PI, angle / (float)Math.PI * 2.Of, angle /
(float)Math.PI /

4.Of, O.Of, O.Of, O.Of);

DrawBoxfangle / (float(Math.PI, angle / (float)Math.PI / 2.Of, angle /
(float)Math.PI *

4.Of, 5.Of, O.Of, O.Of);

DrawBoxfangle / (float)Math.PI, angle / (float)Math.PI * 4.Of, angle /
(float)Math.PI /

2.Of, -5.Of, O.Of, O.Of);

DrawBoxfangle / (float(Math.PI, angle / (float)Math.PI * 2.Of, angle /
(float)Math.PI /

4.Of, O.Of, -5.Of, O.Of);

DrawBoxfangle / (float)Math.PI, angle / (float)Math.PI / 2.Of, angle /
(float)Math.PI *

4.Of, 5.Of, -5.Of, O.Of);

DrawBoxfangle / (float)Math.PI, angle / (float)Math.PI * 4.Of, angle /
(float)Math.PI /

2.Of, -5.Of, -5.Of, O.Of);

DrawBoxfangle / (float)Math.PI, angle / (float)Math.PI * 2.Of, angle /
(float)Math.PI /

4.Of, O.Of, 5.Of, O.Of);

DrawBoxfangle / (float)Math.PI, angle / (float)Math.PI / 2.Of, angle /
(float)Math.PI *

4.Of, 5.Of, 5.Of, O.Of);

DrawBoxfangle / (float)Math.PI, angle / (float)Math.PI * 4.Of, angle /
(float)Math.PI /

2.Of, -5.Of, 5.Of, O.Of);

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

Глава 4. Более совершенные технологии рендеринга 87
вать ошибки при освещении объекта (поскольку при вычислении осве­
щения используются данные нормалей к поверхностям). Вы можете так
же видеть, что каждый угол куба представлен цветом его вершины, а гра­
ни куба интерполированы из цветов его вершин.

Использование буферов глубины или

Z-буферов

Буфер глубины, depth buffer (часто упоминаемый как Z-буфер или W-

буфер), используется приложением Direct3D для хранения информации
о глубине отображаемого объекта. Эта информация используется в про­
цессе растеризации, чтобы определить, насколько пиксели перекрывают
друг друга. На данном этапе, наше приложение не имеет буфера глуби­
ны, поэтому пиксели изображения не перекрываются в течение всего про­
цесса растеризации. Попробуем нарисовать еще несколько кубов, кото­
рые будут накладываться на некоторые из имеющихся. Добавьте следую­
щие строки в конце наших существующих обращений к DrawBox:

DrawBox(angle / (float)Math.PI, angle / (float)Math.PI * 2.Of, angle /
(float)Math.PI /
4.Of, O.Of, (float)Math.Cos(angle), (float)Math.Sin(angle));
DrawBox(angle / (float)Math.PI, angle / (float)Math.PI / 2.Of, angle /
(float)Math.PI *
4.Of, 5.Of, (float)Math.Sin(angle), (float)Math.Cos(angle));
DrawBox(angle / (float)Math.PI, angle / (float)Math.PI / 2.Of, angle /
(float)Math.PI /
2.Of, -5.Of, (float)Math.Cos(angle), (float)Math.Sin(angle) );

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

устройство:

public Microsoft.DirectX.Direct3D.DepthFormat AutoDepthStencilFormat [get,
set]
public bool EnableAutoDepthStencil [get, set]

88
Часть I. Введение в компьютерную графику

ОПТИМИЗАЦИЯ ПАМЯТИ ПРИ ИСПОЛЬЗОВАНИИ ИНДЕКСНЫХ

БУФЕРОВ

Для того чтобы определить, насколько использование индексного
буфера позволяет экономить память для нашего приложения, срав­
ним относительно простые приложения отображения куба с исполь­
зованием индексного буфера и без него. В первом сценарии мы
создавали вершинный буфер, включающий в себя 32 вершины типа
CustomVertex.PositionColored. Эта структура содержала 16 байт
(4 байта на каждый параметр X, Y, Z и цвет). Можно умножить этот
размер на число вершин, получается, что наши данные вершин за­
нимают 576 байт.
Теперь сравним это с алгоритмом, использующим индексный бу­
фер. Мы используем только 8 вершин (того же самого типа), так что
наш размер данных вершин составляет 128 байтов. Однако, мы так­
же должны хранить наши индексные данные, при этом мы исполь­
зуем короткие индексы (2 байта на каждый), 36 индексов. Таким
образом, наши индексные данные занимают 72 байта, суммируя это
значение с 128 байтами, мы имеем полный размер 200 байтов.
Сравните это с нашим первоначальным размером 576 байтов. Мы
сократили требуемую память на 65 %. Экстраполируя эти значения
на очень большие сцены, нетрудно представить, насколько эффек­
тивным может быть использование индексных буферов в плане эко­
номии памяти.

Установка EnableAutoDepthStencil в значение «true» включает буфер

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

занный в параметре AutoDepthStencilFormat. Применимые значения фор­

матов глубины DepthFormat перечислены в таблице 4.1:

Таблица 4.1. Возможные форматы Z буферов

Формат

D16

D32

D16Lockable

D32FLockable

D15S1

Описание

16-разрядный Z-буфер
32-разрядный Z-буфер
16-разрядный Z-буфер с возможностью блокировки
32-разрядный Z-буфер. Блокируемый формат. Использует стандарт ШЕЕ с плавающей запятой
16-разрядный Z-буфер, использует 15 бит на канал глубины, с последним битом, используемым для шаблонного (stencil) канала (такие каналы будут обсуждаться позднее)

Глава 4. Более совершенные технологии рендеринга 89

Формат Описание

D24S8 32-разрядный Z-буфер. Использует 24 бита для канала глубины и
8 бит для шаблонного канала
D24X8 32-разрядный Z-буфер. Использует 24 бита для канала глубины,
оставшиеся 8 бит игнорируются
D24X4S4 32-разрядный Z-буфер. Использует 24 бита для канала глубины, с 4 битами, используемыми для шаблонного канала. Оставшиеся 4 бита игнорируются
D24FS8 32-разрядный Z-буфер. Использует 24 бита для канала глубины
(с плавающей запятой) и 8 битов для шаблонного канала

ВЫБОР СООТВЕТСТВУЮЩЕГО БУФЕРА ГЛУБИНЫ

На сегодняшний день практически любая приобретаемая графичес­
кая плата поддерживает Z-буфер; однако, в зависимости от обсто­
ятельств, при использовании этого буфера могут возникнуть про­
блемы. При вычислении глубины пиксела приложение Direct3D раз­
мещает пиксель в определенном диапазоне Z-буфера (обычно от
O.Of до 1 .Of), но это размещение редко является равномерным по
всему диапазону. Отношение передней и задней плоскости напря­
мую определяет картину распределения в Z-буфере.
Например, если ваша передняя плоскость определяется значени­
ем 1 .Of, а задняя плоскость значением 100.Of, то 90 % всего диапа­
зона будут использоваться в первых 10 % вашего буфера глубины.
В предыдущем примере, если бы задняя плоскость определялась
значением 1000.Of, то 98 % всего диапазона использовалось бы в
первых 2 % буфера глубины. Это могло бы привести к появлению
«артефактов» при отображении отдаленных объектов.
Использование другого буфера глубины — W-буфера — устраняет
эту проблему, но имеет свои собственные недостатки. При исполь­
зовании W-буфера возможно появление «артефактов» скорее для
ближних объектов, нежели для отдаленных. Также следует отметить,
что не так много графических карт поддерживают W-буферы, по
сравнению с Z-буферами.
И последнее, для увеличения эффективности процедуры рендерин­
га при использовании буферов глубины лучше отображать элемен­
ты от передней плоскости (самое большое значение Z) к задней (са­
мое маленькое значение Z). В течение растеризации сцены Direct3D
может быстро отбросить пиксель, который уже перекрыт, и отобра­
зить видимое поле рисунка полностью. Это не относиться к случаю,
когда мы проводим рендеринг данных с алфавитными компонента­
ми, но к этому вопросу мы вернемся позже.

90 Часть I. Введение в компьютерную графику
Буферы глубины большего размера могут хранить гораздо большее
количество данных глубины, но ценой производительности и скорости.
Если в этом нет необходимости, используйте буферы с меньшим разме­
ром. Современные графические платы поддерживают как правило 16-
разрядные буферы глубины, поэтому мы можем добавить это значение к
существующей структуре параметров:

presentParams.EnableAutoDepthStencil = true;
presentParams.AutoDepthStencilFormat = DepthFormat.D16;

Замечательно, теперь в нашем устройстве имеется буфер глубины.
Остается опробовать работу нашего приложения с новым буфером и срав­
нить результаты.
Запускаем приложение.
К сожалению, что-то нарушилось в выполнении приложения, и мы не
видим того, чего ожидали. Что же случилось с нашими кубами? Почему
добавление буфера глубины к нашему устройству вызвало сбой в работе
программы? Это достаточно интересно: оказывается, наш буфер глуби­
ны ни разу не был «очищен» или сброшен, что и вызвало ошибку в рабо­
те. Попытаемся сделать это. Измените обращение к функции clear следу­
ющим образом:

device.Clear(ClearFlags.Target [ ClearFlags.ZBuffer, Color.CornflowerBlue,
l.Of, 0);

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

Краткие выводы

В этой главе мы охватили более совершенные методы рендеринга,
включая.
Использование индексных буферов, позволяющих обойти лиш­
нее дублирование вершин и таким образом увеличить эффектив­
ность обработки и отображения данных.
• Различные типы примитивов, принципы создания каждого из них.
• Буферы глубины, их описание и использование.
В следующей главе мы будем отображать на экране реальные объек­
ты, загруженные из файлов. Кроме того, пришло время переходить к
объектам «mesh».

Глава 5. Рендеринг «Mesh» 91

Глава 5. Рендеринг Mesh-объектов

В течение этой главы мы рассмотрим следующие пункты.
Применение объектов Mesh.
• Использование материалов, загрузка материалов.
• Рисование общих объектов с использованием Mesh-технологии.
• Использование Mesh для загрузки и рендеринга внешних файлов.

Определение Mesh-объектов

В процессе построения и отображения объектов, помимо создания
вершин вручную, ввода индексных данных, возможна также загрузка
данных вершин из внешнего источника, например файла. Обычный фор­
мат таких файлов — .X файл. В предыдущих главах мы создавали только
простые объекты, которые отображались на экране. Определение дан­
ных для треугольника и куба не составило огромного труда для нас. Но
если представить объект, у которого имеются десятки тысяч вершин,
вместо 36, которых мы использовали, усилия для написания такого кода
или процедуры были бы более чем значительными.
К счастью, в Управляемом DirectX есть объект, который может инкап­
сулировать сохраненные и загружаемые вершины, а также индексиро­
вать данные. Будем называть такой объект — объект Mesh. Объекты Mesh
могут использоваться для сохранения любого типа графических данных,
но главным образом предназначены для формирования сложных моде­
лей. Технология Mesh включает несколько методов или алгоритмов, по­
зволяющих увеличить эффективность рендеринга отображаемых объек­
тов. Все Mesh-объекты будут содержать вершинный буфер и индексный
буфер (с которыми мы уже ознакомились), плюс буфер атрибутов, кото­
рый мы рассмотрим позже в этой главе.
Фактический объект Mesh постоянно находится в библиотеке расши­
рений (Direct3D Extensions library (D3DX)). До сих пор мы имели только
ссылки на главное приложение Direct3D, поэтому, прежде чем использо­
вать Mesh-объекты для нашего проекта, мы должны добавить ссылку на
библиотеку Microsoft.DirectX.Direct3DX.dll. Далее, используя объект
Mesh, попробуем создать наше приложение для вращающегося куба.
После того как мы загрузили необходимые ссылки в наш проект, необ­
ходимо объявить переменную для объекта Mesh. Ее можно разместить там
же, где размещались бы значения вершинного или индексного буфера:

private Mesh mesh = null;

Имеются три метода для создания объектов Mesh; однако, сейчас нам

не понадобится ни один из них. Есть несколько статических методов клас-

92 Часть I. Введение в компьютерную графику
са Mesh, которые мы можем использовать при создании или загрузке раз­
личных моделей. Один из первых методов, на который следует обратить
внимание, — метод «Box». Судя по названию, данный метод создает
объект Mesh, включающий в себя «куб». Для рассмотрения и примене­
ния данного метода добавим следующую строку сразу после кода созда­
ния устройства:
mesh = Mesh.Box(device, 2.Of, 2.Of, 2.0f);
Данный метод создаст новый Mesh-объект, который содержит верши­
ну и индексы, необходимые для рендеринга куба с заданной высотой,
шириной и глубиной (значение 2.Of). Это куб того же размера, что и со­
зданный нами раньше вручную, используя вершинный буфер. Невероят­
но, но мы уменьшили количество строк этой процедуры до одной.
Теперь, когда мы создали Mesh-объект, будут ли наши действия теми
же, что и раньше, или нам необходимы новые методы? Ранее, при ото­
бражении нашего куба мы вызывали функцию SetStreamSource, чтобы
сообщить приложению Direct3D, какой вершинный буфер используется
для считывания данных, а также определяли индексы и свойства форма­
та вершин. При использовании Mesh-объектов отпадает необходимость
в использовании указанных действий.

РИСУНОК, ИСПОЛЬЗУЮЩИЙ MESH-ОБЪЕКТ

Уточним некоторые вопросы относительно вершинного буфера для

Mesh-объектов. При использовании объектов Mesh сохраняются вер­

шинный буфер, индексный буфер и формат вершин. Когда Mesh-

объект подвергается рендерингу, он автоматически устанавливает

потоковый источник, также как индексы и свойства формата вершин.

Теперь, когда наш Mesh-объект создан, необходимо отобразить его на
экране. Все Mesh-объекты разбиты на группу подмножеств (на основе
буфера атрибутов, который мы обсудим вскоре), а также имеется метод
DrawSubset, который мы можем использовать для нашего рендеринга.
Перепишем функцию DrawBox следующим образом:

private void DrawBox(float yaw, float pitch, float roll, float x, float y,
float z)

{

angle += O.Olf;
device.Transform.World = Matrix.RotationYawPitchRoil(yaw, pitch, roll) *
Matrix.Translation(x, y, z);

mesh.DrawSubset(0);

i

Глава 5. Рендеринг «Mesh» 93
Как можно видеть, мы заменили наш вызов DrawIndexedPrimitives
на вызов DrawSubset. Стандартные примитивы, создаваемые классом
Mesh (такие как Mesh.Box), будут всегда иметь единственное подмно­

жество.

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

для объекта Mesh (через свойства VertexFormat), можно увидеть, что здесь

списаны только данные нормалей и местоположение объекта. Цвета
объекта Mesh не были определены и, поскольку мы выключили подсвет­
ку, кубы остались неосвещенными и неокрашенными.
Если вы помните, в главе 1 («Введение в Direct3D») говорилось о том,
что освещение работает только тогда, когда имеются данные о нормалях,
сохраненные для вершин, и поскольку у нас имеются некоторые данные
о нормалях для нашего куба, попробуем включить только подсветку фона.
Освещение в устройстве установлено по умолчанию, поэтому вы можете
либо удалить строку, определяя значение «false», либо установить соот­
ветствующее значение «true».
Итак, мы успешно превратили наши неокрашенные кубы в черные.
Но к сожалению, мы не имеем никакого освещения самой сцены. Пора
ознакомиться с термином «общее освещение» или «общий свет» и ис­
пользовать данную характеристику в нашей сцене.
Общий свет обеспечивается постоянным источником света для сце­
ны. При этом все объекты в сцене будут освещены равномерно, посколь­
ку общее освещение не зависит ни от каких коэффициентов (например,
местоположения источника, направленности, ослабления и пр.), в отли­
чие от других методов освещения. Вам даже не понадобятся данные о
нормалях для задания общего света. Но, несмотря на свою эффектив­
ность, такой свет не позволяет добиться реалистичности картинки. Тем
не менее, пока мы воспользуемся преимуществами общего освещения.
Добавьте следующую строку в раздел, где описывалось состояние рен­
дера подсветки:

device.RenderState.Ambient = Color.Red;

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

94 Часть I. Введение в компьютерную графику

Использование материалов и освещения

Итак, чем же отличается нынешнее освещение от того, которое мы
уже использовали раньше? Единственное главное различие (кроме того,
что используется Mesh) — недостаток цвета в наших данных вершины.
Это и привело к неудаче в нашем случае.
Для того чтобы Direct3D правильно вычислял цвет в отдельных точ­
ках на трехмерном объекте, не достаточно указать только цвет источника
освещения, требуется указать и то, как объект будет отражать свет опре­
деленного цвета. В реальном мире, если вы освещаете красным светом
синюю поверхность, на последней появится мягкий фиолетовый отте­
нок. Вам необходимо описать, как поверхность (в данном случае, наш
куб) отражает свет от источника.
В приложении Direct3D эту особенность описывают так называемые
«материалы». Вы можете определить, каким образом объект будет отра­
жать общий диффузный свет, какие участки будут освещены больше или
меньше (обсудим позже), и отражает ли объект свет вообще. Добавьте
следующий код к вашему обращению DrawBox (до вызова DrawSubset):

Material boxMaterial = new Material!);
boxMaterial.Ambient = Color.White;
boxMaterial.Diffuse = Color.White;
device.Material = boxMaterial;

Здесь мы создаем новый материал и устанавливаем значения общего
и диффузного освещения, выбрав белый цвет. Использование белого оз­

начает, что мы отразим весь общий и диффузный свет, падающий на объек­

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

ринге.

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

алом.

ИСПОЛЬЗОВАНИЕ БОЛЕЕ РЕАЛИСТИЧНОГО ОСВЕЩЕНИЯ

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

выглядят очень реалистичными. Вы не можете даже видеть цент-

Глава 5. Рендеринг «Меsh»-объектов
95
ральные вершины и грани куба, объект выглядит сплошным и нере­
льефным. Оказывается, все зависит от того, как общий свет осве­
щает сцену. Если вы помните, при определении освещения отра­
женный свет вычислялся одинаково для всех вершин в сцене, неза­
висимо от нормали к плоскости объекта или любого другого пара­
метра освещения, рис.5.1.
Рис. 5.1. Общее освещение без использования шейдинга (ретуширования)
Чтобы отобразить наш куб более реалистично, мы должны добавить
реальный свет к нашей сцене. Просмотрите строку, описывающую
общий свет, и после этого добавьте следующие строки:

device.Lights[0].Туре = LightType.Directional;
device.Lights[0].Diffuse = Color.DarkBlue;
device.Lights[0].Direction = new Vector3(0, -1, -1);

device.Lights[0].Commit ();

device.Lights[0].Enabled = true;

Это создаст источник направленного темно-синего света, направ­
ление которого совпадает с выбранным направлением камеры. Те­
перь приложение отобразит затененные вращающиеся темно-си­
ние кубы гораздо более реалистично. Можно увидеть, что направ­
ленные к наблюдателю грани освещены полностью, тогда как по­
вернутые грани кажутся более затененными (возможно даже пол­
ностью темными), рис.5.2.

96 Часть I. Введение в компьютерную графику
Рис. 5.2. Затененные кубы с направленным освещением
Имеются несколько готовых объектов, которые вы можете использо­
вать при использовании Mesh-файлов. Используйте любой из следую­
щих методов для создания этих объектов (каждая из готовых Mesh-фун­
кций требует в качестве первого параметра значение устройства):
mesh = Mesh.Box(device, 2.Of, 2.Of, 2. Of);
Метод, использующий левую систему координат для создания куба.

Width - ширина Определяет размер куба вдоль оси X
Height - высота Определяет размер куба вдоль оси Y
Depth - глубина Определяет размер куба вдоль оси Z
mesh = Mesh.Cylinder(device, 2.Of, 2.Of, 2.Of, 36, 36);

Метод, использующий левую систему координат для создания цилин­
дра.

Radiusl Радиус цилиндра на отрицательном конце оси Z. Это значение
должно быть больше или равно O.Of.
Radius2 Радиус цилиндра на положительном конце оси Z. Это значение
должно быть больше или равно O.Of.

Глава 5. Рендеринг «Меsh»-объектов 97
Length Длина цилиндра на оси Z.
Slices Число секторов (slices) вдоль главной оси (большее значение
добавит больше вершин).
Stacks Число стеков вдоль главной оси (большее значение добавит
больше вершин).
mesh = Mesh.Polygon(device, 2.Of, 8);

Метод, использующий левую систему координат для создания поли­

гона.

Length Длина каждой стороны полигона.
Sides Число сторон полигона.
mesh = Mesh.Sphere(device, 2.Of, 36, 36);

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

Radius Радиус сферы. Это значение должно быть больше или равно О
Slices Число секторов (slices) вдоль главной оси (большее значение
добавит больше вершин).
Stacks Число стеков вдоль главной оси (большее значение добавит
больше вершин).
mesh = Mesh.Torus(device, 0.5f, 2.Of, 36, 18);

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

InnerRadius Внутренний радиус тора. Это значение должно быть больше или
равно О
OutterRadius Внешний радиус тора. Это значение должно быть больше или
равно О
Sides Число сторон в поперечном сечении тора. Это значение должно
быть больше или равно трем.
Rings Число колец в поперечном сечении тора. Это значение должно
быть больше или равно трем.
mesh = Mesh.Teapot(device) ;

Метод, использующий левую систему координат для создания изоб­
ражения заварочного чайника , рис.5.3.
-
Зак.
604

98 Часть I. Введение в компьютерную графику

Рис. 5.3. Встроенный Mesh-обект в виде заварочного чайника

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

Использование Mesh-объектов для
рендеринга сложных моделей

Отображение заварочных чайников выглядит вполне реалистично, но

это не часто используется при программировании игр. Большинство Mesh-

обьектов создано художниками, использующими приложения моделиро­
вания. Если ваше приложение моделирования поддерживает экспорт фай­
лов формата .X, вам повезло!
ПРЕОБРАЗОВАНИЕ ОБЩИХ ФОРМАТОВ МОДЕЛИРОВАНИЯ

В ФАЙЛ .X ФОРМАТА
DirectX SDK (включенный в CD диск) включает в себя несколько ути­
лит преобразования для наиболее популярных приложений моде­
лирования. Использование таких утилит позволяет вам легко пре­
образовывать, сохранять и использовать ваши высококачественные
модели в ваших приложениях.

Глава 5. Рендеринг «Mesh"-объектов 99
Существует несколько типов данных, сохраненных в обычном «.х»
файле, который может быть загружен при создании Mesh-объектов. Сюда
можно отнести вершинные и индексные данные, которые потребуются
при выполнении модели. Каждое из Mesh-подмножеств будет иметь со­
ответствующий материал. Набор материалов может также содержать ин­
формацию о текстуре. Вы можете также получить файл шейдера — вы­
сокоуровневого языка программирования для построения теней (дослов-
но — High Level Shader Language, HLSL), используемого с этим Mesh-
объектом при загрузке файла. Язык шейдеров HLSL — более совершен­
ный раздел, который мы позже рассмотрим более подробно.
Помимо статических методов с использованием Mesh-объектов, кото­
рые позволили нам создавать наши «простые» типы примитивов, суще­
ствуют еще два основных статических Mesh-метода, которые могут ис­
пользоваться для загрузки внешних моделей. Они называются
Mesh.FromFile (с использованием файла) и Mesh.FromStream (с исполь­
зованием потока). Эти методы по существу идентичны, только в потоко­
вом методе имеется большее количество перегрузок в зависимости от
размера потока. Корневые перегрузки для каждого метода следующие:

public static Microsoft.DirectX.Direct3D.Mesh FromFile ( System.String
filename ,
Microsoft.DirectX.Direct3D.MeshFlags options ,
Microsoft.DirectX.Direct3D.Device device ,
Microsoft.DirectX.Direct3D.GraphicsStream adjacency ,
out Microsoft.DirectX.Direct3D.ExtendedMaterial[] materials ,
Microsoft.DirectX.Direct3D.EffectInstance effects )
public static Microsoft.DirectX.Direct3D.Mesh FromStream ( System.10.Stream
stream ,
System.Int32 readBytes ,
Microsoft.DirectX.Direct3D.MeshFlags options ,
Microsoft.DirectX.Direct3D.Device device ,
Microsoft.DirectX.Direct3D.GraphicsStream adjacency ,
out Microsoft.DirectX.Direct3D.ExtendedMaterial[] materials ,
Microsoft.DirectX.Direct3D.EffectInstance effects )

Первым параметром является тип источника данных (filename или
stream), который мы будем использовать для загрузки Mesh-объекта. В
случае загрузки из файла эта строка определяет имя загружаемого Mesh-
файла. В случае использования потока строка указывает на поток и на
число байтов, которые мы хотим считать для данных. При желании счи­
тать весь поток можно просто не включать значение readBytes.
Параметр MeshFlags управляет тем, где и как загружены данные. Этот
параметр может быть представлен в виде поразрядной комбинации зна­
чений, см. таблицу 5.1.

100 Часть I. Введение в компьютерную графику

Параметр

MeshFlags .DoNotClip

MeshFlags.Dynamic

MeshFlags.IbDynamic

MeshFlags.IbManaged

MeshFlags.IbSoftwareProcessing

MeshFlags.IbSystemMem

MeshFlags.lbWriteOnly
MeshFlags.VbDynamic

MeshFlags. VbManaged

MeshFlags.VbSoftwareProcessing

MeshFlags. VbSystemMem

MeshFlags. VbWriteOnly

MeshFlags.Managed

MeshFlags .Npatches

Таблица 5.1. Значения параметра MeshFlags

Значение

Использует флаг Usage.DoNotClip для вершинного и индексных буферов
Равнозначное использование IbDynamic и VbDynamic
Использует Usage.Dynamic для индексных
буферов

Использует пул памяти Pool.Managed для индексных буферов
Использует флаг Usage.SoftwareProcessing для индексных буферов
Использует пул памяти Pool.SystemMemory для индексных
буферов

Использует флаг Usage.WriteOnly Для индексных буферов
Использует Usage.Dynamic для вершинных буферов
Использует пул памяти Pool.Managed для вершинных буферов
Использует флаг Usage. SoftwareProcessing для вершинных буферов
Использует пул памяти Pool.SystemMemory для вершинных
буферов

Использует флаг Usage.WriteOnly для вершинных буферов
Равнозначное использование IbManaged и
VbManaged

Использование флага Usage.NPatches для индексных и вершинных буферов. При рендеринге Mesh объекта потребуется дополнительный улучшенный N-Patch
MeshFlags.Points Использует флаг Usage.Points для
индексных и вершинных буферов

Глава 5. Рендеринг «Meshw-объектов 101

Параметр

MeshFlags.RtPatches
MeshFlags.SoftwareProcessing

MeshFlags.SystemMemory

MeshFlags.Use32Bit

MeshFlags.UseHardwareOnly

Значение

Использует флаг Usage.RtPatches для индексных и вершинных буферов

Равнозначное использование
IbSoftwareProcessing и VbSoftwareProcessing

Равнозначное использование
IbSystemMem и VbSystemMem
Использует 32-разрядные индексы для индексного буфера. Пока возможно, но обычно не рекомендуется
Использует только аппаратную обработку

Следующий параметр device — устройство, которое мы будем исполь­
зовать для рендеринга Mesh-объекта. Этот параметр обязательный, по­
скольку ресурсы должны быть связаны с устройством.
Параметр adjacency является внешним параметром и означает, что
параметр будет локализован и попадет к вам после того, как функция
закончит выполнение. Это возвратит информацию о смежных вершинах
в виде трех целых чисел на поверхность объекта, которые определяют
три «соседних» элемента каждой поверхности Mesh-объекта.
ЧТЕНИЕ ИНФОРМАЦИИ О СМЕЖНЫХ ЗНАЧЕНИЯХ ОТ
ВОЗВРАЩАЕМОГО ПАРАМЕТРА GRAPHICSSTREAM

Информация о смежных значениях, возвращаемая вам процедурой
создания Mesh-объекта, будет приходить из класса GraphicsStream.
Вы можете получить локальную копию смежных данных с помощью
• следующего кода:
int[] adjency = adjBuffer.Read(typeaf(int),

mesh.NumberFaces * 3);

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

Параметр расширения materials также является выходным парамет­
ром, который возвратит массив, включающий информацию о различных

102 Часть I. Введение в компьютерную графику
подмножествах Mesh. Класс ExtendedMaterial поддерживает как обыч­
ный Direct3D материал, так и строку «string», которая может использо­
ваться для загрузки текстур. Обычно этой строкой является имя файла
или название ресурса текстуры. Однако, поскольку загрузка текстуры

выполняется в виде приложения, это могут быть любые введенные пользо­

вателем строковые данные.
Наконец, последний параметр Effectlnstance описывает файл шейдера

HLSL и значения, которые будут использоваться для данного Mesh-объек­

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

мацию.

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

Сначала мы должны удостовериться, что мы имеем переменные объек­

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

private Material[] meshMaterials;
private Texture [] meshTextures;

Поскольку встречается много различных подмножеств объектов, необ­
ходимо сохранить как массив текстур, так и массив материалов, по одному
для каждого подмножества. Давайте рассмотрим некоторый код, позволя­
ющий загрузить Mesh-объект (функция LoadMesh), см. листинг 5.1:

Листинг 5.1. Загрузка Mesh объекта из файла.
private void LoadMesh(string file)

{

ExtendedMaterial[] mtrl;
// Load our mesh
mesh = Mesh.FromFile(file, MeshFlags.Managed, device, out mtrl);
// If we have any materials, store them
if ((mtrl != null) && (mtrl.Length > 0))

{

meshMaterials = new Material[mtrl.Length];
meshTextures = new Texture[mtrl.Length];
// Store each material and texture
for (int i = 0; i < mtrl.Length; i++)

{

Глава 5. Рендеринг «Mesh»-o6beKTOB 103

meshMaterials[i] = mtrl[i] .Material3D;
if ((mtrl[i].TextureFilename != null) && (mtrl[i].TextureFilename !=

string.Empty))

{

// We have a texture, try to load it

meshTextures[i] = TextureLoader.FromFile(device, @"..\..\" +

mtrl[i].TextureFilename);

}
}
}
Сначала мы объявляем наш массив ExtendedMaterial, в котором будет
храниться информация о подмножествах Mesh-объекта. Затем мы про­
сто вызываем метод FromFile для загрузки объекта. На данном этапе мы
не учитываем смежные или HLSL-параметры, поэтому используем пере­

грузку без них.

После загрузки Mesh-объекта необходимо сохранить информацию о
материале и текстурах для различных подмножеств. После того как мы
удостоверимся в наличии последних, мы, наконец, можем распределить
массивы материалов и текстур, использующих число подмножеств в ка­
честве размера. Затем мы свяжем каждое из наших значений массива
ExtendedMaterial и сохраним материал в нашей локальной копии. Если
имеется информация о текстуре, включенной в это подмножество мате­
риалов, то для создания текстуры мы используем функцию TextureLoa-
der.FromFile. Эта функция определена только двумя параметрами, уст­
ройством и именем файла текстуры, и является более предпочтительной,
чем выполнение с помощью функции System.Drawing.Bitmap, рассмот­
ренной раньше.
Для рисования данного Mesh-объекта добавьте следующий метод к
нашему приложению:

private void DrawMesh(float yaw, float pitch, float roll, float x, float y,
float z)

{

angle += O.Olf;
device.Transform.World = Matrix.RotationYawPitchRoll(yaw, pitch, roll) *
Matrix.Translation(x, y, z);
for (int i = 0; i < meshMaterials.Length; i++)

{

device.Material = meshMaterials [i];
device.SetTexture(0, meshTextures[i]);

mesh.DrawSubset(i);

104 Часть I. Введение в компьютерную графику
Если вы обратили внимание, мы сохранили ту же самую последова­
тельность написания кода, что и при использовании метода DrawBox.
Далее, чтобы рисовать Mesh-объект, необходимо связать все материалы
и выполнить следующее:
1. Установить сохраненный материал как материал для устройства.
2. Установить значение текстуры в устройстве для сохраненной тек­
стуры. Даже если не имеется никакой сохраненной текстуры, установите
значением текстуры нулевое значение или пустой указатель.
3. Вызвать функцию пересылки DrawSubset в нашем идентификаторе

подмножества.

Замечательно, теперь мы имеем все, что необходимо для загрузки Mesh-

объекта и отображения его на экране. Исходный текст нашего Mesh-объек­

та «tiny.x» находится в прилагаемом CD диске, данный файл является
тестовым для приложения DirectX SDK. Чтобы его запустить мы добави­
ли следующие строки после создания устройства:
// Load our mesh
LoadMesh(@"..\..\tiny.x");
Затем мы должны изменить нашу информацию о камере, поскольку
загружаемый объект оказался достаточно большим. То есть, мы должны
изменить масштаб изображения нашей камеры. Замените представление
и преобразование проекции следующим образом:

device.Transform.Projection = Matrix.PerspectiveFovLH((float)Math.PI / 4,
this.Width /
this.Height, l.Of, 10000.Of);
device.Transform.View = Matrix.LookAtLH(new Vector3(0,0, 580.Of), new

Vector3(),

new Vector3(0,1,0));

Как видно, мы увеличили длину задней плоскости и переместили ка­
меру достаточно далеко назад. Осталось вызвать функцию DrawMesh:
DrawMesh(angle / (float)Math.PI, angle / (float)Math.PI * 2.Of, angle /
(float)Math.PI / 4.Of, O.Of, O.Of, O.Of);
Запуск и выполнение приложения отобразит на экране картинку, при­

веденную на рис.5.4.

Глава 5. Рендеринг «Mesh-объектов
1*5
Рис. 5.4 Рендеринг Mesh-объекта, загруженного из файла
Итак, мы получили нечто более реалистичное, чем просто вращаю­
щиеся кубы или треугольники.

Краткие выводы

В этой главе мы охватили вопросы рендеринга с использованием Mesh-
объектов, включая.
• Использование объектов Mesh
• Использование материалов.
• Использование Mesh для рисования общих объектов.
Использование Mesh для загрузки и отображения внешних фай­
лов.
В нашей следующей главе мы рассмотрим вопросы оптимизации дан-
ных Mesh-объектов и ознакомимся с более совершенными особенностя­
ми этой технологии.

106 Часть I. Введение в компьютерную графику

Глава 6. Использование Управляемого

DirectX для программирования игр

Выбор игры

Несмотря на то, что мы не обсудили более совершенные возможности
трехмерного программирования, у нас имеется достаточно информации
для того, чтобы написать простую трехмерную игру.
Прежде чем начать писать игру, было бы неплохо придумать план.
Мы должны знать тип игры, которую мы будем писать, основные осо­
бенности и пр. Учитывая ограниченный набор разделов, которые мы ох­
ватили, мы не можем пока создавать что-то чрезмерно сложное. Вместо
этого, мы напишем достаточно несложную программу для нашей игры.
Одна из первых демонстрационных игр для MS DOS называлась «Ос­
лик», «Donkey», в ней пользователь управлял автомобилем, и цель игры
состояла в том, чтобы объехать осликов, встречающихся на дороге. Игра
или ее оформление представляются достаточно простыми для того, что­
бы воссоздать ее на данный момент. В данной главе будет рассмотрено
программирование этой игры в трехмерной варианте, но без осликов. Мы
назовем эту игру «Dodger».
Итак, потратим немного времени на планирование и проектирование
нашей игры. Что нам необходимо, и что мы хотим сделать? Очевидно,
нам понадобится класс «Автомобиль» или «Саг», чтобы управлять на­
шим транспортным средством. Затем, было бы неплохо иметь класс, от­
вечающий за управление препятствиями, которые мы будем пробовать
объезжать. Плюс, мы будем нуждаться в нашем основном классе — движ­
ке игры, который будет выполнять весь рендеринг и связывать все это

вместе.

Если вы попытаетесь создать коммерческий вариант игры, вам пона­
добится затратить много времени на разработку описания игры, что яв­
ляется достаточно серьезным документом, детализирующим огромное
количество игровых концепций и особенностей. Основная задача этой
книги состоит в том, чтобы охватить процесс программирования игр, а
не шаги, которые должны привести к изданию, поэтому вопросы ком­
мерциализации мы опустим.
Другой рекомендуемый документ, который обычно требуется перед
началом работы по разработке — техническая спецификация (для крат­
кости, спецификация). Она включает детальный список всех классов, а
также методы и свойства, которые эти классы осуществят. Этот доку­
мент может также содержать диаграммы UML, которые отображают от­
ношения между объектами.

Глава 6. Использование DirectX для программирования игр 107
Цель спецификации состоит в том, чтобы изначально и основательно
обдумать проект вашего приложения, прежде чем вы начнете писать ка­
кой-либо код или программу. Поскольку акцент в книге поставлен на
программирование игр, непосредственно вопросы по спецификации дан­
ного проекта мы также опустим. Но на будущее рекоммендуется всегда
продумывать спецификацию перед написанием любого кода.

Программирование игры

Вы можете запустить приложение Visual Studio и создать новый про­

ект. Создайте новый проект С# Windows Application под именем «Dodger».

Следует отметить, что заданное по умолчанию название формы — Forml.
Замените каждое имя Forml на имя DodgerGame, которое будет являться
названием класса и будет представлено соответствующим кодом в этой
главе. Необходимо добавить ссылки на три сборки Управляемого DirectX,
которые мы уже использовали в проектах раньше, и включить для них
using-директиву. Перепишите конструктор следующим образом:

public DodgerGame()
(
this.Size = new Size(800,600);
this.Text = "Dodger Game";
this.SetStyle(ControlStyles.AllPaintinglnWmPaint | ControlStyles.Opaque,

true);

}

Данная процедура установит размер окна 800x600, заголовок окна и
стиль для корректного выполнения рендеринга. Затем необходимо изме­
нить точку входа, заменяя основной метод «Main» на приведенный в ли­
стинге 6.1.
Листинг 6.1. Основная точка входа игры.
static void Main()
{

using (DodgerGame frm = new DodgerGame!))

{

// Show our form and initialize our graphics engine

frm.Show();

frm.InitializeGraphics();

Application.Run(frm);

}
}

108 Часть I. Введение в компьютерную графику
По существу, это тот же самый код, с помощью которого мы уже за­
пускали все примеры раньше. Мы создаем окно Windows, инициализи­
руем графику и затем запускаем форму, и таким образом, приложение.
Тем не менее, в функции инициализации InitializeGraphics, где и будет

запускаться программа, необходимо внести некоторые изменения. Добавь­

те к вашему приложению метод, приведенный в листинге 6.2.

Листинг 6.2. Инициализация Графических Компонентов.
///
/// We will initialize our graphics device here
///

public void InitializeGraphics!)
(
// Set our presentation parameters
PresentParameters presentParams = new PresentParametersO;
presentParams.Windowed = true;
presentParams.SwapEffeet = SwapEffect.Discard;
presentParams.AutoDepthStencilFormat = DepthFormat.D16;
presentParams.EnableAutoDepthStencil = true;
// Store the default adapter
int adapterOrdinal = Manager.Adapters.Default.Adapter;
CreateFlags flags = CreateFlags.SoftwareVertexProcessing;
// Check to see if we can use a pure hardware device
Caps caps = Manager.GetDeviceCaps(adapterOrdinal, DeviceType.Hardware);
// Do we support hardware vertex processing?
if (caps.DeviceCaps.SupportsHardwareTransformAndLight)
// Replace the software vertex processing
flags = CreateFlags.HardwareVertexProcessing;
// Do we support a pure device?
if (caps.DeviceCaps.SupportsPureDevice)
flags ] = CreateFlags.PureDevice;
// Create our device
device = new Device(adapterOrdinal, DeviceType.Hardware, this, flags,

presentParams) ;

// Hook the device reset event
device.DeviceReset += new EventHandler(this.OnDeviceReset);

this.OnDeviceReset(device, null);

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

Глава 6. Использование DirectX для программирования игр 109
На сегодняшний день современные графические платы могут поддер­
живать обработку вершин за счет аппаратного ускорения. Зачем же тра­
тить процессорное время, когда можно «возложить» часть операций не­
посредственно на графическую карту, которая выполнит это значительно
быстрее? Однако, вы можете не знать, действительно ли используемый
адаптер поддерживает эти возможности. Об этом немного позже.
Теперь мы можем узнавать о возможностях устройства еще до его со­
здания, а также определять флажки, необходимые при создании устрой­
ства. Как вы помните из главы 2, структура отображаемого списка воз­
можностей устройства огромна и разбита на различные подразделы. Под­
раздел, представляющий интерес на данный момент, — DeviceCaps, со­
держит описание свойств и возможностей для соответствующего драй­

вера.

Когда вы хотите выяснить, поддерживается ли данная специфическая
возможность или нет, вы можете просто проверить булево значение, от­
носящееся к этой возможности: если это значение «true», возможность
поддерживается, в противном случае, нет. В первую очередь вы выясня­
ете, поддерживаются ли в данном устройстве аппаратные преобразова­
ния и освещение. Если да, вы можете создавать устройство с аппаратной
обработкой вершин, добавив флаг hardware vertex processing к осталь­
ным. Затем необходимо выяснить, можете ли вы создавать реальное уст­
ройство (возможно только при наличии аппаратной обработки вершин);

если да, вы используете для флажков поразрядный оператор «OR» («или»),

добавляя также эту возможность. Реальное аппаратное устройство — наи­
более эффективный тип устройства, которое вы можете создать, так что
если эти опции доступны, необходимо использовать их.
Затем вы создаете устройство, используя указанные флажки, в зави­
симости от возможностей ваших графических плат, вы можете использо­
вать реальное аппаратное устройство или же некую его разновидность.
Если помните, при использовании вершинных буферов возникала необ­
ходимость отслеживания события сброса устройства, подобная же ситу­
ация присутствует и здесь. Всякий раз, когда устройство сбрасывается,
желательно определить установки состояния устройства по умолчанию.
Поэтому необходимо отслеживать событие сброса. Метод обработчика
событий или обработчик событий (event handler method) приведен в лис­
тинге 6.3, добавьте его к вашему приложению.

Листинг 6.3. Обработчик события сброса устройства
private void OnDeviceReset(object sender, EventArgs e)
(
device.Transform.Projection = Matrix.PerspectiveFovLH((float)Math.PI / 4,
this.Width / this.Height, l.Of, 1000.Of);

110
Часть I. Введение в компьютерную графику
device.Transform.View = Matrix.LookAtLH(new Vector3(0.0f, 9.5f, 17.Of),
new Vector3(),

new Vector3 (0,1,0));

// Do we have enough support for lights?
if ((device.DeviceCaps.VertexProcessingCaps.SupportsDirectionalLights) &&
((unit)device.DeviceCaps.MaxActiveLights > 1))
(
// First light
device.Lights[0].Type = LightType.Directional;
device.Lights[0].Diffuse = Color.White;
device.Lights[0].Direction = new Vector3(l, -1, -1);

device.Lights[0]. Commit ();

device.Lights[0].Enabled = true;
// Second light
device.Lights[1].Type = LightType.Directional;
device.Lights[l].Diffuse = Color.White;
device.Lights[1].Direction = new Vector3(-l, 1, -1);

device. Lights [ 1 ]. Commit () ;

device.Lights[l].Enabled = true;

1

else

(
// Hmm.. no light support, let's just use
// ambient light
device.RenderState.Ambient = Color.White;

1

Начало этой функции достаточно знакомо для нас. Устанавливается
камера, определяется вид и преобразование проекции в устройстве. Для
этой игры выбирается неподвижная камера, и эти параметры необходи­
мо устанавливать после каждого сброса устройства (все состояния уст­
ройства аннулируются при сбросе).
Использование общего освещения не является предпочтительным,
поскольку мы уже видели, что общий свет не совсем реалистичен, более
подходящим был бы направленный свет. Однако, мы уже не можем про­
верить, поддерживает ли устройство данный тип освещения или нет, по­
скольку после создания устройства структура Properties, «возможности»
или «свойства», уже не используется. Если устройство может поддержи­
вать источник или источники направленного освещения, мы будем ис­
пользовать их, в противном случае возможна установка общего света по
умолчанию. Возможно, это будет не так реалистично, но это лучше, чем
иметь неосвещенную сцену.
Необходимо окончательно переписать метод OnPaint для того, чтобы
запустить процедуру рендеринга. Добавьте следующую функцию:

Глава 6. Использование DirectX для программирования игр 111

protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)

{

device.Clear(ClearFlags.Target \ ClearFlags.ZBuffer, Color.Black, l.Of, 0);

device.BeginScene();

device.EndScene();

device.Present();

this.Invalidated ;
}

ИСПОЛЬЗОВАНИЕ ТОЛЬКО НЕОБХОДИМОГО ОСВЕЩЕНИЯ
Вместо того чтобы использовать подход «все или ничего» в плане
выбора типа освещения, вы можете просто проводить «многоуров­
невую» проверку поддержки режимов освещения. В данном сцена­
рии сначала выясняется, поддерживается ли хотя бы один источник
света, и если да, можно включить его. Затем проверяется наличие
второго поддерживаемого источника света, и так далее. Это дает
возможность иметь резервный вариант (один источник) даже для
тех устройств, которые не поддерживают два источника света и бо­
лее. Данный пример не совсем подходит при использовании одно­
го источника направленного света, поскольку многоуровневая про­
верка не была выполнена. Хотя даже в этом случае это выглядело
бы примерно так:
// Do we have enough support for lights?
if ((device.DeviceCaps.VertexProcessingCaps.SupportsDirectionalLights) &&
((unit)device.DeviceCaps.MaxActiveLights > 0))
(
II First light
device.Lights[0].Type = LightType.Directional;
device.Lights[0].Diffuse = Color.White;
device.Lights[0].Direction = new
Vector3(l, -1, -1);
device.Lights[0].Commit();
device.Lights[0].Enabled = true;
if ((unit)device.DeviceCaps.MaxActiveLights > 1))

{
// Second light
device.Lights[l].Type = LightType. Directional;
device.Lights[l].Diffuse = Color.White;
device.Lights[1].Direction = new Vector3(-l, 1, -1);

device.Lights[1].Commit () ;

device.Lights[1].Enabled = true;

}
}

112 Часть I. Введение в компьютерную графику
Вернемся к методу OnPaint. Ничего нового, кроме установки черного
цвета фона. Теперь мы можем приступить к созданию первого игрового
объекта — «road». Исходный текст программы находится на CD диске,
включая файл .X, который будет отображать данные объекта «road», по­
этому мы должны объявить переменные для объекта «road mesh»:

// Game board mesh information
private Mesh roadMesh = null;
private Material[] roadMaterials = null;
private Texture[] roadTextures = null;

Мы будем также использовать разновидности функции загрузки Mesh-

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

формацию о всех материалах и текстурах, в отличии от переменных класса

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

Листинг 6.4. Процедура загрузки Mesh-объекта.
public static Mesh LoadMesh(Device device, string file, ref Material!]
meshMaterials,
ref Texture[] meshTextures)

{

ExtendedMaterial[] mtrl;
// Load our mesh
Mesh tempMesh = Mesh.FromFile(file, MeshFlags.Managed, device, out mtrl);
// If we have any materials, store them
if ((mtrl != null) && (mtrl.Length > 0))

{

meshMaterials = new Material[mtrl.Length];
meshTextures = new Texture[mtrl.Length];
// Store each material and texture
for (int i = 0; i < mtrl.Length; i++)
( meshMaterials [i] = mtrl[i].Material3D;
if ((mtrl[i].TextureFilename != null) && (mtrl[i].TextureFilename ! =
string.Empty))
(
// We have a texture, try to load it
meshTextures[i] = TextureLoader.FromFile(device, @"..\..\" +
mtrl[i].TextureFilename);

}
}

Глава 6. Использование DirectX для программирования игр 113
return tempMesh;

}

Эта функция уже обсуждалась раньше, так что нет необходимости
описывать ее еще раз. Мы используем эту функцию, чтобы загрузить
обьект «road», и нам следует определить и вызвать ее в процедуре обра­
ботчика события сброса устройства, в конце которой можно добавить
следующий код:
// Create our road mesh
roadMesh = LoadMesh(device, @"..\..\road.x", ref roadMaterials, ref

roadTextures) ;

Удостоверьтесь в том, что вы скопировали объект файл текстуры в
каталог с вашим исходным кодом. Этот код загрузит объект Mesh «road»,

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

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

private void DrawRoad(float x, float y, float z)
(
device.Transform.World = Matrix.Translation(x, y, z);
for (int i = 0; i < roadMaterials.Length; i++)
(

device.Material = roadMaterials[i];
device.SetTexture (0, roadTextures [i]) ;

roadMesh.DrawSubset(i);

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

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

Это лишние вычисления, которые нам не нужны. Другая причина — точ­
ность: если бы мы позволили автомобилю продвигаться только вперед, и
игрок был бы достаточно резвым, в конечном счете, автомобиль «уехал»

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

// Constant values for the locations
public const float RoadLocationLeft = 2.5f;
public const float RoadLocationRight = -2.5f;
private const float RoadSize = 100.Of;
private const float MaximumRoadSpeed = 250.Of;
private const float RoadSpeedlncrement = 0.5f;
// Depth locations of the two 'road' meshes we will draw
private float RoadDepthO = O.Of;
private float RoadDepthl = -100.Of;
private float RoadSpeed = 30.Of;

Mesh-объект «road», используемый для создания дороги — достаточ­
но распространенный объект. Его длина составляет 100 единиц, а шири­
на — 10 единиц. Константа размера отражает фактическую длину доро­
ги, в то время как две константы местоположения отмечают расстояние
от центральной линии линий обеих сторон дороги. Последние две кон­
станты предназначены для управления в процессе ведения игры. Макси­
мальная скорость перемещения дороги составляет 250 единиц в секунду,
при увеличении скорости дискретность составляет половину единицы.
Наконец, необходимо установить значение глубины двух дорожных
секций. Для этого следует инициализировать первую секцию как ноль, а
вторую секцию начать непосредственно с конца первой (обратите внима­
ние, что это значение равно размеру дороги). Итак, мы имеем основные
переменные и константы, необходимые для рисования и перемещения
дороги, и можно добавить вызов процедуры рисования. Поскольку мы
хотим отобразить дорогу первой, добавьте два вызова DrawRoad после
функции рендеринга сцены BeginScene:

// Draw the two cycling roads
DrawRoad(O.Of, O.Of, RoadDepthO);
DrawRoad(O.Of, O.Of, RoadDepthl);

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

Глава 6. Использование DirectX для программирования игр 115
экране, пикселы рассчитываются фильтром растяжения. Когда несколь-
то элементов текстуры перекрывают отдельный пиксел, они рассчитыва­
ются фильтром сжатия. Заданный по умолчанию фильтр растяжения и
сжатия, называемый точечным фильтром (Point Filter), попросту исполь­
зует самый близкий элемент текстуры как цвет для соответствующего
пиксела. Это и вызывает эффект пикселизации.
Существуют различные способы для фильтрации текстур, однако, не
каждое устройство может поддерживать их. Все, что вам действительно
необходимо, это фильтр, который может интерполировать элементы тек­

стуры дороги, чтобы выполнить ее более гладко. К функции OnDeviceReset

добавьте код, приведенный в листинге 6.5.

Листинг 6.5. Фильтрация текстуры.
// Try to set up a texture minify filter, pick anisotropic first
if (device.DeviceCaps.TextureFilterCaps.SupportsMinifyAnisotropic)

{

device.SamplerState[0].MinFilter = TextureFilter.Anisotropic;

}

else if (device.DeviceCaps.TextureFilterCaps.SupportsMinifyLinear)

{

device.SamplerState[0].MinFilter = TextureFilter.Linear;

}

// Do the same thing for magnify filter
if (device.DeviceCaps.TextureFilterCaps.SupportsMagnifyAnisotropic)

{

device.SamplerState[0].MagFilter = TextureFilter.Anisotropic;

}

else if (device.DeviceCaps.TextureFilterCaps.SupportsMagnifyLinear)

{

device.SamplerState[0].MagFilter = TextureFilter.Linear;

}
Как вы можете здесь видеть, вначале выясняется, способно ли ваше

устройство поддерживать анизотропную фильтрацию при растяжении или

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

фильтрации, приложение отобразит на экране более гладкую поверхность

дороги.

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

116 Часть I. Введение в компьютерную графику
столкновение автомобиля с препятствием. Для этого необходимо выз­
вать эту функцию в разделе метода OnPaint (до вызова функции очистки

Clear):

// Before this render, we should update any state

OnFrameUpdate ();

Также необходимо добавить к приложению метод, приведенный в
листинге 6.6.

Листинг 6.6. Метод обновления кадра.
private void OnFrameUpdate ()

{

// First, get the elapsed time
elapsedTime = Utility.TimerjDirectXTimer.GetElapsedlime);
RoadDepthO += (RoadSpeed * elapsedTime);
RoadDepthl += (RoadSpeed * elapsedTime);
// Check to see if we need to cycle the road
if (RoadDepthO > 75.Of)

{

RoadDepthO = RoadDepthl - 100.Of;

}

if (RoadDepthl > 75.Of)

{

RoadDepthl = RoadDepthO - 100.Of;

}

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

параметра elapsed time позволяет перемещать дорогу и затем удалять

пройденные дорожные секции, размещая их в конце текущей дорожной
секции. При этом необходимо определить «количество» пройденной до­
роги, умножив текущую дорожную скорость (измеряемую в единицах за
секунду) на количество прошедшего времени (в секундах), таким обра­
зом мы получаем «количество» дороги на кадр. Также необходимо вклю­
чить ссылку на elapsedTime в вашей секции объявления переменных:
private float elapsedTime = O.Of;

Глава 6. Использование DirectX для программирования игр 117

ПЕРЕМЕЩЕНИЕ ОБЪЕКТОВ В РЕАЛЬНОМ МАСШТАБЕ ВРЕМЕНИ

Почему это так необходимо? Скажем, вы решили увеличивать при­
ращение величины дороги при постоянном значении для каждого
кадра. На вашем компьютере это выполняется совершенно, так по­
чему это не работает точно также на других системах? Например,
дорога перемещается на другом компьютере несколько медленнее,
чем на вашем. Или дорога перемещается удивительно медленно,
по сравнению с тем, что испытывает человек, едущий на машине.
Причина кроется в том, что вы выполняете ваши вычисления, опи­
раясь на частоту смены кадров. Например, скажем, в вашей систе­
ме изображение сменяется со скоростью 60 кадров в секунду, и все
вычисления опираются на это значение. Теперь возьмем машины,
которые работают с частотой обновления кадра 40 кадров в секун­
ду, или более быстрые, например, 80 кадров в секунду; естествен­
но мы получим различные результаты. Таким образом, возникает
задача, чтобы ваша игра выполнялась неизменно и независимо от
типа системы, поэтому при вычислениях нужно уходить от привяз­
ки к частоте смены кадров.
Лучший способ для решения этой проблемы состоит в том, чтобы
определить и привязать игровые перемещения и вычисления к не­
которой неизменной единице времени. Например, максимальная
скорость нашей дороги определена как 250 единиц в секунду. Наша
первая цель состояла бы в том, чтобы определить время, прошед­
шее с момента нашего последнего обновления. В версии .NET
Runtime имеется встроенная утилита (встроенный таймер), которая
может использоваться для определения текущего отсчета времени
системы, но у которой есть свой недостаток, связанный главным
образом с низкой разрешающей способностью таймера, составля­
ющей, как правило, 15 миллисекунд. Это приводит к тому, что при
высокой скорости смены кадров (более 60 кадров в секунду) дви­
жения будут казаться прерывистыми.
Версия DirectX SDK включает в себя класс, называемый DirectXTimer,
который, если ваша машина позволяет это, использует таймер с
высоким разрешением (обычно 1 миллисекунда). Если данный тай­
мер не доступен на вашей машине, то система вернется к встроен­
ному таймеру. Примеры в этой книге будут использовать данный
таймер (DirectXTimer) как механизм определения времени. Он уже
включает в себя код для таймера высокой точности, поэтому мы не
будем изобретать это «колесо» дважды.

118 Часть I. Введение в компьютерную графику

Добавление движущегося автомобиля

в используемую сцену

Теперь, когда вы отображаете на экране объект в виде перемещаю­
щейся дороги, необходимо добавить объект, с которым взаимодействует
игрок — это автомобиль (в листинге программы — «саг»). Вы могли бы
просто разместить переменные класса «саг», константы и код в основной
класс — «Main class», в котором размещены и дорожные секции, но это
выглядело бы не так модульно, как хотелось. Было бы предпочтительнее
размещать автомобильный код отдельно, в его собственном классе, кото­
рый мы попробуем сейчас создать. В главном меню проекта откройте
опцию Add New Item и выберите в качестве добавляемого новый класс,
названный «саг». Проверьте, что вы включили операторы использования
Управляемого DirectX в этом новом файле кода, созданном для вашего

приложения.

Что же должен делать класс «саг»? Как мы уже говорили, в процессе
рендеринга автомобиль остается неподвижным относительно перемеща­
ющейся сцены, за исключением перемещений влево-вправо, когда он
должен объезжать препятствия. С учетом вышесказанного, необходимо
добавить следующий набор переменных в наш класс:

// Car constants
public const float Height = 2.5f;
public const float Depth = 3.0f;
public const float Speedlncrement = 0.If;
private const float Scale = 0.85f;
// Car data information
private float carLocation = DodgerGame.RoadLocationLeft;
private float carDiameter;
private float carSpeed = 10.Of;
private bool movingLeft = false;
private bool movingRight = false;
// Our car mesh information
private Mesh carMesh = null;
private Material[] carMaterials = null;
private Texture[] carlextures = null;

Данные переменные будут управлять всеми параметрами, необходи­
мыми для управления автомобилем. Константы высоты «Height» и глу­
бины «Depth» автомобиля останутся статическими (поскольку переме­
щение осуществляется только влево-вправо). Приращение скорости бо­
кового перемещения «Speedlncrement» также будет постоянным. После­
дняя константа «Scale» — масштаб или отношение размера автомобиля
относительно ширины дороги.

Глава 6. Использование DirectX для программирования игр 119
Переменные в классе «саr» очевидны. Текущее местоположение авто­
мобиля на дороге, которое установлено по умолчанию с левой стороны
дороги. Диаметр автомобиля, который будет использоваться при столк­
новении автомобиля с препятствием. Текущая боковая скорость автомо­
биля (так как скорость перемещения дороги может увеличиваться, ско­
рость перемещения автомобиля должна увеличиться соответственно). И,
наконец, две логические переменные, которые определяют направление
перемещения (влево-вправо), а также файл .X данных объекта Mesh.
Для создания объекта Mesh (и его связанных структур) и вычисления
диаметра автомобиля потребуется конструктор класса саr. Замените за­
данный по умолчанию конструктор на специально созданный для ваше­
го приложения, см. листинг 6.7.

Листинг 6.7. Создание класса саr
///
/// Create a new car device, and load the mesh data for it
///

/// D3D device to use
public Car(Device device)

{

// Create our car mesh
carMesh = DodgerGame.LoadMesh(device, @"..\..\car.x", ref carMaterials,

ref carTextures);

// We need to calculate a bounding sphere for our car
VertexBuffer vb = carMesh.VertexBuffer;
try

{

// We need to lock the entire buffer to calculate this
GraphicsStream stm = vb.Lock(0, 0, LockFlags.None) ;
Vector3 center; // We won't use the center, but it's required
float radius = Geometry.ComputeBoundingSphere(stm,
carMesh.NumberVertices, carMesh.VertexFormat, out center);
// All we care about is the diameter. Store that
carDiameter = (radius * 2) * Scale;

}

finally

{

// No matter what, make sure we unlock and dispose this vertex
// buffer.

vb.Unlock();

vb.Disposed;

}
}

120 Часть I. Введение в компьютерную графику
Создание объекта Mesh достаточно просто, так как представляет собой
тот же самый метод, который мы использовали при создании Mesh-объекта
road, только с другими именами переменных. Новым алгоритмом здесь яв­
ляется только вычисление диаметра автомобиля. Вычисляется граничная
сфера (сфера, которая полностью заключает в себе все точки в Mesh объек­
те) для автомобиля. Класс geometry содержит данную функцию, но она тре­
бует пересылки параметров вершин для вычисления граничной сферы.
То, что нам сейчас необходимо, это получить вершинные данные из
Mesh-объекта. Уже известно, что данные вершин хранятся в вершинных
буферах, так что мы можем использовать вершинный буфер, сохранен­
ный в Mesh-объекте. Чтобы считать данные из вершинного буфера необ­
ходимо вызвать метод блокировки на момент считывания, Lock method,
который возвращает все потоковые вершинные данные. О других мето­
дах, работающих с вершинными буферами, мы расскажем в следующей
главе. После метода блокировки мы можем использовать метод
ComputeBoundingSphere, чтобы получить «центр» этого Mesh-объекта и
радиус сферы. Поскольку мы не заботимся о центре объекта и хотим со­
хранить диаметр, удвоим радиус и сохраним его. Окончательно (в блоке
finally), мы проверяем, что вершинный буфер, который мы использова­
ли, разблокирован и освобожден.
Далее необходимо добавить метод, выполняющий прорисовку ваше­
го автомобиля. Поскольку вы сохраняете положение автомобиля в клас­
се, единственная необходимая вещь, которая понадобится для этого ме­
тода — это используемое для рисунка устройство. Этот метод аналоги­
чен методу DrawRoad, отличаясь лишь в использовании переменных и в
том, что мы масштабируем объект перед его выводом на экран. Добавьте
следующий код:

///
/// Render the car given the current properties
///

/// The device used to render the car
public void Draw(Device device)

{

// The car is a little bit too big, scale it down
device.Transform.World = Matrix.Scaling(Scale,
Scale, Scale) * Matrix.Translation(carLocation, Height, Depth);
for (int i = 0; i < carMaterials.Length; i++)

{

device.Material = carMaterials[i];
device.SetTexture(0, carTextures[i]);

carMesh.DrawSubset(i);

}
}

Глава 6. Использование DirectX для программирования игр 121
Перед тем как использовать класс саr, необходимо создать локальные

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

список параметров к вашему классу саr:

// Public properties for car data
public float Location
get ( return carLocation; }
set ( carLocation = value; }
public float Diameter
get ( return carDiameter; )
public float Speed
get ( return carSpeed; (
set ( carSpeed = value; 1
public bool IsMovingLeft
get ( return movingLeft; }
set ( movingLeft = value; I
public bool IsMovingRight
get { return movingRight; 1
set ( movingRight = value; }

Далее необходимо добавить переменную для поддержки класса саг в
основном движке игры. Добавьте следующие строки где-нибудь в разде­
ле определения переменных приложения DodgerGame:
// Car
private Car car = null;
Поскольку мы используем устройство в качестве параметра конструк­
тора, мы не можем создавать класс саr до момента создания этого устрой­
ства. Было бы неплохо поместить алгоритм создания автомобиля в методе
OnDeviceReset. Для этого сразу после создания Mesh-объекта road добавь­
те следующие строки, чтобы создать объект саr в качестве устройства:
// Create our car
car = new Car (device);

122 Часть I. Введение в компьютерную графику
После создания объекта класса саr мы можем изменить алгоритм рен­
деринга, чтобы запустить процедуру отображения автомобиля. Сразу
после вызова двух методов DrawRoad из метода OnPaint добавьте вызов
рисунка из объекта саr:

// Draw the current location of the car

car.Draw(device);

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

Листинг 6.8. Обработка команд с помощью клавиш.
///
/// Handle key strokes
///

protected override void OnKeyDown(System.Windows.Forms.KeyEventArgs e)

{

// Handle the escape key for quiting
if (e.KeyCode == Keys.Escape)

{

// Close the form and return
this.Closed;

return;

}
// Handle left and right keys if ((e.KeyCode == Keys.Left) || (e.KeyCode == Keys.NumPad4))

{

car.IsMovingLeft = true;
car.IsMovingRight = false;

}

if ((e.KeyCode == Keys.Right) || (e.KeyCode == Keys.NumPad6))

{

car.IsMovingLeft = false;
car.IsMovingRight = true;

}

II Stop moving
if (e.KeyCode == Keys.NumPad5)

{

car.IsMovingLeft = false;
car.IsMovingRight = false;

}
}

Глава 6. Использование DirectX для программирования игр 123
Ничего особенного здесь не происходит. При нажатии на клавишу
«Escape» игра будет закончена закрытием формы. Нажатием левой или

правой клавиши-стрелки мы записываем соответствующее значение «true»

в переменной перемещения «влево», «вправо» (в распечатке IsMovingLeft
и IsMovingRight), при этом для перемещения в противоположную сторо­
ну данная переменная устанавливается в значение «false». Перемещение
автомобиля прекращается, если нажата клавиша «5» на цифровой клави­
атуре. Итак, при выполнении приложения нажатие этих клавиш заставит
переменные изменять свои значения, но при этом сам автомобиль не бу­
дет двигаться. Необходимо также добавить функцию обновления для ав­
томобиля. Добавьте метод, приведенный в листинге 6.9, в ваш класс саг.

Листинг 6.9. Управление перемещением автомобиля.
///
/// Update the cars state based on the elapsed time
///

/// Amount of time that has elapsed
public void Update(float elapsedTime)
(
if (movingLeft)

{

// Move the car
carLocation += (carSpeed * elapsedTime);
// Is the car all the way to the left?
if (carLocation >= DodgerGame.RoadLocationLeft)
{

movingLeft = false;
carLocation = DodgerGame.RoadLocationLeft;

}

}

if (movingRight)

{

// Move the car
carLocation -= (carSpeed * elapsedTime);
// Is the car all the way to the right?
if (carLocation <= DodgerGame.RoadLocationRight)

{

movingRight = false;
carLocation = DodgerGame.RoadLocationRight;

}

}
}
Этот метод принимает в качестве параметра общее затраченное время
«elapsed time» таким образом, чтобы мы могли поддерживать те же са-

124 Часть I. Введение в компьютерную графику
мые перемещения на всех компьютерах. Сама функция достаточно про­
ста. Если одна из переменных перемещения принимает значение «true»,
мы будем двигаться в соответствующем направлении (опираясь на пара­

метр «elapsed time»). Затем проверяется местоположение автомобиля, если

положение неправильное (автомобиль выходит за пределы дороги), дви­
жение останавливается полностью. Однако, в настоящий момент этот
метод не вызывается, и для того чтобы его вызвать, необходимо изме­
нить метод OnFrameUpdate в классе DodgerGame. Добавьте следующую
строку к концу этого метода:

// Now that the road has been 'moved', update our car if it's moving

car.Update(elapsedTime);

Добавление препятствий

Поздравляем! Это — первое интерактивное графическое ЗD-прило-
жение, которое вы создали. Мы получили модель перемещения автомо­
биля или автомобильный симулятор. Несмотря на то, что на самом деле
перемещается дорога (вниз относительно автомобиля), создается полное
ощущение движения автомобиля. Таким образом, мы написали практи­
чески половину нашей игры. Теперь необходимо создать препятствия,
которые вы потом будете объезжать. Подобно тому, как мы добавляли
класс саг, необходимо добавить новый класс «Obstacle» («Препятствия»).
Проверьте, что вы включили директиву «using» Управляемого DirectX в
этом новом файле кода.
Хотя предполагается использование одного Mesh-объекта для всех
препятствий, было бы интересно внести некоторое разнообразие в спи­
сок препятствий, например, различную форму, тип или цвет препятствий.
Можно использовать или готовую заготовку Mesh-объекта, изменяя его
тип, или материалы для изменения цвета. Таким образом, следует доба­
вить константы и переменные, необходимые для класса obstacle, см. лис­
тинг 6.10.

Листинг 6.10. Константы класса «Obstacle».
// Object constants
private const int NumberMeshTypes = 5;
private const float ObjectLength = 3.Of;
private const float ObjectRadius = ObjectLength / 2.Of;
private const int ObjectStacksSlices = 18;
// obstacle colors
private static readonly Color [] ObstacleColors = (
Color.Red, Color.Blue, Color.Green,
Color.Bisque, Color.Cyan, Color.DarkKhaki,

Глава 6. Использование DirectX для программирования игр 125
Color.OldLace, Color.PowderBlue, Color.DarkTurquoise,
Color.Azure, Color.Violet, Color.Tomato,
Color.Yellow, Color.Purple, Color.AliceBlue,
Color.Honeydew, Color.Crimson, Color.Firebrick };
// Mesh information
private Mesh obstacleMesh = null;
private Material obstacleMaterial;
private Vector3 position;
private bool isleapot;

Как видно из первой константы, имеются пять различных типов Mesh-
объектов (сфера, куб, тор, цилиндр, и заварочный чайник, соответствен­
но, sphere, cube, torus, cylinder и teapot). Большинство этих типов будут
иметь или параметр длины, или параметр радиуса, которыми можно ва­
рьировать для изменения размера препятствия. Существуют также до­
полнительные параметры Mesh-объекта (пачки, наборы, сектора, кольца
и т.д), которые управляют числом полигонов (треугольники можно отне­
сти к простейшим полигонам), составляющих объект. За это отвечает
последняя константа в списке — ObjectStacksSlices. При увеличении зна­
чения этой константы растет число используемых полигонов, а следова­
тельно, и качество картинки.
Далее идет список цветов для Mesh-объекта. Мы беспорядочно выб­
рали несколько цветов и включили их в список. Обратите внимание, что
мы не сохраняем в этом классе ни массив материалов, ни текстуры для
наших объектов. Как известно, заданный по умолчанию тип Mesh содер­
жит только одно подмножество без текстур или материалов, поэтому эта
дополнительная информация не нужна.
Поскольку препятствия «лежат» на движущейся дороге, необходимо
согласовать перемещение препятствия с мировой системой координат.
Необходимо связывать положение препятствия, которое будет изменять­
ся с каждым кадром, с дорогой. Поэтому, поскольку мы не можем конт­
ролировать размер объекта «teapot», выбранного в качестве Mesh-объек­
та, в процессе его создания необходимо применить метод масштабирова­

ния.

Замените конструктор класса obstacle на следующий:

public Obstacle(Device device, float x, float y, float z)

{

// Store our position
position = new Vector3(x, y, z);
// It's not a teapot
isTeapot = false;
// Create a new obstacle
switch (Utility.Rnd.Next(NumberMeshTypes))

{

126 Часть I. Введение в компьютерную графику

case 0:

obstacleMesh = Mesh.Sphere(device, ObjectRadius, ObjectStacksSlices,

ObjectStacksSlices);

break;
case 1:
obstacleMesh = Mesh.Box(device, ObjectLength, ObjectLength,

ObjectLength);

break;
case 2:
obstacleMesh = Mesh.Teapot(device) ;
isTeapot = true;
break;
case 3:
obstacleMesh = Mesh.Cylinder(device, ObjectRadius, ObjectRadius,
ObjectLength,ObjectStacksSlices, ObjectStacksSlices);
break;
case 4:
obstacleMesh = Mesh.Torus(device, ObjectRadius / 3.0f, ObjectRadius / 2.Of,
ObjectStacksSlices, ObjectStacksSlices) ;
break;

}

// Set the obstacle color
obstacleMaterial = new Material();
Color objColor = ObstacleColors[Utility.Rnd.Next(ObstacleColors.Length)];
obstacleMaterial.Ambient = objColor;
obstacleMaterial.Diffuse = objColor;

}
Обратите внимание на использование здесь функции Rnd из модуля
утилит. Исходник этой функции включен в CD диск. Ее задача заключа­
ется в том, чтобы просто возвращать случайные числа. Конструктор для
нашего препятствия сохраняет заданное по умолчанию местоположение
препятствия и значения по умолчанию для объекта Mesh. Затем он слу­
чайным образом выбирает один из типов Mesh-объекта и создает его.
Наконец, он выбирает случайный цвет из списка и использует его как
цвет материала для препятствий.
Прежде чем включить препятствие в движок игры, необходимо учесть
пару моментов. Сначала необходимо создать функцию, которая изменяет
положение объекта в соответствии с положением дороги, для этого доба­
вим следующий код:

public void Update(float elapsedTime, float speed)

{

position.Z += (speed * elapsedTime);

}

Глава 6. Использование DirectX для программирования игр 127
Снова используется параметр «elapsed time», чтобы обеспечить и со­
гласовать различные скорости перемещений. Также пересылается теку­
щее значение скорости дороги, чтобы совместить перемещение объекта
и дороги. Для отображения перемещения препятствия необходимо ис­
пользовать процедуру рендеринга. Добавьте метод, приведенный в лис­
тинге 6.11, к классу obstacle.

Листинг 6.11. Рисование препятствий.
public void Draw(Device device)
(
if (isTeapot)

{

device.Transform.World = Matrix.Scaling(ObjectRadius, ObjectRadius,
ObjectRadius)
* Matrix.Translation(position);

}

else

{

device.Transform.World = Matrix.Translation(position);

}

device.Material = obstacleMaterial;

device.SetTexturefO, null);

obstacleMesh.DrawSubset(O);

}
Поскольку Mesh-объект «teapot» после создания не масштабируется
(если вы рисуете один из этих объектов), необходимо сначала смасшта-
бировать этот объект и уже затем переместить его в соответствующую
позицию. Затем устанавливается материал для цвета объекта, присваива­
ется значение «null» для текстуры, и рисуется Mesh-объект.
• Очевидно, потребуется иметь не одно препятствие на дороге. Поэто­
му нам понадобится простой метод добавления и удаления препятствий.
Использование массива возможно, но нецелесообразно, поскольку нео­
днократное изменение размера массива несколько громоздко. Лучше со­
здать класс-коллекцию для хранения данных о препятствиях. Добавьте
класс, приведенный в листинге 6.12, в конец вашего файла с кодом пре­

пятствия.

Листинг 6.12. Класс-коллекция Препятствий, класс obstacles.
public class Obstacles : IEnumerable

{

private ArrayList obstacleList = new ArrayList();

128 Часть I. Введение в компьютерную графику

///
/// Indexer for this class
///

public Obstacle this[int index]

{

get

{
return (Obstacle)obstacleList[index] ;
}

// Get the enumerator from our arraylist
public IEnumerator GetEnumeratorO

{

return obstacleList.GetEnumerator();

}

///
/// Add an obstacle to our list
///

/// The obstacle to add
public void Add(Obstacle obstacle)

{

obstacleList.Add(obstacle);

}

///
/// Remove an obstacle from our list
///

/// The obstacle to remove
public void Remove(Obstacle obstacle)

{

obstacleList.Remove(obstacle);

}

///
/// Clear the obstacle list
///

public void Clear()

{

obstacleList.ClearO ;

}
}
Для правильной компиляции необходимо поместить директиву «using»
для System.Collections в самом начале файла кода для этого класса. Этот
класс имеет индексированный прямой доступ к объекту препятствия, а
также метод перебора и следующие три действия: добавление, удаление
и очистка, соответственно, add, remove и clear. Имея эти базовые возмож­
ности, можно приступить к добавлению объекта препятствия.

Глава 6. Использование DirectX для программирования игр 129
Сначала необходимо внести переменную, которую можно использо­
вать для поддержки списка текущих препятствий в сцене. Добавьте сле­
дующую переменную в класс DodgerGame:

// Obstacle information
private Obstacles obstacles;

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

образом:

///
/// Add a series of obstacles onto a road section
///

/// Minimum depth of the obstacles
private void AddObstacles(float minDepth)

{

// Add the right number of obstacles
int numberToAdd = (int)((RoadSize / car.Diameter - 1) / 2.0f);
// Get the minimum space between obstacles in this section
float minSize = ((RoadSize / numberToAdd) - car.Diameter) / 2.Of;
for (int i = 0; i < numberToAdd; i++)

{

// Get a random # in the min size range
float depth = minDepth - ((float)Utility.Rnd.NextDouble() * minSize);
// Make sure it's in the right range
depth -= (i * (car.Diameter * 2));
// Pick the left or right side of the road
float location = (Utility.Rnd.Next (50) >

25) ?RoadLocationLeft:RoadLocationRight;

// Add this obstacle
obstacles.Add(new Obstacle(device, location, ObstacleHeight, depth));

}

}
Эта функция является отправной точкой для создания препятствий в
игре. Вначале она вычисляет число препятствий, которые необходимо
добавить в данной дорожной секции. Необходимо убедиться в том, что
между препятствиями имеется достаточно пространства для автомоби­
ля. После того как функция определит число препятствий и минималь­
ное пространство между ними, она случайным образом помещает их в
участок дороги, после чего добавляет их к текущему списку препятствий.
Обратите внимание на константу ObstacleHeight, высоту препятствия,
используемую при создании нового препятствия:

private const float ObstacleHeight = Car.Height * 0.S5f;

-•
IIK 604

130 Часть I. Введение в компьютерную графику
Осталось сделать три вещи перед тем, как препятствия появятся в сце­
не: необходимо добавить обращение к методу добавления препятствий,
необходимо убедиться, что функция обновления вызывается для каждо­
го препятствия в сцене, и необходимо отобразить препятствия на экране.
Кроме того, для сброса переменных при запуске новой игры необходимо
создать соответствующую функцию и использовать данный алгоритм при
первом вызове метода AddObstacles. Добавьте метод, приведенный в ли­
стинге 6.13.

Листинг 6.13. Загрузка игровых опций, заданных по умолчанию.
///
/// Here we will load all the default game options
///

private void LoadDefaultGameOptions()

{

// Road information
RoadDepthO = O.Of;
RoadDepthl = -100.Of;
RoadSpeed = 30.Of;
// Car data information
car.Location = RoadLocationLeft;
car.Speed = 10.Of;
car.IsMovingLeft = false;
car.IsMovingRight = false;
// Remove any obstacles currently in the game
foreach(Obstacle о in obstacles)

{

// Dispose it first

o. Disposed;

}

obstacles. Clear d;
// Add some obstacles

AddObstacles(RoadDepthl);

// Start our timer

Utility.Timer(DirectXTimer.Start);

}

Этот метод принимает различные значения переменных, которые мож­

но при необходимости установить по умолчанию. Он также принимает
любые существующие препятствия, находящиеся в списке, располагает
их и очищает список перед заполнением новыми препятствиями. И нако­
нец, он запускает таймер, после чего необходимо добавить вызов создан­
ной функции после создания устройства в методе InitializeGraphics. He

Глава 6. Использование DirectX для программирования игр 131
добавляйте (!) эту функцию в метод OnDeviceReset; мы хотим вызывать
эту функцию, только когда начинается новая игра.

// Load the default game options

LoadDefaultGameOptions () ;

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

OnFrameUpdate:

// Move our obstacles
foreach(Obstacle о in obstacles)

{

// Update the obstacle, check to see if it hits the car
o.Update(elapsedTime, RoadSpeed);

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

// Draw any obstacles currently visible
foreach(Obstacle о in obstacles)

{

o.Draw(device);

}

Теперь попытаемся запустить игру! Вы проехали часть дороги (есте­
ственно, перемещая саму дорогу), проехали несколько препятствий, что
дальше? После этих нескольких препятствий больше ничего не появля­
ется. Вспомните, метод AddObstacles добавляет препятствия только к
одной секции дороги! Таким образом, перемещая дорожные секции, мы
не вызываем повторно метод создания препятствий для этих «новых»
дорожных секций. Перепишите секцию кода, который используется для
добавления новых дорожных секций, следующим образом:

// Check to see if we need to cycle the road
if (RoadDepthO > 75.Of)

{

RoadDepthO = RoadDepthl - 100.Of;

AddObstacles(RoadDepthO);

}
if (RoadDepthl > 75.Of)

{

132 Часть I. Введение в компьютерную графику

RoadDepthl = RoadDepthO - 100.Of;

AddObstacles(RoadDepthl);

}

Теперь это выглядят более реалистично. У нас есть автомобиль, пере­
мещающийся мимо препятствий (пока проносясь через препятствия). К
самим препятствиям также можно добавить движение, например, заста­
вить их вращаться. Для этого вначале необходимо добавить несколько
новых переменных к классу obstacle, чтобы управлять вращением пре­

пятствий:

// Rotation information
private float rotation = 0;
private float rotationspeed = 0.Of;
private Vector3 rotationVector;

Скорость, с которой они вращаются, и оси вращения должны выби­
раться случайным образом. Это легко осуществить, добавляя следующие
строки в конец конструктора класса obstacle:

rotationspeed = (float)Utility.Rnd.NextDouble() * (float)Math.PI;
rotationVector = new Vector3( (float)Utility.Rnd.NextDouble() ,

(float) Utility.Rnd.NextDouble(), (float) Utility.Rnd.NextDouble ()) ;

Осталось два момента, необходимых для того, чтобы задать правиль­
ное вращение препятствиям. Для начала необходимо включить враще­
ние в функцию обновления (update function) следующим образом:

rotation += (rotationspeed * elapsedTime);

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

if (isTeapot)

{

device.Transform.World = Matrix.RotationAxis(rotationVector, rotation)
* Matrix.Scaling(ObjectRadius, ObjectRadius, ObjectRadius)
* Matrix.Translation(position);

}
else

{

device.Transform.World = Matrix.RotationAxis(rotationVector, rotation)
* Matrix.Translation(position);

}

Глава 6. Использование DirectX для программирования игр 133
Теперь, при запуске игры, видны препятствия, беспорядочно враща­
ющиеся по мере увеличения или уменьшения скорости автомобиля. Ка­
ков следующий шаг? Необходимо добавить опции, позволяющие отсле­
живать состояние игры и текущий счет, который необходимо обнулять в
начале новой игры и увеличивать после удачного прохождения препят­
ствия. Добавьте следующие значения переменных объекта к движку игры
«main» в классе DodgerGame:

// Game information
private bool isGameOver = true;
private int gameOverlick = 0;
private booi hasGameStarted = false;
private int score = 0;

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

car.IsMovingRight = false;

score = 0;
В методе OnFrameUpdate до того момента, как вы начинаете переме­
щать препятствия, добавьте следующий код:

// Remove any obstacles that are past the car
// Increase the score for each one, and also increase
// the road speed to make the game harder.
•Obstacles removeObstacles = new Obstacles));
foreach(Obstacle о in obstacles)

{

if (o.Depth > car.Diameter - (Car.Depth * 2))
(
// Add this obstacle to our list to remove

removeObstacles.Add(o);

// Increase roadspeed
RoadSpeed += RoadSpeedlncrement;
// Make sure the road speed stays below max
if (RoadSpeed >= MaximumRoadSpeed)

{

RoadSpeed = MaximumRoadSpeed;

}

// Increase the car speed as well

134 Часть I. Введение в компьютерную графику

car.IncrementSpeed();

// Add the new score
score += (int)(RoadSpeed * (RoadSpeed / car.Speed));

}

}

// Remove the obstacles in the list
foreach(Obstacle о in removeObstacles)

{

obstacles.Remove(o);

// May as well dispose it as well
o.Disposed ;

}

removeObstacles.Clear();

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

та с учетом текущей скорости перемещения дороги или автомобиля. После

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

///
/// Increment the movement speed of the car
///

public void IncrementSpeed()

{

carSpeed += Speedlncrement;

}
Теперь следует добавить в класс obstacle новый метод для определе­
ния момента, когда автомобиль врезается в одно из препятствий:

public bool IsHittingCar(float carLocation, float carDiameter)

{

// In order for the obstacle to be hitting the car,
// it must be on the same side of the road and
// hitting the car
if (position.Z > (Car.Depth - (carDiameter / 2.0f)))

{

// are we on the right side of the car
if ((carLocation < 0) && (position.X < 0))
return true;
if ((carLocation > 0) && (position.X > 0))
return true;

Глава 6. Использование DirectX для программирования игр 135
}
return false;
}
Довольно просто. Вы выясняете, если автомобиль находится в той же
самой глубине секции и с той же самой стороны дороги, что и препят­
ствие, это означает столкновение с препятствием, и возвращается значе­
ние «true». В противном случае возвращается значение «false», автомо­
биль успешно преодолевает препятствие. Теперь необходимо вставить
этот код в движок игры. Замените код обновления препятствия более со­
вершенным кодом:

// Move our obstacles
foreach(Obstacle о in obstacles)
(
// Update the obstacle, check to see if it hits the car
o.Update(elapsedTime, RoadSpeed) ;
if (o.IsHittingCar(car.Location, car.Diameter))

{

// If it does hit the car, the game is over.

isGameOver = true;
gameOverTick = System.Environment.TickCount;
// Stop our timer

Utility.Timer(DirectXTimer.Stop);

}
}
Теперь, после того как вы «обнаружили» столкновение с препятстви­
ем, игра заканчивается. Вы фиксируете состояние игры и останавливаете

таймер.

Последние штрихи

На данный момент мы ничего не делаем с переменными состояния. В
первую очередь осуществляем логику окончания игры. Очередной запуск
игры необходимо привязать к нажатию любой клавиши. Для этого после
окончания игры (случай, когда мы потерпели неудачу) выполняется неболь­
шая пауза (около одной секунды), и затем нажатие любой клавиши запуска­

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

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

// Nothing to update if the game is over
if ((isGameOver) || (!hasGameStarted))
return;

136 Часть I. Введение в компьютерную графику
Теперь необходимо обработать нажатия клавиш, чтобы перезапустить
игру. В конец перегрузки OnKeyDown Вы можете добавить следующую
логику:
if (isGameOver)
{
LoadDefaultGameOptions();

}

// Always set isGameOver to false when a key is pressed
isGameOver = false;
hasGameStarted = true;

Это и есть поведение, которого мы добивались. Теперь после оконча­
ния игры игрок нажимает клавишу, и новая игра начинается с заданных
по умолчанию игровых опций. При желании вы можете удалить вызов
опции LoadDefaultGameOptions из метода InitializeGraphics, поскольку она
будет вызываться автоматически после нажатия клавиши. Однако, у нас
пока нет кода, который вызовет небольшую паузу после прекращения
игры. Вы можете поместить его в процедуру OnKeyDown или сразу пос­
ле проверки нажатия клавиши «Escape»:

// Ignore keystrokes for a second after the game is over
if ((System.Environment.TickCount - gameOverTick) < 1000)

{
return;

}

Выполнение данных строк игнорирует любые нажатия клавиши (кроме
клавиши выхода Escape) в течение одной секунды после того, как игра за­
кончена. Теперь вы можете приступить к игре. Хотя можно еще добавить
дополнительный текст, отображающий состояние игры или некоторые ком­

ментарии. В составе имен («namespace») приложения Direct3D имеется класс

шрифтов («Font class»), который может использоваться для отображения тек­

ста, однако, Font class имеется и в пространстве имен System.Drawing. Эти
два класса будут конфликтовать, если вы попытаетесь использовать «Font»
без идентификации. К счастью, вы можете переименовать данный объект,
используя директиву «using» следующим образом:

using Direct3D = Microsoft.DirectX.Direct3D;

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

Глава 6. Использование DirectX для программирования игр 137

// Fonts
private Direct3D.Font scoreFont = null;
private Direct3D.Font gameFont = null;

Необходимо инициализировать эти переменные, и важно, чтобы это
было сделано после создания устройства. Нет необходимости делать это
в методе OnDeviceReset, поскольку эти объекты автоматически обрабо­
тают сброс устройства. Добавьте следующие строки в конце метода

InitializeGraphics:

// Create our fonts
scoreFont = new Direct3D.Font (device, new System.Drawing.Font("Arial",

12.Of,

FontStyle.Bold));

gameFont = new Direct3D.Font(device, new System.Drawing.Font("Arial",

36.Of,

FontStyle.Bold ! FontStyle.Italic));

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

if (hasGameStarted)

{

// Draw our score
scoreFont.DrawText (null, string. Format ("Current score: (Of, score),
new Rectangle(5,5,0,0), DrawTextFormat.NoClip, Color.Yellow) ;

}

if (isGameOver)

{

// If the game is over, notify the player
if (hasGameStarted)

{

gameFont.DrawText (null, "You crashed. The game is over.", new

Rectangle(25,45,0,0),

DrawTextFormat.NoClip, Color.Red);

}

if ((System.Environment.TickCount - gameOverTick) >= 1000)

{

// Only draw this if the game has been over more than one second
gameFont.DrawText(null, "Press any key to begin.", new

Rectangle(25,100,0,0),

DrawTextFormat.NoClip, Color.WhiteSmoke);

}
}

138
Часть 1. Введение в компьютерную графику

Алгоритм отображения текста DrawText будет обсуждаться подроб­

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

информацию, например: текущий счет, сообщение о неудаче, сообщение

о начале игры после нажатия любой клавиши и т.д.

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

запустить ее, фиксировать изменение счета, конец игры, неудачу, и затем

начать игру сначала. Что осталось? Хорошо было бы сохранять лучший

результат, который бы постоянно пересохранялся при более высоком ре­

зультате.

ДОБАВЛЕНИЕ КОММЕНТАРИЯ

«High Scores» — наилучший результат

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

игры:

///
/// Structure used to maintain high scores
///

public struct HighScore
(

private int realScore;
private string playerName;
public int Score { get { return realScore; } set ( realScore = value; 1 }
public string Name { get { return playerName; } set ( playerName = value; ) }

I

Дальше необходимо установить список результатов «high scores» в
нашем движке игры. Мы рассмотрим формирование списка только
для трех игроков, используя при этом массив для хранения этих
данных. Добавьте следующие строки в движок игры:

// High score information
private HighScore[] highScores = new HighScore[3] ;
private string defaultHighScoreName = string.Empty;

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

Глава 6. Использование DirectX для программирования игр 139

///
/// Check to see what the best high score is. If this beats it,
/// store the index, and ask for a name
///

private void CheckHighScore()

{

int index = -1;
for (int i = highScores.Length - 1; i >= 0; i—-)

{

if (score >= highScores[i].Score) // We beat this score

{

index = i;

}

}

II We beat the score if index is greater than 0
if (index >= 0)

{

for (int i = highScores.Length - 1; i > index ; i—-)

{

// Move each existing score down one
highScores[i] = highScores [i-1];

}

highScores[index].Score = score;
highScores[index].Name = Input.InputBox("You got a high score!!",
"Please enter your name.", defaultHighScoreName);

}
}

///
/// Load the high scores from the registry
///

private void LoadHighScores()

{

Microsoft.Win32.RegistryKey key =
Microsoft.Win32.Registry.LocalMachine.CreateSubKey(

"Software\\MDXBoox\\Dodger") ;

try

{

for (int i = 0; i < highScores.Length; i++)

{

highScores[i].Name = (string)key.GetValue(
string.Format("Player{0}", i), string.Empty);
highScores[i].Score = (int)key.GetValue(
string.Format("Score(O)", i), 0);

}

defaultHighScoreName = (string)key.GetValue(
"PlayerName", System.Environment.UserName);

}

140
Часть I. Введение в компьютерную графику

finally

{

if (key != null)
(
key.Closed; // Make sure to close the key

}

}
}
///
/// Save all the high score information to the registry
///

public void SaveHighScores ()

{

Microsoft.Win32.RegistryKey key =
Microsoft.Win32.Registry.LocaiMachine.CreateSubKey(

"Software\\MDXBoox\\Dodger");

try

{

for(int i = 0; i < highScores.Length; it++)

{

key.SetValue(string.Format("Player{0}", i), highScores[i].Name);
key.SetValue(string.Format("Score{O}", i), highScores[i].Score);

}

key.SetValue("PlayerName", defaultHighScoreName);

}

finally
{

if (key != null)

{

key.Close(); // Make sure to close the key

}
}
}
He будем слишком глубоко вникать в конструкцию этих функций, по­
скольку они имеют дело главным образом со встроенными класса­
ми .NET и не воздействуют на код Управляемого DirectX. Однако,
важно показать, откуда эти методы вызываются в движке игры.
Проверка значения для «high scores» должна производиться сразу
после окончания игры. Замените код в методе OnFrameUpdate, ко­
торый проверяет факт столкновения автомобиля с препятствием,
на следующий:

if (о.IsHittingCar(car.Location, car.Diameter))

{

Глава 6. Использование DirectX для программирования игр 141
// If it does hit the car, the game is over.
isGameOver = true;
gameOverTick = System.Environment.TickCount;
// Stop our timer

Utility.Timer(DirectXTimer.Stop);

// Check to see if we want to add this to our high scores list

CheckHighScore();

}
Вы можете загружать значение «high scores» в конце конструктора
основного движка игры. Следует отметить, что алгоритм сохране­
ния является общим (тогда как другие методы являются индивиду­
альными). Поэтому мы будем вызывать его из нашего основного
кода. Перепишите основной метод «main»:

using (DodgerGame frm = new DodgerGame())

{

// Show our form and initialize our graphics engine

frm.Show();

frm.InitializeGraphics();

Application.Run(frm);

// Make sure to save the high scores
frm.SaveHighScoresO ;

}
И заключительный момент действия — отображение на экране спи-
сак наилучших результатов. Мы добавим его в наш код рендеринга.
До того как вызвать окончательный метод для нашего текста, доба­
вим к секции кода рендеринга надписи «High scores» следующие

строки:

// Draw the high scores
gameFont.DrawText(null, "High Scores: ", new Rectangle(25,155,0,0),
DrawTextFormat.NoClip, Color.CornflowerBlue);
for (int i = 0; i < highScores.Length; i++)

{

gameFont.DrawText(null, string.Format("Player; {0} : {1}",
highScores[i].Name,

highScores[i].Score),

new Rectangle(25,210 + (i * 55),0,0), DrawTextFormat.NoClip,
Color.CornflowerBlue);

}

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

142 Часть I. Введение в компьютерную графику

Краткие выводы

В этой главе мы проделали следующее.
Использовали объекты Mesh для рендеринга игровых объектов.
• Проверили некоторые возможности устройства.
• Освоили простейший пользовательский ввод.
• Создали систему подсчета очков.
• Объединили все в общую конструкцию.
Результаты игры приведены на рис. 6.1.

Рмс.б.1. Завершенная игра

В следующей главе мы обсудим использование более совершенных
возможностей и свойств mesh-объектов.

ЧАСТЬ II

ОСНОВНЫЕ КОНЦЕПЦИИ

ПОСТРОЕНИЯ ГРАФИКИ

Глава 7. Использование дополнительных свойств
и возможностей Mesh-объектов
Глава 8. Введение в ресурсы
Глава 9. Применение других типов Mesh
Глава 10. Использование вспомогательных классов

144 Часть II. Основные концепции построения графики

Глава 7. Использование

дополнительных свойств

и возможностей Mesh-объектов

В данной главе мы обсудим более широкие возможности применения
объектов «Mesh», включая.
• Оптимизацию данных Mesh-объекта.
• Упрощение Mesh-объектов.
• Создание Mesh с новыми компонентами данных о вершинах.
• Объединение вершин.

Создание копий Mesh-объектов

На данном этапе изучения книги мы имеем возможность загружать
Mesh-объекты и отображать их на экране. Наша сцена имеет несколько
источников света, и, тем не менее, объекты кажутся темными. Рассмат­
ривая свойства объектов, можно заметить, что вершинные форматы не
включают данные нормалей к поверхностям, необходимые для вычисле­
ния более реалистичного освещения.
В данном случае необходимо взять все имеющиеся данные Mesh-объек­
та и добавить к ним данные нормалей. Механизм для осуществления дан­
ной операции приведен в листинге 7.1:

Листинг 7.1. Добавление нормалей к Mesh-объекту.
// Check if mesh doesn't include normal data
if ((mesh.VertexFormat & VertexFormats.Normal) != VertexFormats.Normal)
(
Mesh tempMesh = mesh.Clone(mesh.Options.Value,
mesh.VertexFormat | VertexFormats.Normal, device);
tempMesh.ComputeNormals();
// Replace existing mesh
mesh.Disposed ;
mesh = tempMesh;

}

Здесь мы берем существующий Mesh-объект и определяем, содержит
ли он данные нормалей или нет. Значение вершинного формата
VertexFormat возвращает список параметров VertexFormats, которые объе­
динены через логический оператор «ИЛИ», поэтому мы используем опе­
ратор «И», чтобы определить, установлен ли бит нормали. В случае если
он не установлен, мы создаем с помощью функции Clone второй, вре-

Глава 7. Использование свойств и возможностей Mesh-объектов 145

менный Mesh-объект, являющийся копией первоначального объекта. Дан­

ный метод имеет три варианта загрузки:

public Microsoft.DirectX.Direct3D.Mesh Clone (
Microsoft.DirectX.Direct3D.MeshFlags options ,
Microsoft.DirectX.Direct3D.GraphicsStream declaration ,
Microsoft.DirectX.Direct3D.Device device )
public Microsoft.DirectX.Direct3D.Mesh Clone (
Microsoft.DirectX.Direct3D.MeshFlags options ,
Microsoft.DirectX.Direct3D.VertexEleraent[] declaration ,
Microsoft.DirectX.Direct3D.Device device )
public Microsoft.DirectX.Direct3D.Mesh Clone (
Microsoft.DirectX.Direct3D.MeshFlags options ,
Microsoft.DirectX.Direct3D.VertexFormats vertexFormat ,
Microsoft.DirectX.Direct3D.Device device )

В нашем примере мы использовали последнюю перегрузку. В каж­
дой из перегрузок, первые и последние параметры — те же самые. Па­
раметр опций — options позволяет вновь созданному Mesh-объекту
иметь различный набор дополнительных опций. Вы можете сохранить
те же самые опции в новом объекте-копии (то, что мы делали ранее), а
можете изменить их. Было бы предпочтительнее, чтобы новый Mesh-
объект постоянно находился в системной памяти, нежели в управляе­
мой памяти. Любой из указателей MeshFlags, которые являются дос­
тупными при создании объекта, также доступны в течение операции
создания копии.
Последний параметр метода Clone device — устройство, на базе кото­
рого будет создан новый объект. В большинстве случаев это будет то же
самое устройство, которое вы создаете для первоначального объекта, но
возможно также и создание копий объекта под абсолютно различные ус­
тройства. Например, скажем, вы написали приложение, которое было
рассчитано на несколько мониторов, каждый из которых работал в пол­
ноэкранном режиме. Если Mesh-объект отображался на первом монито­
ре, не было необходимости иметь «экземпляр» этого объекта на втором.
При желании отобразить объект на втором мониторе, вы можете легко
продублировать его (или другими словами создать и отобразить копию
объекта) на новое устройство и иметь к нему доступ. Наш предыдущий
пример просто использовал уже имеющееся в наличии устройство.
Параметр declaration в процедуре Clone определяет, каким образом
данные будут отображаться на экране. В используемом нами варианте
мы пропускаем описание вершинного формата вновь созданной копии
объекта (которая может отличаться от оригинала). В других перегрузках

146
Часть II. Основные концепции построения графики

данный параметр предназначен для определения вершин (Vertex
declarations) созданного объекта.
Как вы можете видеть, это — вспомогательная функция класса Mesh,
которая может автоматически вычислять нормали Mesh-объектов. В не­
используемых нами вариантах загрузки присутствует параметр, который
используется для ввода информации, имеющий вид массива целых чисел
или потока GraphicsStream.
Вы можете использовать возможность создания копии объекта в це­
лях создания новых экземпляров того же Mesh-объекта для нового уст­
ройства или изменять опции уже созданного объекта. Вы можете также
использовать это для создания объекта с новыми значениями формата
вершины, или даже удалять существующие данные формата вершины из
вашего Mesh-объекта. Если объект, который есть на данный момент, не
удовлетворяет вашим требованиям, вы можете имитировать его, создав
копию, и изменить эту копию по необходимости.

Оптимизация данных Mesh-объекта

Создание копии Mesh-объекта — не единственный способ расширить
свойства имеющегося объекта. Существует еще несколько способов оп­
тимизации Mesh-обьектов. Функция Optimize для объекта похожа на ме­
тод создания копии, описанный выше (данная функция позволяет созда­
вать новый Mesh-объект с различными опциями), однако, она может так­
же выполнять оптимизацию в процессе создания нового объекта. Следу­
ет отметить, что мы не можем использовать функцию Optimize для до­
бавления или удаления вершинных данных или для дублирования их под
новое устройство. Рассмотрим основную перегрузку метода Optimize:

public Microsoft.DirectX.Direct3D.Mesh Optimize (
Microsoft.DirectX.Direct3D.MeshFlags flags ,
int[ ] adjacencyln , out int[ ] adjacencyOut ,
out int[ ] faceRemap ,
out Microsoft.DirectX.Direct3D.GraphicsStream vertexRemap )

Каждая из четырех перегрузок этого метода принимает одинаковый
набор аргументов, или просто флажков и вводимых данных. Обратите
внимание, что параметр adjacencyln может использоваться или как мас­
сив целых чисел (как показано выше), или как поток данных Graphics-

Stream.

Параметр флажков используется, чтобы определить, каким может быть

создан новый объект. Данный параметр может иметь разное количество
флажков из списка MeshFlags (за исключением флажков Use32Bit или
WriteOnly). Флажки Optimize, которые могут использоваться специаль­
ным образом для этой функции, приведены в таблице 7.1:

Глава 7. Использование свойств и возможностей Mesh-объектов 147
Таблица 7.1. Функции оптимизации Mesh-объекта

MeshFlags.OptimizeCompact
Переупорядочивает поверхности в Mesh-объекте, чтобы удалить неиспользованные вершины и
поверхности

MeshFlags.OptimizeAttrSort Переупорядочивает поверхности в Mesh-объекте так, чтобы иметь меньшее количество изменений состояния аттрибута, который может улучшить выполнение DrawSubset
MeshFlags.OptimizeDevicelndependent Использование этой функции затрагивает размер кэша вершины, определяя заданный по умолчанию размер кэша, и обеспечивает достаточно эффективное выполнение на используемых аппаратных
средствах

MeshFlags.OptimizeDoNotSplit
Использование этого флажка определяет, что вершины не должны быть разбиты в случае, если они распределены между группами
атрибутов

MeshFlags.Optimizelgnore Verts
Оптимизирует только поверхности, игнорируя вершины

MeshFlags.OptimizeStripeReorder
Использование этого флажка переупорядочивает поверхности, чтобы максимизировать длину смежных треугольников или
полигонов

MeshFlags. Optimize VertexCache
Использование этого флажка переупорядочивает поверхности для увеличения скорости кэширования
вершины

ОПТИМИЗАЦИЯ MESH-ОБЪЕКТОВ НА МЕСТЕ

Что если вы не хотите создавать новый Mesh-объект целиком? Вы
не хотите изменять различные флажки в процессе создания, вы
только хотите использовать преимущества, полученные при опти­
мизации объекта.
Существует похожий метод для Mesh-объекта, называемый
OptimizelnPlace, который принимает те же самые параметры, толь­
ко с двумя различиями. Флаговый параметр должен быть одним из

148 Часть II. Основные концепции построения графики

флажков оптимизации (вы не можете изменять ни один из флажков

создания), и еще, этот метод не имеет возвращаемого значения.

Все оптимизации будут проходить непосредственно для объекта,

из которого вызывается данная процедура.

Также понадобится параметр AdjacencyIn, он может быть представ­
лен в виде целочисленного массива, включающего в себя три целых чис­
ла на каждую сторону, которые определяют трех смежных «соседей» каж­
дой поверхности в объекте, или же в виде потока графических данных, в
котором содержится та же самая информация.
Если вы выбираете одну из двух последующих перегрузок, последние
три параметра в ней представляют те данные, которые будут возвращены
вам посредством параметра out. Первым значением этих возвращенных
данных будет новая информация смежности. Второе значение — новый
индекс для каждой поверхности в объекте. Последним значением будет
графический поток, который содержит новый индекс для каждой верши­
ны. Многие из приложений не потребуют этой информации и пропустят
эти функции.
Следующая небольшая секция кода показывает сортировку объекта с
использованием буфера атрибутов и обеспечивает его размещение в уп­
равляемой памяти:
// Compact our mesh
Mesh tempMesh = mesh.Optimize
(MeshFlags.Managed |
MeshFlags.OptimizeAttrSort |
MeshFlags.OptimizeDoNotSplit, adj) ;

mesh.Dispose();

mesh = tempMesh;

ФОРМИРОВАНИЕ ИНФОРМАЦИИ СМЕЖНОСТИ

Обратите внимание, что многие из более совершенных методов

Mesh используют информацию смежности. Вы можете получить эту

информацию в процессе создания Mesh-объекта. Но если объект

уже создан, то для получения этой информации существует функ­

ция GenerateAdjacency. Первый параметр этой функции — число с

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

определить те вершины, местоположение которых отличается ме­

нее чем на это значение, как смежные или совпадающие вершины.

Второй параметр— целочисленный массив, который будет запол­

нен информацией смежности. Этот массив должен иметь размер

по крайней мере 3 * mesh.NumberFaces.

Глава 7. Использование свойств и возможностей Mesh-объектов 149

Упрощение существующих Mesh-объектов

Теперь предположим, что ваш художник только что нарисовал вам
некоторый объект в вашей сцене, который находится в различных поло­
жениях в зависимости от того, на каком уровне вы находитесь. На неко­
торых уровнях объект располагается на заднем плане и не требует столь
же детальной деталировки, как на других уровнях. Естественно, можно
дать задание художнику, что бы он сделал вам две различные модели, с
высоким и низким качеством деталировки, но есть и более простое ре­
шение — можно использовать некоторые встроенные упрощения для
имеющегося класса Mesh.
Программа упрощения изменяет существующий объект. Суть метода
заключается в том, чтобы, используя набор весовых параметров, попробо­
вать удалить как можно больше поверхностей и вершин объекта для полу­
чения низко-детального объекта. Однако, прежде чем упростить объект,
его необходимо очистить. Для этого добавляют другую вершину, которая
является общей для двух треугольников, расположенных веером (мы уже
рассматривали такой тип примитива). Рассмотрим процедуру Clean:

public static Microsoft.DirectX.Direct3D.Mesh Clean (
Microsoft.DirectX.Direct3D.Mesh mesh ,
Microsoft.DirectX.Direct3D.GraphicsStream adjacency ,
Microsoft.DirectX.Direct3D.GraphicsStream adjacencyOut ,

out System. String errorsAndWarnings )

Обратите внимание, это напоминает более ранние функции. Процедура
аналогичным образом принимает параметр объекта, который мы собира­
емся очистить, и информацию смежности. Однако, помимо этого здесь
требуется параметр смежности adjacencyOut. Наиболее общая методика
должна использовать смежные данные в графическом потоке, который вы
получаете при создании объекта, также как параметры adjacencyIn и
adjacencyOut для очистки. Имеется также возвращаемая строка, которая
позволяет выводить сообщения об ошибках или предупреждениях, с кото­
рыми можно столкнуться при очистке объекта. Следует также обратить
внимание на то, что параметры смежности могут быть или в виде графи­
ческих потоков, как показано выше, или в виде массивов целых чисел.
Чтобы показать последствия выполнения программы упрощения, ис­
пользующей эти методы, можно взять пример, который приводился в
юнце главы 5, и попробовать использовать его как отправную точку для
нашего упрощения. Сначала мы включаем каркасный режим так, чтобы
вы могли видеть эффект (на вершинах он более нагляден). Добавим сле­
дующую строку в функцию SetupCamera:

device.RenderState.FillMode = FillMode.WireFrame;

150 Часть II. Основные концепции построения графики
Затем, как мы уже решили, Mesh-объект должен быть очищен. По­
скольку нам необходимо знать информацию смежности объекта для очи­
стки, мы должны переписать код создания объекта в методе LoadMesh
следующим образом:

ExtendedMaterial [ ] mtrl;
GraphicsStream adj;
// Load our mesh
mesh = Mesh.FromFile(file, MeshFlags.Managed, device, out adj, out mtrl);

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

// Clean our main mesh
Mesh tempMesh = Mesh.Clean(mesh, adj, adj);
// Replace our existing mesh with this one

mesh.Dispose();

mesh = tempMesh;

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

public static Microsoft.DirectX.Direct3D.Mesh Simplify (
Microsoft.DirectX.Direct3D.Mesh mesh ,

int[] adjacency ,

Microsoft.DirectX.Direct3D.AttributeWeights vertexAttributeWeights ,
float [] vertexWeights , System.Int32 minValue ,
Microsoft.DirectX.Direct3D.MeshFlags options )

Структура этого метода должна казаться нам знакомой. Объект Mesh,
который мы собираемся упрощать, представляет собой первый параметр,
параметр смежности adjacency (который может быть определен в виде
массива или в виде графического потока) — последующий.
Параметр AttributeWeights служит для того, чтобы установить различ­
ные коэффициенты, используемые при упрощении объекта. Для большин­
ства приложений следует использовать процедуры, которые не использу­
ют это значение, поскольку заданная по умолчанию структура рассматри­
вает только геометрические данные и данные нормали. Лишь в отдельных
случаях эти значения должны были бы измениться. Значения по умолча­
нию для этой структуры, если вы их не пересылаете, имели бы вид:

AttributeWeights weights = new AttributeWeights() ;
weights.Position = l.Of;
weights.Boundary = l.Of;
weights.Normal = l.Of;

Глава 7. Использование свойств и возможностей Mesh-объектов 151

weights.Diffuse = O.Of;
weights.Specular = O.Of;
weights.Binormal = O.Of;
weights.Tangent = O.Of;
weights.TextureCoordinate = new float[]
(O.Of, O.Of, O.Of, O.Of, O.Of, O.Of, O.Of, O.Of };

Следующий параметр vertexWeights — список весовых коэффициен­
тов для каждой вершины. Если вы пересылаете пустой указатель для этого
параметра, принимается что каждый вес будет равен l.Of.
Далее идет параметр MinValue— минимальное число поверхностей
или вершин (в зависимости от пересылаеых флажков), до которого вы

хотите попробовать упростить объект. Чем меньше это значение, тем менее

детальный объект получится. Однако, следует обратить внимание, что
выбор этого значения не подразумевает реальное минимальное значение,
которое может быть достигнуто. Другими словами, это значение опреде­
ляет желаемый, а не абсолютный минимум.
Последним параметром options для этой функции может быть один из
двух флажков. Если вы хотите упростить число вершин, вы должны за­
писать MeshFlags. Simplify Vertex, иначе используйте MeshFlags. Simplify-

Face.

Теперь необходимо добавить код, чтобы упростить Mesh-объект, ко­
торый мы использовали в нашем примере MeshFile, см. главу 5. Жела­
тельно иметь перед глазами и первоначальный оригинал объекта (очи­
щенный), и упрощенный, а также иметь возможность переключаться от
одного к другому. Таким образом, добавим новое поле, чтобы сохранить
упрощенный объект:

private Mesh simplifiedMesh = null;

Затем необходимо создать упрощенный объект. В конце функции
LoadMesh добавьте следующий код:

II Get our new simplified mesh
simplifiedMesh = Mesh.Simplify(mesh, adj, null, 1,

MeshFlags.SimplifyVertex);

Console.WriteLine("Number of vertices in original mesh: (0}",

mesh.NumberVertices);

Console.WriteLine("Number of vertices in simplified mesh: (0(",
simplifiedMesh.NumberVertices);

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

152 Часть II. Основные концепции построения графики

Number of vertices in original mesh: 4445
Number of vertices in simplified mesh: 391

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

тродействие.

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

private bool isSimplified = false;

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

device.Material = meshMaterials[i];
device.SetTexture (0, meshTextures [i]) ;

if (!isSimplified)

{

mesh.DrawSubset(i) ;

}

else

{

simplifiedMesh.DrawSubset(i);

}
Обратите внимание, что независимо от того, отображаем мы обыч­
ный или упрощенный объект, материал и текстура для обоих остаются
теми же самыми. Разница лишь в том, какой объект мы вызываем в мето­
де DrawSubset. Теперь осталось предусмотреть возможность переключе­
ния нашей логической переменной. Привяжем выполнение этой функ­
ции к нажатию клавиши «Пробел», для этого добавьте следующий код:

protected override void OnKeyPress(KeyPressEventArgs e)
( if (e.KeyChar == '4'

{

isSimplified = !isSimplified;

}
}

Глава 7. Использование свойств и возможностей Mesh-объектов 153
Теперь, когда мы запускаем это приложение, мы видим наш объект,

отображенный в каркасном режиме. Нескольких, имеющихся у этого объек­

та вершин, вполне достаточно для того, чтобы объект выглядел сплош­
ным. Теперь нажмите клавишу «Пробел» и наблюдайте результат удале­
ния вершин. Эффект весьма значительный, но, когда камера расположена
близко к объекту, не совсем лицеприятный. Для управления расстоянием
между камерой и объектом добавьте другую булеву переменную:

private bool isClose = true;

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

if (isClose)

{

device.Transform.View = Matrix.LookAtLH(new Vector3(0,0, 580.Of), new
Vector3(),new Vector3 (0,1,0));

}

else

{

device.Transform.View = Matrix.LookAtLH(new Vector3(0,0, 8580.Of), new

Vector3(),

new Vector3(0,1,0));

}

//device.RenderState.FillMode = FillMode.WireFrame;

Легко заметить, что камера отодвинута от объекта на 8000 единиц на­
зад. Также обратите внимание, что здесь мы выключили каркасный ре­
жим. Поскольку большинство игр не запускаются в каркасном режиме,
?то даст вам более реалистичное представление. Последняя вещь, кото­
рую мы должны сделать, — обеспечить возможность переключать каме­
ру. Для этого мы будем использовать клавишу «М». Добавьте следующие
строки в конце метода OnKeyPress:

if (e.KeyChar == 'm')
isClose = !isClose;

Запустите приложение еще раз. Пока камера расположена близко, на­
жмите несколько раз клавишу «пробел». Затем нажмите клавишу «т»,
чтобы переместить камеру от объекта. Нажмите клавишу «пробел» еще
несколько раз и обратите внимание, что теперь эффект гораздо менее дра­
матичен, а результат упрощения при соответствующем положении каме­
ры имеет вполне терпимое качество изображения. На рис. 7.1 и рис.7.2
можно сравнить исходный и упрощенный объекты.

154 Часть II. Основные концепции построения графики

Рис. 7.1. Близко расположенный объект с исходным высоким разрешением

Рис. 7.2. Далеко расположенный объект с низким разрешением

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

Глава 7. Использование свойств и возможностей Mesh-объектов 155

СОХРАНЕНИЕ MESH-ОБЪЕКТОВ

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

// Save our simplified mesh for later use
// First we need to generate the adjacency for this mesh
int[] simpleAdj = new int[simplifiedMesh.NumberFaces * 3];
simplifiedMesh.GenerateAdjacency(O.Of, simpleAdj);
using (Mesh cleanedMesh = Mesh.Clean (simplifiedMesh,
simpleAdj, out simpleAdj))
cleanedMesh.Save(@"..\..\Asimple.x", simpleAdj,
mtrl, XFileFormat.Text);

Обратите внимание, что мы не получали никакой информации смеж­
ности для нашего упрощенного объекта. Поскольку нам эта инфор­
мация еще понадобится, мы просто сгенерируем эти данные. Не­
обходимо отметить, что после процедуры упрощения необходимо
вначале очистить объект и только потом сохранять. Мы выполняем
это в операторе «using».
Существует восемь различных похожих перегрузок для метода со­
хранения Save. Четыре из них сохраняют данные в поток, с которым
вы затем оперируете, тогда как четыре других сохраняют данные в
файл. Мы выбираем вариант с сохранением в файл. Каждая из пе­
регрузок принимает данные смежности и материалы, используемые
для объекта. Информация смежности может быть еще раз опреде­
лена как массив целых чисел или как графический поток. Половина
перегрузок использует структуру Effectlnstance, имеющую дело с
шейдерными файлами HLSL, которые мы обсудим позже.
Последний параметр функции Save — тип формата файла, который
вы хотите сохранить. Существует текстовый, двоичный и сжатый
формат. Выберите тот, который вас устраивает больше всего.

156 Часть II. Основные концепции построения графики

Объединение вершин в Mesh-объектах

Другой эффективный способ упрощения объекта состоит в том, что­
бы объединить «похожие» или общие вершины. Есть метод в классе mesh,
называемый WeldVertices, используемый для объединения общих вершин,
имеющих одинаковые атрибуты. Прототип метода включает в себя сле­
дующее:

public void WeldVertices ( Microsoft.DirectX.Direct3D.WeldEpsilonsFlags
flags ,

Microsoft.DirectX.Direct3D.WeldEpsilons epsilons ,

Microsoft.DirectX.Direct3D.GraphicsStream adjacencyln ,
Microsoft.DirectX.Direct3D.GraphicsStream adjacencyOut ,
out int[] faceRemap ,
Microsoft.DirectX.Direct3D.GraphicsStream vertexRemap )

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

WeldEpsilonsFlags.WeldAll
Объединяет все вершины, которые отмечены в данных смежности как
перекрываемые

WeldEpsilonsFlags.WeldPartialMatches Если данная вершина находится в пределах значения epsilon, заданного структурой WeldEpsilons, измените частично перекрываемую вершину так, чтобы она стала идентичной, и, если все компоненты будут равны, то удалите одну из вершин

WeldEpsilonsFlags.DoNotRemove Vertices
Может использоваться, только если определена структура WeldPartialMatches. Позволяет только изменение вершины, но не удаление
WeldEpsilonsFlags.DoNotSplit Может использоваться, только если определена структура WeldPartialMatches. He позволяет разбивать вершину

Глава 7. Использование свойств и возможностей Mesh-объектов 157
Структура самого WeldEpsilons очень похожа на структуру Attribute-
Weights, используемую для упрощения объекта. Единственное разли­
чие — есть новый параметр для этой структуры, который управляет фак­
тором мозаичности (tessellation).
Мозаичность объекта — это параметр, характеризующий изменение
уровня детальности объекта путем изменения числа треугольников или
полигонов или путем разбиения отдельного треугольника на два и более.
В дальнейшем, подразумевая мозаичность, мы будем использовать тер­
мин «тесселяция».
Чтобы показать эффект использования этого метода, мы еще раз изме­
ним существующий пример MeshFile с целью объединения его вершин.
Поскольку в действительности это только один вызов, нет необходимости
в составлении громоздкого кода, который мы должны добавить. Мы будем

осуществлять объединение вершин при изначально нажатой клавише «Про­

бел», для этого перепишем метод OnKeyPress следующим образом:

protected override void OnKeyPress(KeyPressEventArgs e)

{

Console.WriteLine("Before: {0}", mesh.NumberVertices);
mesh.WeldVertices(WeldEpsilonsFlags.WeldAU, new WeldEpsilons (), null,

null);

Console.WriteLine("After: {0}", mesh.NumberVertices);

}
Теперь нажатие клавиши «Пробел» приведет к следующему текстово­
му сообщению:

Before: 4432
After: 3422

В итоге мы получили 91 % вершин от начального количества. Это не
'так впечатляет, как в ранее рассмотренном случае, но зато происходит
намного быстрее. Однако, обратили ли вы внимание, как изменились ко­
ординаты текстуры, когда вы нажимали клавишу «пробел»? Это было
вызвано удалением некоторых вершин из общей области. Вблизи это не­
много заметнее, но на расстоянии на это можно не обращать внимания.

ПРОВЕРКА ДОСТОВЕРНОСТИ ВАШЕГО ОБЪЕКТА

Было бы заманчиво иметь способ, позволяющий определить, дей­

ствительно ли ваш объект необходимо очистить, или же он уже го­

тов к оптимизации. Естественно, такой способ есть. Класс Mesh

имеет метод Validate, который имеет четыре варианта загрузки. Вот

один из них:

158 Часть II. Основные концепции построения графики

public void Validate ( Microsoft.DirectX.Direct3D.GraphicsStream adjacency ,

System.String errorsAndWarnings )

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

комментарий.

Использование метода Validate перед любым упрощением или оп­
тимизацией помогает устранять отказы, возникающие при выпол­
нении этих методов.
Создание нескольких объектов из одного

Эффективнее, чем просто удаление вершин из вашего объекта, может
быть разбиение вашего исходного крупного объекта на различные части.
Будем использовать тот же пример MeshFile и попробуем слегка изме­
нить его, разбив на меньшие, но более управляемые объекты.
При разбиении объект преобразуется в массив объектов. В нашем при­

мере мы так же будем держать перед глазами исходный и конечные объек­

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

// Split information
private Mesh[] meshes = null;
private bool drawSplit = false;
private bool drawAHSplit = false;
private int index = 0;
private int lastlndexTick = System.Environment.TickCount;

Эти переменные будут определять созданные в результате разбиения
объекты, также как и флажок, указывающий на то, рисуете ли вы исход­
ный объект или отображаете разбиваемый объект (по умолчанию выби­
рается исходный объект). Если вы рисуете разбиваемый объект, имеется
второй флажок, указывающий на то, отображаются ли объекты в массиве
или по отдельности (по умолчанию следует выбрать второй вариант).

Глава 7. Использование свойств и возможностей Mesh-объектов 159
Необходимо обработать текущий индекс отображаемого объекта (в слу­
чае, если отображение выполняется по отдельности) и «мини-таймер»
для определения момента переключения к следующему объекту (для того
же случая).
Теперь мы можем создавать наш массив объектов. Сразу после вызова
LoadMesh в методе InitializeGraphics добавьте следующую секцию кода:

meshes = Mesh.Split(mesh, null, 1000, mesh.Options.Value);

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

public static Microsoft.DirectX.Direct3D.Mesh[ ] Split (Mesh mesh , int[ ]

adjacencyln ,

System.Int32 maxSize , MeshFlags options ,
out GraphicsStream adjacencyArrayOut ,
out GraphicsStream faceRemapArrayOut ,

out GraphicsStream vertRemapArrayOut )

Видно, что эта функция принимает в качестве первого параметра
объект, который мы хотим разбить. Следующий параметр — adjacencyln,
данные о смежности (можно переслать пустой указатель null, поскольку
мы уже описывали его). Третий параметр maxSize — максимальное чис­
ло вершин в создаваемых объектах. Для предыдущего примера, макси­
мум составляет 1000 вершин на каждый новый объект. Параметр options
используется, чтобы определить флажки для каждого из недавно создан­
ных объектов. Последние три параметра возвращают информацию о каж­
дом из новых объектов, в виде потока данных. Мы будем использовать
перегрузки без этой информации.
После того как мы создали массив объектов, необходимо задать спо­
соб переключения от исходного объекта к полученному массиву. Для этого
будем использовать те же самые клавиши, что и ранее: клавиша «Про­
бел» и «М». Замените метод OnKeyPress следующим кодом:

protected override void OnKeyPress(KeyPressEventArgs e)

{

if (e.KeyChar == ' ')

{

drawSplit = !drawSplit;

}

else if (e.KeyChar == V)

{

drawAHSplit = IdrawAllSplit;

}
}

160 Часть II. Основные концепции построения графики
Здесь мы переключаем два режима отображения — отображение ис­
ходного и разбиваемого объекта, после чего выбираем отображение раз­
биваемого объекта целиком или же по отдельности. Теперь мы должны
изменить метод DrawMesh, чтобы использовать эти переменные. Заме­
ните содержание указанного метода в соответствии с кодом, приведен­
ным в листинге 7.2.

Листинг 7.2. Рендеринг разбиваемых объектов.
if ((System.Environment.TickCount - lastlndexTick) > 500)

{

index++;
if (index >= meshes.Length)
index = 0;
lastlndexTick = System.Environment.TickCount;

}

device.Transform.World = Matrix.RotationYawPitchRoll(yaw, pitch, roll) *
Matrix.Translation(x, y, z);
for (int i = 0; i < meshMaterials.Length; i++)

{

device.Material = meshMaterials[i];

device.SetlexturefO, meshTextures[i]) ;

if (drawSplit)

{

if (drawAllSplit)

{

foreach(Mesh m in meshes)

m.DrawSubset(i);

}

else

{

meshes[index].DrawSubset(i);

}
}

else

{

mesh.DrawSubset (i);

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

Глава 7. Использование свойств и возможностей Mesh-объектов 161
При запуске данного приложения вначале отобразится исходный
объект. После нажатия на клавишу «Пробел» начнут отображаться от­
дельные разбитые объекты. Если вы в этом режиме нажмете клавишу
«М», отобразятся все разбитые объекты одновременно. Вы можете срав­
нить исходный и полученный результат.

Краткие выводы

В этой главе мы узнали все, что нужно знать о стандартном классе
Mesh, включая.
• Оптимизацию данных Mesh-объекта.
• Упрощение объектов.
Создание объектов с новыми компонентами вершинных данных.
• Объединение вершин.
В следующей главе мы исследуем ресурсы Direct3D, затрагивающие
глубину отображаемых объектов.

162 Часть II. Основные концепции построения графики

Глава 8. Введение в ресурсы

Ресурсы (Resources) являются основополагающей частью отображе­
ния или рендеринга сложных объектов в Direct3D. В этой главе мы рас­
смотрим более совершенные возможности ресурсов, включая.
• Статические и динамические ресурсы.
Изменение содержимого буферов, включенных в Mesh-объекты.
Использование различных флажков блокировки.
Использование небезопасного режима «unsafe» для максималь­
ного выполнения операций.

Класс ресурсов

Класс Resource — относительно маленький класс, но он является базо­
вым для всех ресурсов в Direct3D, так что имеет смысл начать рассмотре­
ние этого раздела книги со списка и назначения каждого метода этого класса.
В действительности мы никогда не будем создавать или использовать этот
класс непосредственно, так как он является абстрактным, но мы сможем
использовать различные методы этого класса, приведенные в таблице 8.1.
Таблица 8.1. Методы Класса «Resource» и параметры
Параметр или метод Описание
Device Только для чтения; возвращает устройство для этого
ресурса

Туре

Priority

PreLoad

Только для чтения, возвращает тип ресурса. Подходящие значения для этотого параметра находятся в списке ResourceType
Чтение — запись, возвращает приоритет этого ресурса. Предполагаются только те ресурсы, которые постоянно находятся в управляемом пуле памяти. Они используются, чтобы определить, когда ресурс может быть удален из памяти. Более низкий приоритет означает более быстрое удаление ресурса из памяти. По умолчанию все управляемые ресурсы имеют приоритет
О, а все неуправляемые ресурсы будут всегда иметь
приоритет 0. Есть также метод SetPriority, который возвращает старый приоритет после назначения нового
Используйте этот метод для индикации того, что управляемый ресурс может вскоре понадобиться. Это позволит приложению Direct3D перемещать ваш ресурс в видеопамять еще до того, как это будет необходимо. Важно обратить внимание, что если вы уже используете значительное количество видеопамяти, этот метод будет неэффективен

Глава 8. Введение в ресурсы 163
Параметр или метод Описание
PrivateData members Имеются три значения, которые позволяют получать и записывать индивидуальные данные для каждого из ресурсов. Эти данные никогда не используются Direct3D и могут использоваться приложением по вашему усмотрению
Как вы можете видеть, класс Resource имеет дело главным образом с
расширенными возможностями управляемых ресурсов. Важно обратить
внимание на то, что каждый ресурс в Direct3D, также как и пул памяти
(определенный в списках Usage и Pool), будет иметь директиву using.

Рассмотренные параметры и свойства определяют, каким образом исполь­

зуется ресурс, и где он расположен в памяти (будь это системная память,
видеопамять или AGP память).
Ресурсы позволяют центральному процессору обращаться к сохранен­
ным данным обычно с помощью механизма блокировки Locking. В на­
ших примерах до настоящего времени мы формировали наши буферы,
каждый раз вызывая метод SetData, и создавали текстуры из файлов.
Однако, можно извлекать данные или небольшие подразделы этих дан­
ных, блокируя на время эти ресурсы. Мы кратко обсудим эти вопросы в
этой главе. Давайте пока рассмотрим первый из ресурсов, которые мы

представили.

Использование вершинных и индексных

буферов

Вершинные буферы являются основной структурой данных, исполь­
зуемых приложением Direct3D для сохранения данных о вершинах, в то
время как индексные буферы играют туже роль, но для индексов. Эти
• классы происходят от класса Resource и, таким образом, наследуют ме­
тоды этого класса, добавляя несколько своих собственных.
Одним из главных параметров класса буферов является описание бу­
фера (description). Структура, возвращаемая из этого раздела, сообщает
всю информацию о созданном буфере, включая формат, использование,
пул памяти, размер и формат вершины. Возможно, мы бы уже знали эту
информацию, если бы создавали буферы самостоятельно, но при созда­
нии буфера из внешнего источника это весьма полезная информация.

СТАТИЧЕСКИЕ И ДИНАМИЧЕСКИЕ БУФЕРЫ

Описав два этих метода, связанных с классом буферов, мы можем

обсудить различия между статическими и динамическими буфера­

ми. Это касается и вершинных, и индексных буферов.

164
Часть II. Основные концепции построения графики

Если буфер был создан с флажком Usage.Dynamic— это динами­
ческий буфер, любой другой буфер является статическим. Стати­
ческие буферы предназначены для элементов, значения которых
изменяются не так часто, в то время как динамические буфера опе­
рируют с постоянно изменяющимися данными.
Статический буфер, тем не менее, не подразумевает, что его дан­
ные не могут изменяться. Однако, блокировка и обмен информаци­
ей со статическим буфером во время его использования может при­
вести к проблемам в процессе выполнения приложения. Прежде чем
данные можно будет изменить, процессор должен закончить обра­
ботку текущего набора данных, что может потребовать определен­
ного времени. С другой стороны, когда данные в буфере изменяют­
ся, процессор ждет окончания этих действий, что также влияет на
эффективность не с лучшей стороны.
Если вы предполагаете частое изменение данных, необходимо ис­
пользовать динамический буфер (флажок Usage.Dynamic), это по­
зволит приложению Direct3D оптимизировать конвейер данных для
их частого изменения. Но следует отметить, что использование ди­
намического буфера не даст никаких преимуществ в скорости по
сравнению со статическим вариантом.
Нам желательно знать количество ожидаемых элементов в буферах
на кадр и соответственно под это выбирать буфер. Для максималь­
ного быстродействия рекомендуется иметь один большой статичес­
кий вершинный буфер для каждого отображаемого формата вер­
шин, а при необходимости возможно использование динамических
буферов.
Механизм Locking, блокировка
используемых буферов

Механизм блокировки locking кажется одним из наиболее неясных

моментов в Direct3D, особенно в Управляемом DirectX. Как выполнять

эти процедуры и как увеличивать их быстродействие — достаточно се­

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

Прежде чем мы возьмемся за это, выясним что же такое «блокировка»

буфера? В действительности это просто действие, разрешающее доступ

центрального процессора к разделу данных в вашем ресурсе, при этом

ресурс блокируется от каких-либо внешних «вмешательств». Поскольку

вы не можете непосредственно «общаться» с графическими устройства­

ми, необходимо найти способ управлять данными вершин из вашего при­

ложения, для этого и нужен механизм блокировки. Рассмотрим различ­

ные процедуры или методы блокировки, которые существуют для вер­

шинных и индексных буферов (они принимают те же самые параметры):

Глава 8. Введение в ресурсы 165
public System.Array Lock ( System.Int32 offsetToLock ,
Microsoft.DirectX.Direct3D.LockFlags flags )
public System.Array Lock ( System.Int32 offsetToLock , System.Type
typeVertex ,
Microsoft.DirectX.Direct3D.LockFlags flags , params int[] ranJcs )
public Microsoft.DirectX.Direct3D.GraphicsStream Lock ( System.Int32

offsetToLock ,

System.Int32 sizeToLock , Microsoft.DirectX.Direct3D.LockFlags flags )

Как вы можете видеть, имеется три вида перегрузки, предназначен­
ных для блокировки наши буферов. Начнем с первой, как самой простой.
Эта перегрузка доступна, только если вы создавали буфер с помощью
конструктора, который принимает описание System.Type и значения вер­
шин или индексов.
Остальные две перегрузки представляются весьма интересными.
Первый параметр каждой из них — offset, смещение (в байтах), с кото­
рого вы хотите запустить механизм блокировки. Если вы желаете бло­
кировать весь буфер, необходимо установить нулевое значение смеще­
ния. Обратите внимание, что первые два варианта процедуры возвра­
щают массив данных. Во втором варианте вторым параметром являет­
ся исходный тип возвращаемого массива. Последний параметр ranks
используется для определения размера или ранга возвращаемого мас­
сива. Для примера, давайте предположим, что у вас есть вершинный
буфер (Vector3), включающий в себя координатные данные имеющихся
1200 вершин. Блокировка данного буфера выглядела бы следующим

образом:

Vector3[] data = (Vector3[])vb.Lock(0, typeof(Vector3), LockFlags.None,

1200);

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

Vector3[,] data = (Vector3[,])vb.Lock(0, typeof(Vector3), LockFlags.None,
600, 600);

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

массив.

166
Часть II. Основные концепции построения графики

БОЛЕЕ ЭФФЕКТИВНАЯ БЛОКИРОВКА БУФЕРОВ

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

нены.

• Новый массив подходящего типа распределен, дан размер, ука­
занный в параметре ranks.
• Данные скопированы из блокированной ячейки памяти в наш но-'
вый буфер.
• Данный буфер возвращен пользователю, и при необходимости
может быть изменен.
• При последующем вызове метода Unlock, уже другая копия
данных из массива пересылается назад в блокированную ячей­
ку памяти.
• И окончательно все данные вершины разблокируются.
Не трудно понять, почему этот метод выполняется несколько мед­
леннее, чем мы этого ожидали. Можно удалять только одну из двух
копий: определяя при создании буфера флажок «только для запи­
си» Usage.WriteOnly, мы устраняем первую копию, а, определяя
при блокировке флажок «только для чтения» LockFlags.Readonly, —
вторую.
Последний вариант вызова является наиболее предпочтительным.
Он также имеет новый параметр, а именно, размер данных, кото­
рые мы хотим блокировать. В других перегрузках это значение вы­
числяется в течение вызова по формуле sizeof(type)*NumberRanks.
Если вы используете последнюю перегрузку, просто пересылайте
размер данных, которые вы хотите блокировать (в байтах). Если вы
хотите блокировать весь буфер, установите в первых двух парамет­
рах этого метода нулевые указатели.
Эта перегрузка возвратит класс GraphicsStream, который позволит
вам непосредственно управлять заблокированными данными без
любых дополнительных распределений памяти для массивов и без
любых дополнительных копирований в память. Теперь вы можете
непосредственно и более эффективно управлять памятью, выигры­
вая в быстродействии.
Но, тем не менее, не стоит полностью отказываться от операций бло­
кировки с использованием массивов из-за того, что они более мед­
ленные. Они достаточно удобны и, если их использовать надлежа-

Глава 8. Введение в ресурсы
167

щим образом, проигрыш в быстродействии по сравнению с опера­

циями блокировки потоковых данных GraphicsStream практически

незаметен.

Управление процедурой блокировки

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

LockFlags.None

LockFlags.Discard

LockFlags.NoOverwrite

LockFlags.NoDirtyUpdate

LockFlags.NoSystemLock

LockFlags.Readonly

Если вы не используете флажки блокировки, будет задействован ме­
ханизм блокировки по умолчанию. Если вы хотите управлять процеду­
рой блокировки, можно использовать флажки, приведенные выше.
Флажок Discard (исключение) может использоваться только для дина­
мических буферов. В этом случае вершинный или индексный буфер бу­
дет, и, если существует еще какое-либо подключение к старой памяти,
будет возвращен новый блок памяти. Этот флажок весьма полезен, если
вы заполняете вершинный буфер динамически. Как только вершинный
буфер полностью заполняется, вы блокируете его, используя данный фла­
жок. Эта процедура часто используется в комбинации со следующим ти­
пом флажков.
Флажок NoOverwrite (также используется только для динамических
буферов) сообщает приложению Direct3D, что вы не будете перезапи­
сывать данные в вершинном или индексном буфере. Использование дан­
ного флажка позволит отменить или переопределить вызов и продол­
жить использовать буфер. Если вы не используете этот флажок, блоки­
ровка будет выполняться до тех пор, пока не завершится любой теку­
щий рендеринг. Поскольку при этом вы не можете перезаписывать дан­
ные в этот буфер, это будет полезно только при добавлении вершин в

буфер.

Стандартное использование этих двух флажков подразумевает исполь­
зование буфера большого размера, который заполняется динамически.
Флажок NoOverwrite используется до тех пор, пока буфер не заполнится
полностью. В это время следующая блокировка будет использовать фла­
жок Discard для блокировки буфера. В листинге 8.1. приводится пример
кода из процедуры PointSprites (точечные спрайты), поставляемой вмес­
те с DirectX SDK.

168
Часть II. Основные концепции построения графики

Листинг 8.1. Выборка из метода PointSprites.
if (++numParticlesToRender == flush)
{

// Done filling this chunk of the vertex buffer. Lets unlock and
// draw this portion so we can begin filling the next chunk.

vertexBuffer.Unlock();

dev.DrawPrimitives(PrimitiveType.PointList, baseParticle,

numParticlesToRender);

// Lock the next chunk of the vertex buffer. If we are at the
// end of the vertex buffer, LockFlags.Discard the vertex buffer and start
// at the beginning. Otherwise, specify LockFlags.NoOverWrite, so we can
// continue filling the VB while the previous chunk is drawing.
baseParticle += flush;
if (baseParticle >= discard)
baseParticle = 0;
vertices = (PointVertex[])vertexBuffer.Lock(baseParticle *
DXHelp.GetTypeSize(typeof(PointVertex)), typeof(PointVertex),
(baseParticle != 0) ? LockFlags.NoOverwrite : LockFlags.Discard,

flush);

count = 0;

numParticlesToRender = 0;
}
В этой выборке регистрируется момент, когда данные полностью на­
копились и готовы к отображению на экране (вызов DrawPrimitives). Если
такой момент наступил, мы разблокируем наш буфер и производим рен­
деринг. Затем мы определяем, действительно ли мы находимся в конце
нашего буфера (baseParticle > = discard), и блокируем наш буфер еще раз.
Мы запускаем блокировку в конце буфера, пересылая флажок
NoOverwrite, за исключением случая, когда baseParticle имеет ненулевое
значение, тогда мы блокируем данные в начале буфера, используя фла­
жок Discard. Это позволяет нам продолжить добавление новых точечных
спрайтов к нашей сцене, пока буфер не заполнится, после чего мы ис­
ключим наш старый буфер и начнем заполнять новый.
Рассмотрев эти два типа флажков, мы можем передти к оставшимся.
Самый простой из них — Readonly, который, судя по его названию, со­
общает Direct3D, что вы не будете записывать данные в буфер. Когда мы
имеем дело с перегрузками блокировки, которые возвращают массивы,
данная операция имеет некоторые преимущества, поскольку не происхо­

дит копирования данных, обновляемых при вызове разблокировки Unlock.

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

Глава 8. Введение в ресурсы 169
Последний из флажков — NoSystemLock, как правило, используется
нечасто. Обычно, когда вы блокируете ресурс в видеопамяти, резервиру­
ется критическая секция «systemwide» в рамках всей системы, не позволяя
каким-либо образом изменять режимы визуального отображения до тех
пор, пока действует блокировка. Использование флажка NoSystemLock
отключает это свойство. Данное действие может быть полезно только для
операций блокировки, занимающих весьма непродолжительное время, и
только если вы все еще нуждаетесь в увеличении скорости выполнения.
Таким образом, часто использовать данный флажок не рекомендуется.
Естественно, после вызова блокировки и после выполнения необхо­
димых операций мы должны разблокировать буфер. Для этого использу­
ется механизм разблокировки. У этой функции нет никаких параметров,
разблокировка должна вызываться каждый раз, когда используется бло­
кировка и наоборот, невыполнение этого требования может вызвать ошиб­
ки при процедуре рендеринга.

Использование текстурных ресурсов

Все ресурсы текстур в Управляемом DirectX происходят от отдельно­
го класса BaseTexture, принадлежащего общему классу Resource. Суще­
ствует несколько новых методов, основанных на использовании объек­
тов класса BaseTexture, см. таблицу 8.2.
Таблица 8.2. Методы класса BaseTexture и параметры
Параметр или метод Описание
AutoGenerateFilterType Параметр чтения-записи, описывает, каким образом mipmap подуровни сгенерированы автоматически. Он принимает значение списка TextureFilter (фильтра текстур), и автоматически воссоздает любые mipmap подуровни, если тип фильтра изменен. Заданный по умолчанию тип фильтра для генерации mipmap уровня — TextureFilter.Linear (линейная фильтрация), в случае если драйвер не поддерживает этот режим, будет использоваться TextureFilter.Point (точечная фильтрация). Если устройство не поддерживает выбранный тип фильтра, процедура фильтрации игнорируется. Все параметры фильтра являются используемыми, за исключением значения «None». Можно видеть, что значение TextureFilterCaps структуры Capabilities (Возможности) определяет, какие типы фильтров поддерживаются вашим устройством
LevelOfDetail Параметр чтения-записи, определяет наиболее
детальный (в плане разрешения) уровень
управляемых текстур

170 Часть II. Основные концепции построения графики

Параметр или метод Описание

GenerateMipSubLevels Этот метод автоматически генерирует подуровни
текстуры mipmap, о которой мы только что упомянули. Он будет использовать следующее свойство, чтобы определить режим фильтрации и использовать его при создании этих уровней
LevelCount Только для чтения, определяет число уровней используемой текстуры. Например, текстура mipmapped (текстура с разрешением, изменяющимся по мере удаления отображаемого объекта, см. ниже в «Структура Mipmaps»), имела бы число уровней, определяемое значением
LevelCount

СТРУКТУРА MIPMAPS

Проще говоря, mipmap представляет собой цепочку или последо­
вательность текстур, первая из текстур имеет самое большое зна­
чение детального разрешения. Значение разрешения каждой пос­
ледующей текстуры уменьшается в два раза от значения предыду­
щей. Например, при значении разрешения первой текстуры
256x256, следующий уровень будет иметь 128x128, затем 64x64 и
так далее, по мере удаления объекта от наблюдателя. Цепочки
Mipmap используются приложением Direct3D для управления каче­
ством отображаемых текстур, что требует значительного места в
памяти. Данный подход позволяет существенно экономить ресур­
сы памяти при сохранении приемлемого разрешения в целом.
При создании текстуры один из используемых параметров опреде­
ляет число уровней, которые вы хотите иметь в этой текстуре. Это
число уровней связано непосредственно с цепочкой текстур, кото­
рые были описаны выше. При задании нулевого значения для этого
параметра приложение Direct3D автоматически создаст набор
mipmaps от вашей первоначальной текстуры с максимальной разре­
шающей способностью до последней, имеющей разрешение 1x1. В
нашем примере, используя «0» для этого параметра, и имея перво­
начальное разрешение 256x256, будет создана цепочка из девяти
текстур: 256x256, 128x128, 64x64, 32x32, 16x16, 8x8, 4x4, 2x2, и 1x1.
При вызове функции SetTexture приложение Direct3D будет автома­
тически проводить фильтрацию различных текстурируемых цепочек
mipmaps, основываясь на текущей установке свойств MipFilter в
классе Sampler. Если вспомнить, в нашей игре «Dodger», которую
мы написали в главе 6, мы устанавливали фильтры растяжения и
сжатия для наших текстур дороги. Для фильтров mipmap использу­
ются те же подходы.

Глава 8. Введение в ресурсы 171

Блокировка текстур и получение описаний

Подобно вершинным и индексным буферам, текстуры также имеют
механизм блокировки. Дополнительно к известным нам методам здесь
появляются две новые особенности, которые не присущи ресурсам гео­
метрии (вершины, нормали и пр.), а именно: недействительные области
(dirty regions) и фоновые объекты (backing object). Для начала изучим
механизм блокировки для текстур.
Блокировка текстур сходна с подобной операцией над нашими «гео­
метрическими» буферами с двумя имеющимися различиями. Во-пер­
вых, вызов блокировки принимает параметр уровня level множествен­
ной текстуры, по отношению к которому мы хотим выполнить блоки­
ровку. Во-вторых, вы можете заблокировать отдельно полигон (к при­
меру, куб для объемных текстур), или же блокировать всю поверхность
текстуры, используя при этом перегрузку без определения этого пара­

метра.

При работе с кубическими текстурами, необходим еще один дополни­
тельный параметр — сторона отображаемого куба, которую вы хотите
заблокировать. В качестве этого параметра вы можете использовать зна­
чение из списка CubeMapFace.
Обратите внимание, что некоторые из процедур блокировки полиго­
нов LockRectangle могут возвращать параметр шага (pitch). Это дает воз­
можность узнать о количестве данных в каждом ряду (в байтах).

В то время как блокировки текстуры могут принимать параметр «type»

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

текстуры.

Теперь мы рассмотрим блокировку текстуры на примере. Будем ис­
пользовать знакомый нам MeshFile. Мы удалим текстуру, которая исполь­
зуется для рендеринга, и заменим ее на другую, созданную динамически
для нашего приложения. Нам потребуется два режима для этой тексту­
ры: тот, который циклически повторяет текстуры, и тот, который являет­
ся абсолютно случайным. Для этого нам понадобятся следующие пере­

менные:

private uint texColor = 0;
private bool randomTextureColor = false;

Мы планируем использовать 32-разрядный формат пиксела для на­
шей текстуры, таким образом, мы сохраняем наш цвет также в 32-раз­
рядном формате («uint», целочисленный). С помощью булевой перемен­
ной мы выбираем, либо мы создаем случайные цвета текстуры, либо ис-

172 Часть II. Основные концепции построения графики
пользуем циклически повторяющуюся текстуру. Теперь мы должны со­
здать метод, который будет выполнять блокировку текстуры и ее обнов­
ление или изменение. Чтобы показать различия между методами с ис­
пользованием массивов (array methods) и небезопасными методами (unsafe
methods), рассмотрим оба случая. Метод с использованием массива при­
веден в листинге 8.2.

Листинг 8.2. Заполнение текстуры с использованием массива.
private void FillTexture(Texture t, bool random)

{

SurfaceDescription s = t.GetLevelDescription(O);
Random r = new Random() ;
uint[,j data = (uint[,])t.LockRectangle(typeof(uint), 0,
LockFlags.None, s.Width, s.Height);
for (int i = 0; i < s.Width; i++)
(
for (int j = 0; j < s.Height; j++)
(
if (random)
(

data[i,j] = (uint)Color.FromArgb(

r.Next(byte.MaxValue),
r.Next(byte.MaxValue),

r.Next (byte.MaxValue)) .ToArgb() ;
}
else

{

data[i,j] = texColor++;
if (texColor >= OxOOffffff)
texColor = 0;

t. OnlockRectangle(0);

}
Здесь мы берем существующую текстуру и сначала получаем ее опи­
сание, чтобы узнать и задать размер данных для заполнения. Зная шири­
ну и высоту данных, мы блокируем данные в двухмерном массиве (ши­
рина/высота). При блокировке данного массива используется целое чис­
ло без знака (поскольку используется 32-разрядный формат пиксела), при
этом информация о флажках блокировки не важна. Так как мы создаем
только один уровень mipmap последовательности, мы определяем значе­
ние для блокировки нулевого уровня в текстуре.

Глава 8. Введение в ресурсы
173
После того, как текстура блокирована, перебираются значения воз­
вращенного массива текстуры, ее цвета изменяются соответственно либо
случайным образом, либо с помощью приращения (цвет нашей цикли­
ческой текстуры). И, наконец, после того как эти данные полностью из­
менены, мы разблокируем нашу текстуру.
Рассмотрим, что же происходит при использовании небезопасного
метода, вариант которого приведен в листинге 8.3.
Листинг 8.3. Заполнение текстуры с использованием небезопасного метода.
private unsafe void FillTextureUnsafe(Texture t, bool random) {

SurfaceDescription s = t.GetLevelDescription(O);
Random r = new Random() ;
uint* pData = (uint*)t.LockRectangle(0,

LockFlags.None).IntemalData.ToPointer() ;

for (int i = 0; i < s.Width; i++)

{
for (int j = 0; j < s.Height; j++)
{
if (random)
{

*pData = (uint)Color.FromArgb(

r.Next(byte.MaxValue),
r.Next(byte.MaxValue),

r.Next(byte.MaxValue)).ToArgb ();

}

else

{

*pData = texColor++;
if (texColor >= OxOOffffff)
texColor = 0;

}

pData++;

}
}
t.UnlockRectangle(O);

}

Обратите внимание, что единственные отличия этой функции — за­
дание небезопасного режима и то, как мы изменяем наши данные. Мы
блокируем буфер данных потока и используем значение IntemalData (как
указатель IntPtr), чтобы получить доступ к данным, которые мы будем
изменять. Мы управляем данными непосредственно через указатель
Pointer, и в конце операции вновь разблокируем нашу текстуру.

174
Часть II. Основные концепции построения графики

Чтобы компилировать этот метод, вы должны включить в свойствах
проекта возможность компиляции небезопасного кода. Для этого в раз­
деле Configuration Properties, установите значение «true» для свойства

Allow Unsafe Code Blocks.

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

кодом:

// Store each material and texture
for (int i = 0; i < mtrl.Length; i++)

{

meshMaterials[i] = mtrl[i].Material3D;
meshTextures[i] = new Texture(device,
256, 256, 1, 0, Format.X8R8G8B8, Pool.Managed);
#if (UNSAFE)
FillTextureUnsafe(meshTextures [i], randomTextureColor);

#else

FillTexture(meshTextures [i], randomTextureColor);

#endif

}
Как вы можете видеть, мы больше не пытаемся загружать текстуру
из файла. Для каждой текстуры в нашем массиве мы создаем новую
текстуру, используя формат пиксела X8R8G8B8 (32-разрядный фор­
мат). Мы создаем текстуру 256x256 с одним только уровнем. Затем
мы заполняем нашу текстуру, используя только что описанный метод
и оператор #if для выбора. Вы можете так же определить выбор Unsafe
в вашем файле кода и использовать его вместо предложенного вари­
анта.
ВРАЩЕНИЕ С ПРИВЯЗКОЙ К ЧАСТОТЕ СМЕНЫ КАДРОВ

Следует упомянуть один момент, на котором мы уже останавлива­

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

цвета текстуры и скорость вращения модели при нажатии на клави­

шу. Это связано с тем, что движение модели в этом случае зависит

от скорости смены кадров в большей степени, чем от системного

таймера.

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

Глава 8. Введение в ресурсы
175
каждый раз при смене кадра. Кроме того, мы можем устанавливать про­
смотр нашей текстуры. Перепишите метод SetupCamera, см. листинг 8.4,
вставив туда нашу функцию.

Листинг 8.4. Установка опций камеры.
private void SetupCamera()

{

device.Transform.Projection = Matrix.PerspectiveFovLH((float)Math.PI / 4,
this.Width / this.Height, l.Of, 10000.Of);
device.Transform.View = Matrix.LookAtLH (new Vector3(0,0, 580.Of),
new Vector3(), new Vector3 (0,1,0)) ;
device.RenderState.Lighting = false;
if (device.DeviceCaps.TextureFilterCaps.SupportsMinifyAnisotropic)
device.SamplerState[0].MinFilter = TextureFilter.Anisotropic;
else if (device.DeviceCaps.TextureFilterCaps.SupportsMinifyLinear)
device.SamplerState[0].MinFilter = TextureFilter.Linear;
if (device.DeviceCaps.TextureFilterCaps.SupportsMagnifyAnisotropic)
device.SamplerState[0].MagFilter = TextureFilter.Anisotropic;
else if (device.DeviceCaps.TextureFilterCaps.SupportsMagnifyLinear)
device.SamplerState[0].MagFilter = TextureFilter.Linear;
foreach(Texture t in meshTextures)

#if (UNSAFE)

FillTextureUnsafe (t, randomTextureColor) ;

#else

FillTexture(t, randomTextureColor);

#endif

}

Мы выключили освещение для того, чтобы видеть разнообразие на­
ших цветов без какого-либо эффекта затенения, и включили текстурный
фильтр (если он поддерживается). Последнее, что необходимо сделать, —
каким-то образом включить случайные цвета текстуры. Будем использо­
вать нажатие любой клавиши в качестве переключателя между двумя
режимами текстурирования. Для этого добавьте следующее:

protected override void OnKeyPress(KeyPressEventArgs e)

{
randomTextureColor = ! randomTextureColor;
}
Использование случайного подбора цветов создает эффект анимации.
Раскраска объекта на экране напоминает белый шум или картинку в те­
левизоре при отсутствии принимаемого сигнала, см. рис.8.1.

176 Часть II. Основные концепции построения графики

Рис. 8.1 «Снежная» текстура

Краткие выводы

В этой главе мы обсудили различные ресурсы, доступные в приложе­
нии Direct3D и их использование, включая.
• Статические и динамические ресурсы.
• Изменение содержимого буферов, включенных в объекты Mesh.
• Использование различных флажков блокировки.
• Использование небезопасного режима для увеличения быстродей­

ствия.

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

Глава 9. Применение других типов Mesh 177

Глава 9. Применение других

типов Mesh

Упрощение Mesh-объектов

Итак, мы ознакомились с основным классом Mesh, включенным в
библиотеку расширений. Однако, существуют три других типа Mesh, ко­
торые мы еще не рассматривали, и которые изучим в этой главе.
Мы уже знакомы по главе 7 с созданием упрощенных объектов Mesh с
помощью методов Simplify. Поскольку общий случай использования уп­
рощенных объектов дает самое низкое разрешение модели, сохранять
множественные версии объектов — это, вероятно, не самая хорошая идея,
особенно если вы даже не собираетесь использовать некоторых из них.
Для более эффективного упрощения объектов можно использовать
объект SimplificationMesh. Однако, непосредственно при использовании
данного подхода мы не можем выполнять рендеринг, необходимо снача­
ла получить реальный объект из упрощенного. Если вспомнить, раньше
при упрощении объектов мы использовали два «режима» для нашего
примера. Первый режим отображал неупрощенный исходный объект с
близкого расстояния. Второй вариант позволял отобразить менее деталь­
ный объект (за счет сокращения числа вершин и сторон) с большего рас­
стояния. На данном этапе мы будем использовать нечто похожее, более

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

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

ременные:

private SimplificationMesh simplifiedMesh = null;
private float cameraPos = 580.Of;

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

device.Transform.View = Matrix.LookAtLH(new Vector3(0,0, cameraPos),
new Vector3(), new Vector3(0,1,0));

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

178 Часть II. Основные концепции построения графики
ную местоположения камеры. Эта переменная находится там же, где мы
записываем данные при упрощении объекта. Следует обратить внима­
ние на то, что мы не имеем никаких дополнительных mesh-объектов.
Каждый раз, упрощая наш объект, мы будем просто заменять его новым.
Необходимо переписать метод LoadMesh, чтобы удостовериться, что
наш объект очищен, и упрощенный объект создан должным образом. Мы
должны заменить этот метод на приведенный в листинге 9.1:
Как видите, мы должны имееть информацию смежности и для очи­
щенного, и для упрощенного объектов. После загрузки объекта и созда­
ния текстуры, мы очистим наш объект, перед тем как упростить его.

Листинг 9.1. Создание упрощенного объекта Mesh.
private void LoadMesh(string file)
(
ExtendedMaterial[] mtrl;
GraphicsStream adj ;
// Load our mesh
mesh = Mesh.FromFile(file, MeshFlags.Managed, device, out adj, out mtrl!
// If we have any materials, store them
if ((mtrl != null) && (mtrl.Length > 0))

{

meshMaterials = new Material[mtrl.Length];
meshTextures = new Texture[mtrl.Length];
// Store each material and texture
for (int i = 0; i < mtrl.Length; i++)

{

meshMaterials [i] = mtrl[i] .Materia3D;
if ((mtrl[i].TextureFilename != null) &&
(mtrl[i].TextureFilename != string.Empty))

{

// We have a texture, try to load it
meshTextures[i] = TextureLoader.FromFile(device, @"..\..\" +
mtrl[i].TextureFilename);

}

}
}
// Clean our main mesh
Mesh tempMesh = Mesh.Clean(mesh, adj, adj);
// Replace our existing mesh with this one

mesh.Dispose();

mesh = tempMesh;
// Create our simplification mesh
simplifiedMesh = new SimplificationMesh(mesh, adj);

}

Глава 9. Применение других типов Mesh 179

Практически, это все, что было необходимо выполнить. Осталось толь­

ко добавить код, позволяющий нам перемещать объект дальше от каме­
ры, и уменьшать детальное разрешение объекта. Расстоянием до камеры
мы будем управлять с помощью клавиатуры, см. листинг 9.2:

Листинг 9.2. Обработчик событий для операции KeyPress.
protected override void OnKeyPress(KeyPressEventArgs e)
(
if (e.KeyChar == '+')

{

cameraPos += (MoveAmount * 2);
simplifiedMesh.ReduceFaces(mesh.NumberFaces - MoveAmount);
simplifiedMesh.ReduceVertices(mesh.NumberVertices - MoveAmount);
mesh.Disposed;
mesh = simplifiedMesh.Clone(simplifiedMesh.Options.Value,
simplifiedMesh.VertexFormat, device);

}

if (e.KeyChar == 'W')
device.RenderState.FillMode = FillMode.WireFrame;
if (e.KeyChar == 'S')
device.RenderState.FillMode = FillMode.Solid;

}
Обратите внимание, что здесь мы используем неопределенную констан­
ту, чтобы управлять необходимым перемещением, активизируемым с помо­
щью нажатия клавиши. Можно определить константу следующим образом:
private const int MoveAmount = 100;
В описываемом методе нажатие клавиши «W» переключает выполнение
приложения в каркасный режим WireFrame, который достаточно нагляден
для того, чтобы «разглядеть» полигоны на отображаемом объекте. Нажатие
клавиши «S» переключит нас обратно к сплошному отображению объекта.
При нажатии клавиши «+» мы будем отодвигать камеру от нашей модели до
определенного значения. Удаляя объект от камеры, мы уменьшаем число
сторон и вершин в соответствии с указанной константой MoveAmount. Для
того чтобы отобразить наш упрощенный объект, необходимо использовать
его в методе рендеринга вместо первоначального объекта.
Выполняя приложение и нажимая клавиши «+» и «W» (соответствен­
но приближая или удаляя объект и переключая отображение от каркас­

ного исполнения к сплошному), мы практически не увидим разницы меж­

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

дующую переменную:

180 Часть II Основные концепции построения графики
private Microsoft.DirectX.Direct3D.Font font = null;
Мы также должны инициализировать наш шрифт прежде, чем начать
отображать eго. После вызова LoadMesh в методе IntializeGraphics до­
бавьте код инициализации:

// Create our font
font = new Microsoft.DirectX.Direct3D.Font(device, new System.Drawing.Font
"Arial", 14.Of, FontStyle.Bold | FontStyle.Italic));

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



font.DrawText(null, string.Format("Number vertices in mesh:
mesh.numberVertices), new Rectangle (10, 10, 0, 0),
DrawTextFormat.NoClip, Color.BlanchedAlmond);
font.DrawText(null, string.FormatСНивЬег faces in mesh: (0)*,
mesh.HumberFaces), new Rectangle(10, 30, 0, 0),
DrawTextFormat.UoClip, Color.BlanchedAlmond);

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

Рис. 9.1 Упрощенный Меsh-объект

Глава 9. Применение других типов Mesh
181
Одна из основных проблем, с которой придется столкнуться в данном
приложении, заключается в том, что при обратном или повторном при­
ближении камеры к объекту мы не можем восстановить потерянные в
процессе упрощения вершины. Для данного случая нет никакого метода
восстановления после использования, к примеру, метода упрощения
ReduceVertices.
Объекты и функции упрощения SimplificationMesh разработаны и пред­
назначены только для того, чтобы упростить объект, без обратного его

восстановления.

Для решения этой проблемы существуют более совершенные объек­
ты Mesh.

Управление степенью детализации, класс

прогрессивных Meshes-объектов

Бывают случаи, когда можно просто упростить объект, без его восста­
новления (например, модель удаляющейся после выстрела ракеты). Это
предполагает, что после упрощения данного объекта мы не сможем улуч­
шить или вернуть его качество. Для примера с ракетой в этом нет необхо­
димости. Но данный пример является далеко не общим случаем. Как пра­
вило, возникает необходимость, когда нам необходимо уменьшить и за­
тем поднять степень детализации объекта. Этого можно достичь, исполь­
зуя более совершенные методы, к которым можно отнести прогрессив­
ные meshes-объекты.
Чтобы показать поведение прогрессивных mesh-объектов, мы напи­
шем приложение, опираясь на те методы, которые уже использовали
для упрощения объектов, например SimplificationMesh. Однако, вместо
того, чтобы только упрощать объект, мы также попробуем поднимать
уровень детализации при обратном приближении камеры к объекту. Как
и раньше, мы начнем с примера, использующего загрузку объекта из

'файла.

Класс ProgressiveMesh происходит от общего класса mesh-объектов
BaseMesh. Вы можете использовать класс ProgressiveMesh, объявив его
предварительно для вашего объекта:
private ProgressiveMesh progressiveMesh = null;
Необходимо также заменить переменную старого класса Mesh на
новую переменную progressiveMesh. Соответственно, для корректной
компиляции с новой переменной необходимо переписать метод

LoadMesh.

Мы будем использовать подобный метод, в конце которого сгенериру­
ем прогрессивный mesh-объект. Используйте код, приведенный в лис­
тинге 9.3.

182 Часть II. Основные концепции построения графики
Листинг 9.3. Загрузка объекта Progressive Mesh

private void LoadMesh(string file)

{

ExtendedMaterial[] mtrl;
GraphicsStream adj;
// Load our mesh
using(Mesh mesh = Mesh.FromFile(file, MeshFlags.Managed, device,
out adj, out mtrl))

{

// If we have any materials, store them
if ((mtrl != null) && (mtrl.Length > 0))

{

meshMaterials = new Material[mtrl.Length] ;
meshTextures = new Texture[mtrl.Length];
// Store each material and texture
for (int i = 0; i < mtrl.Length; i++)

{

meshMaterials[i] = mtrl[i].Material3D;
if ((mtrl[i].TextureFilename != null) &&
(mtrl[i].TextureFilename != string.Empty))

{

// We have a texture, try to load it
meshTextures[i] = TextureLoader.FromFile(device,
@"..\..\" + mtrl[i].TextureFilename);

}
}

)}
II Clean our main mesh
using(Mesh tempMesh = Mesh.Clean(mesh, adj, adj))

{

// Create our progressive mesh
progressiveMesh = new ProgressiveMesh(tempMesh, adj,
null, 1, MeshFlags.SimplifyVertex);
// Set the initial mesh to the max
progressiveMesh.NumberFaces = progressiveMesh.MaxFaces;
progressiveMesh.NumberVertices = progressiveMesh.MaxVertices;

}
}
}
Обратите внимание, что для создания прогрессивного mesh-объекта мы
используем два временных объекта: очищенный объект и параметр, необ­
ходимый для конструктора прогрессивного mesh-объекта — минимальное

число вершин или сторон, которые мы хотим получить в создаваемом объек­

те, в зависимости от пересылаемого значения MeshFlags (либо упрощение
поверхностей Simplify Face, либо упрощение вершин Simplify Vertex). Ее-

Глава 9. Применение других типов Mesh 183

тественно, это только приближенный подход, но, тем не менее, мы можем
получить некоторые преимущества от его использования.
Также обратите внимание, что в данном случае мы сразу задаем число
вершин и/или сторон в максимальные значения (максимальный уровень
детализации), что позволит изменять текущий уровень детализации, ис­
пользуемый при отображении mesh-объекта.
Для компиляции приложения необходимо переписать вызов
DrawSubset в методе DrawMesh следующим образом:

progressiveMesh.DrawSubset(i);

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

private float cameraPos = 580.Of;
private const int MoveAmount = 100;

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

device.Transform.View = Matrix.LookAtLH(new Vector3(0,0, cameraPos),

new Vector3(), new Vector3(0,1,0));

Окончательно, мы должны как обычно обработать операции с клави­
шами, см. листинг 9.4:

Листинг 9.4. Обработчик событий для операции KeyPress.
protected override void OnKeyPress(KeyPressEventArgs e)
(
if (e.KeyChar == '+')

{

cameraPos += (MoveAmount * 2);
progressiveMesh.NumberVertices =
((BaseMesh)progressiveMesh).NumberVertices - MoveAmount;
progressiveMesh.NumberFaces =
((BaseMesh)progressiveMesh).NumberFaces - MoveAmount;

}

184 Часть II. Основные концепции построения графики

if (e.KeyChar == '-')

{

cameraPos -= (MoveAmount * 2);
progressiveMesh.NumberVertices =
((BaseMesh)progressiveMesh).NumberVertices + MoveAmount;
progressiveMesh.NumberFaces =
((BaseMesh)progressiveMesh).NumberFaces + MoveAmount;

}

if (e.KeyChar == 'W')

device.RenderState.FillMode = FillMode.WireFrame;
if (e.KeyChar == 'S')
device.RenderState.FillMode = FillMode.Solid;

}
Опять мы выполняем переключение между каркасным и сплошным ре­
жимом отображения, используя клавиши «W» или «S». Для уменьшения
уровня детализации и соответствующего перемещения камеры от объекта
используется клавиша «+». Обратите внимание, что, прежде чем получить
число сторон и вершин, мы должны определить наш объект progressiveMash
в классе BaseMesh, чтобы согласовать установку и получение параметров.
Легко заметить, что для увеличения уровня детализации и соответ­
ствующего приближения камеры к объекту используется клавиша «-».
Таким образом, при приближении камеры к объекту увеличивается чис­
ло отображаемых вершин и сторон.

СОХРАНЕНИЕ МНОЖЕСТВЕННЫХ УРОВНЕЙ ДЕТАЛИЗАЦИИ

Обычно сохранение множественных объектов с различной степе­
нью детализации проще, чем наличие одного большого прогрессив­
ного mesh-объекта с возможностью управления степенью детали­
зации. Вы можете ознакомиться с прогрессивным mesh-объектом,
который включен в поставляемый DirectX SDK, и можете применить
методы TrimByFaces и TrimByVertices, чтобы изменять степень де­
тализации объекта.
Теперь было бы неплохо добавить к приложению некоторый текст с
комментариями о числе отображаемых вершин и сторон. Не будем по­
вторяться с инициализацией и определением шрифта, поскольку данная
процедура была подробно описана в этой же главе. Здесь можно лишь
добавить следующее:
font.DrawText(null, string.Format("Number vertices in mesh: {O}",
((BaseMesh)progressiveMesh) .NumberVertices), new Rectangle(l0, 10, 0, 0),
DrawTextFormat.NoClip, Color.BlanchedAlmond);

1 ШаыйШШаЙЙНЙШШЙЙНйй*bfirfi tj,ik I ni

Глава 9. Применение других типов Mesh
185

font.DrawText(null, string.Format("Number faces in mesh: {0}",
((BaseMesh)progressiveMesh).NumberFaces), new Rectangle(10, 30, 0, 0),
DrawTextFormat.NoClip, Color.BlanchedAlmond) ;

Рендеринг патч-объектов. Тесселяция

объектов

Упрощение объектов достаточно распространенная операция на прак­
тике, но что если ваш объект уже итак слишком прост? С одной стороны,

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

большее количество вершин в вашем объекте, чем вы имеете. Но с дру­
гой стороны, вы не можете себе позволить увеличить детализацию уже
имеющейся модели, это ничего не даст в плане информационного разре­
шения. Проблему можно решить, применяя патч-объекты. Большинство
современных графических ЗD-программ моделирования ориентированы
на применение патч-типов mesh или некоторых примитивов старшего
разряда, таких, как NURBS (неравномерный рациональный би-сплайн
для описания кривых поверхностей) или секционированные/разделен­
ные поверхности.
В данной книге мы рассмотрим лишь описание применения патч-
объектов, в частности, для увеличения уровня детализации модели. Для
этого мы создадим небольшое приложение, позволяющее нам улучшить
качество разрешения нашего загружаемого объекта.
Снова мы загружаем наш пример из файла (глава 5). Также нам пона­
добится модель для нашего примера, которая находится на CD диске.
Программа, находящаяся на CD диске, использует две модели, включен­
ные в DirectX SDK (tiger.x — тигр и cube.x — куб), плюс, маленькую
модель сферы, которую вы найдете там же. Убедитесь, что вы копируете
текстуру для модели tiger.bmp. Далее нам нужно добавить следующие

переменные:

private float tessLevel = l.Of;
private const float tesslncrement = l.Of;
private string filename = @"..\..\sphere.x";
private Microsoft.DirectX.Direct3D.Font font = null;

Таким образом, сейчас мы имеем текущий уровень тесселяции
(tessLevel), характеризующий степень мозаичности объекта, который
первоначально установлен в значение l.Of, а также приращение этого
уровня (1.Of). Пока мы зафиксировали эти значения, но на практике мож­
но смело изменять эти параметры. Далее мы должны сохранить название
текущей модели, которую мы загружаем, а также шрифт для сопровож­
дающего текста.

186 Часть II. Основные концепции построения графики
Нам также понадобится внести поправки в метод SetupCamera, на этот
раз мы будем использовать несколько меньшие значения удаления каме­
ры от объекта, поскольку имеем меньшие размеры объекта.
В соответствии с вышесказанным, запишите метод следующим обра­

зом:
private void SetupCamera()

{

device.Transform.Projection = Matrix.PerspectiveFovLH(
(float)Math.PI / 4, this.Width / this.Height, l.Of, 100.Of);
device.Transform.View = Matrix.LookAtLH(new Vector3(0,0, 5.Of),

new Vector3(), new Vector3(0,1,0));

device.Lights[0].Type = LightType.Directional;
device.Lights[0].Diffuse = Color.DarkKhaki;
device.Lights[0].Direction = new Vector3(0, 0, -1);

device.Lights[0].Commit () ;

device.Lights[0].Enabled = true;

}

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

// Create our patch mesh
CreatePatchMesh(filename, tessLevel);
// Create our font
font = new Microsoft.DirectX.Direct3D.Font(device, new System.Drawing.Font
("Arial", 14.Of, FontStyle.Bold | FontStyle.Italic));
// Default to wireframe mode first
device.RenderState.FillMode = FillMode.WireFrame;

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

ны.

Однако, мы пока не имеем метода для создания патч-объектов, так что
следует добавить такой код, см. листинг 9.5:

Глава 9. Применение других типов Mesh
187
Листинг 9.5. Создание патч-объекта mesh.
private void CreatePatchMesh(string file, float tessLevel)

{

if (tessLevel < 1.Of) // Nothing to do
return;
if (mesh != null)
mesh.Disposed;
using (Mesh tempmesh = LoadMesh(file))

{

using (PatchMesh patch = PatchMesh.CreateNPatchMesh(tempmesh))

{

// Calculate the new number of faces/vertices
int numberFaces = (int)(tempmesh.NumberFaces
* Math.Pow(tessLevel, 3));
int numberVerts = (int)(tempmesh.NumberVertices
* Math.Pow(tessLevel, 3));
mesh = new Mesh(numberFaces, numberVerts, MeshFlags.Managed
MeshFlags.Use32Bit, tempmesh.VertexFormat, device);
// Tessellate the patched mesh

patch.Tessellate(tessLevel, mesh);

}
}
}
Если уровень тесселяции, который мы в настоящее время используем,
меньше чем l.Of (по умолчанию), ничего в этом методе делать не нужно,
и процедура прекращает выполнение. В противном случае мы должны
создать новый mesh-объект и применить к нему процедуру тесселляции,
сохранив его затем вместо старого. Изменим наш текущий метод
LoadMesh, который не возвращает значения данных нормалей, на следу­
ющий, см. листинг 9.6:

Листинг 9.6. Загрузка mesh-объекта с данными нормалей.
private Mesh LoadMesh(string file)

{

ExtendedMaterial[] mtrl;
// Load our mesh
Mesh mesh = Mesh.FromFile(file, MeshFlags.Managed, device,

out mtrl);

// If we have any materials, store them
if ((mtrl != null) && (mtrl.Length > 0))

{

meshMaterials = new Material[mtrl.Length];

188 Часть II. Основные концепции построения графики
meshTextures - new Texture[mtrl.Length];
// Store each material and texture
for (int i = 0; i < mtrl.Length; i++)

{

meshMaterials[i] = mtrl[i].Material3D;
if ((mtrl[i].TextureFilename != null) &&
(mtrl[i].TextureFilename != string.Empty))
// We have a texture, try to load it
meshTextures[i] = TextureLoader.FromFile(device,

@"..\..\" т mtrl[i].TextureFilename);

}
}
}

if ((mesh.VertexFormat & VertexFormats.Normal) != VertexFormats.Normal)

{

// We must have normals for our patch meshes
Mesh tempMesh = mesh.Clone(mesh.Options.Value,
mesh.VertexFormat | VertexFormats.Normal, device);
tempMesh.ComputeNormals();

mesh.Dispose();

mesh = tempMesh;

}

return mesh;

}
Здесь нет ничего такого, чего мы не видели прежде. Если в нашем
объекте нет никаких нормалей, мы имитируем новый объект и вычисля­
ем нормали, поскольку они потребуются для тесселяции нашего патч-
объекта. И, наконец, мы возвращаем созданный объект (с нормалями).
ДИРЕКТИВА USING

Обратите внимание, что и для возвращенного объекта, и для патч-

объекта, которые мы создаем в этом методе, мы используем клю­

чевое слово «using». Эта директива предполагает автоматическое

размещение объекта в классе, если он оставляет область действия

оператора.

Затем мы создаем новый патч-объект на базе возвращенного объекта.
Поскольку мы будем создавать новый патч, подразумевая изменение уров­
ня тесселяции объекта, нам необходимо знать число новых вершин и сто­
рон в этом объекте. После того как мы рассчитали и создали новый объект,
мы, наконец, можем его тессилировать. Обратите внимание на использо­
вание флажка MeshFlags.Use32Bit. Поскольку после тесселяции мы мо-

Глава 9. Применение других типов Mesh 189
жем получить возвращенный объект очень большого размера, необходи­
мо вначале убедиться, что мы можем поддерживать такие объекты.
Мы почти готовы к запуску этого приложения. Как и ранее, добавим
текст к отображаемой сцене. После вызова метода рисования нашего
объекта добавьте следующее:

font.DrawText(null, string.Format
("Number Vertices: {0}\r\nNumber Faces: {1}",
mesh.NumberVertices, mesh.NumberFaces),
new Rectangle(10,10,0,0),
DrawTextFormat.NoClip, Color.Black);

Осталось написать сам метод тесселяции объекта. Мы будем исполь­
зовать код, приведенный в листинге 9.7:

Листинг 9.7. Обработчик событий операции KeyPress для тесселяции объекта.
protected override void OnKeyPress(KeyPressEventArgs e)
if (e.KeyChar == '+')

{

tessLevel += tesslncrement;
CreatePatchMesh(filename, tessLevel);

}

if (e.KeyChar == '-')

{

tessLevel -= tesslncrement;
CreatePatchMesh(filename, tessLevel);

}

if (e.KeyChar == 'c')

{

filename = @"..\..\cube.x";
tessLevel = 1.Of;
CreatePatchMesh(filename, tessLevel);
}

if (e.KeyChar == 'o')

{

filename = @"..\..\sphere.x";
tessLevel = l.Of;
CreatePatchMesh(filename, tessLevel);
}

if (e.KeyChar == 't')

{

filename = @". ,\. \tiger.x";
tessLevel = l.Of;

140
Часть II. Основные концепции построения графики
CreatePatchMesh(filename, tessLevel);
}
if (e.KeyChar == 'W')
device.RenderState.FillMode = FillMode.WireFrame;
if (e.KeyChar == 's')
device.RenderState.FillMode = FillMode.Solid;
}
Как и раньше, для переключения каркасного и сплошного режимов
отображения используются клавиши «W» или «S», для изменения уров­
ня тесселяции клавиши «*» и «-».
Клавиша «С» используется для того, чтобы отобразить объект «куб»,
клавиша «Т» — объект «тиф», а клавиша «О» возвращает нас к изобра­
жению сферы.

Примеры тесселированных объектов

На рисунках 9.2 — 9.5 приведены примеры отображаемых объектов с
использованием различных вариантов тесселяции.

Рис. 9.2. Изображение сферы с маленьким разрешением

Изображение сферы (рис.9.2). построенной с помощью треугольни­
ков, выглядит не так реалистично.
Однако, если мы разбиваем каждый треугольник на несколько, каче­
ство изображения улучшается (рис.9.3)

Глава 9. Применение других типов Mesh 191
Рис. 9.3. Изображение сферы с улучшенным разрешением
Рис. 9.4. Изображение тигра с нормальным разрешением
Как можно видеть на рис.9.4, изображение тигра выглядит несколько
мозаично, хотя использование текстуры определенно помогает скраши­
вать этот недостаток (рис.9.5).

192 Часть II. Основные концепции построения графики

Рис. 9.5. Изображение тигра с высоким разрешением

Увеличение параметра тесселяции позволяет значительно улучшить
качество картинки.

Краткие выводы

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

стур.

Глава 10. Использование вспомогательных классов 193

Глава 10. Использование

вспомогательных классов

Рисование линий

Прорисовка линий была рассмотрена в главе 4, когда мы имели дело с
примитивами типа набора линий или полосок, используемых при ренде­
ринге. Однако, при использовании таких примитивов мы не можем изме-
нять ширину линий, кроме того, объекты, выполненные таким образом,
оказываются не достаточно сглаженными.
Класс Line может использоваться в зависимости от типа используемо­
го приложения и является достаточно простым и удобным. Рассмотрим
пример, в котором попробуем отобразить случайное число линий, непре­
рывно рисуемых на экране.
Для этого необходимо создать и подготовить новый проект Direct3D,
добавить необходимые ссылки к сборкам, включая класс и using-дирек-
тиву для списка имен. Так же понадобится создать индивидуальную пе­
ременную для устройства и установить форму окна рендеринга. Эти дей­
ствия мы уже неоднократно проделывали и раньше, поэтому не будем на
этом останавливаться.
Линии могут быть нарисованы либо в аппаратных координатах уст­
ройства, либо в мировых координатах. В нашем примере мы рассмотрим
только экранное пространство, кроме того, мы задействуем буфер глуби­
ны. Используйте метод, приведенный в листинге 10.1, чтобы инициали­
зировать графику.

Листинг 10.1. Инициализация устройства.
public void InitializeGraphics{)

{

// Set our presentation parameters
PresentParameters presentParams = new PresentParameters();
presentParams.Windowed = true;
presentParams.SwapEffeet = SwapEffeet.Discard;
// Create our device
device = new Device(0, DeviceType.Hardware, this,
CreateFlags.SoftwareVertexProcessing, presentParams);

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

Зак.
604

194 Часть II. Основные концепции построения графики
protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)

{

device.Clear(ClearFlags.Target, Color.Black, l.Of, 0);

device.BeginScene();

//Draw some lines

DrawRandomLines();

device.EndScene();

device.Present();

// Let them show for a few seconds
System.Threading.Thread.Sleep(250);

this. Invalidated;

}

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

Листинг 10.2. Рисование произвольно появляющихся линий.
private void DrawRandomLines()
(
Random r = new Random();
int numberLines = r.Next(50);
using (Line 1 = new Line (device))

{

for (int i = 0; i < numberLines; i++)

{

int numVectors = 0;
while (numVectors < 2)
numVectors = r.Next(4);
Vector2[] vecs = new Vector2[numVectors];
for(int inner = 0; inner < vecs.Length; inner++)
{

vecs[inner] = new Vector2(r.Next(this.Width),
r.Next(this.Height));

}

II Color

Color с = Color.FromArgb(r.Next(byte.MaxValue),
r.Next(byte.MaxValue), r.Next(byte.MaxValue));
int width = 0;
while (width == 0)
width = r.Next(this.Width / 100);
// Set the width

Глава 10. Использование вспомогательных классов
195
l.Width = width;
// Should they be antialiased?
l.Antialias = r.Next(50) > 25 ? true : false;
// Draw the line

l.Begin();

l.Draw(vecs, c);

l.End();

}
}
}
Каждый раз при вызове метода сначала определяется случайным об­
разом число линий для рисования, максимум 50 линий. Затем создается
отдельный объект line, для прорисовки каждой линии. Возможно также
создание одного общего объекта для всех линий.
Затем случайным образом выбирается число точек в линии, минимум
две, после чего выбирается случайное положение для этих точек (началь­
ной и конечной) с учетом ширины и высоты нашего окна. Также выбира­
ется случайный цвет и ширина линии (также с учетом размеров окна).
Режим сглаживания выбирается случайным образом. В зависимости от
истинного или ложного значения логической переменной сглаживания,
линии будут отображаться соответственно либо «зубчатыми», либо бо­
лее сглаженными.
Следует обратить внимание на связку begin/draw/end в листинге
10.2, определяющую рисование линии. Существуют и другие вариан­
ты рисования линии, например, булева переменная GILines, которая
определяет, должны ли использоваться линии стиля OpenGL или нет
(для выбора по умолчанию устанавливается значение «false»). Можно
также использовать метод DrawTransform для рисования линий в трех­
мерном пространстве, а не в используемых здесь аппаратных коорди­

натах.

Итак, теперь необходимо переписать основной метод следующим об­

разом:

static void Main()

{

using (Forml frm = new Forml()
(
// Show our form and initialize our graphics engine

frm.Show() ;

frm.InitializeGraphics();

Application.Run(frm);

}
}

196 Часть II. Основные концепции построения графики
При выполнении этого приложения экран заполняется набором бес­
порядочно расположенных линий различных размеров, как гладких, так
и «зазубренных». Количество линий на экране будет изменяться случай­
ным образом, как на рис.10.1.
Рис. 10.1. Изображение случайных линий на экране

Отображение текста

Мы уже обсуждали некоторые вопросы, касающиеся отображения
текста на экране, однако, это было довольно поверхностное изучение.
Теперь рассмотрим эти вопросы более подробно. Напомним, в предыду­
щих примерах для объекта шрифта Font имелись два пространства имен
Microsoft.DirectX.Direct3D и System.Drawing, которые необходимо раз­

личать.

Как и раньше, мы можем переименовать используемый класс в соот­

ветствии со следующей директивой «using»:

using Direct3D = Microsoft.DirectX.Direct3D;

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

Глава 10. Использование вспомогательных классов 197
private Direct3D.Font font = null;
private Mesh mesh = null;

private Material meshMaterial;

private float angle = O.Of;

Здесь мы объявляем шрифт и материалы отображаемого текста. В ка­
честве объекта выбирается несложный тесненный текст. Угловой пара­
метр (angle parameter), который мы использовали и ранее, позволит трех­
мерному тексту вращаться со скоростью, зависящей от скорости смены
кадров. Теперь необходимо инициализировать графику, используя метод,
приведенный в листинге 10.3.

Листинг 10.3. Инициализация графики для рисования фрагмента текста.
public void InitializeGraphicsf)
i
// Set our presentation parameters
PresentParameters presentPararas = new PresentParametersO;
presentParams.Windowed = true;
presentParams.SwapEffect = SwapEffeet.Discard;
presentParams.AutoDepthStencilFormat = DepthFormat.D16;
presentParams.EnableAutoDepthStencil = true;
// Create our device
device = new Device(0, DeviceType.Hardware, this,
CreateFlags.SoftwareVertexProcessing, presentParams);
device.DeviceReset += new System.EventHandler(this.OnDeviceReset);

OnDeviceReset(device, null);

// What font do we want to use?
System.Drawing.Font localFont = new System.Drawing.Font
("Arial", 14.Of, FontStyle.Italic);
// Create an extruded version of this font
mesh = Mesh.TextFromFont(device, localFont, "Managed DirectX",

O.OOlf, 0.4f);

// Create a material for our text mesh
meshMaterial = new Material!);
meshMaterial.Diffuse = Color.Peru;
// Create a font we can draw with
font = new Direct3D.Font(device, localFont);

Таким образом, мы создаем аппаратное устройство с буфером глуби­
ны, и отслеживаем событие сброса устройства DeviceReset. Поскольку
нам необходимо устанавливать освещение и камеру каждый раз после
сброса устройства, мы привяжем выполнение этого кода к обработчику
событий. Затем с помощью System.Drawing.Font мы задаем шрифт, кото-

198 Часть II. Основные концепции построения графики
рый будем использовать как основной при рисовании двух- и трехмер­
ных фрагментов тестов. Для данного примера выбран шрифт Arial 14,
хотя это не принципиально.
Итак, сначала мы создаем трехмерный объект текста в виде теснен­
ной надписи «Managed DirectX», причем создаем отдельный mesh для
каждой отображаемой строки. Затем мы определяем материал и цвет ото­
бражаемого 2D-шрифта.
РЕНДЕРИНГ ОБЪЕМНОГО ТЕСНЕННОГО ТЕКСТА

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

быть выполнен с помощью двух простых треугольников, тогда как

при отображении трехмерного тесненного текста могут понадобить­

ся тысячи треугольников.

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

private void OnDeviceReset(object sender, EventArgs e)
(

Device dev = (Device)sender;
dev.Transform.Projection = Matrix.PerspectiveFovLH(
(float)Math.PI / 4, this.Width / this.Height, l.Of, 100.Of);
dev.Transform.View = Matrix.LookAtLH(new Vector3(0,0, -9.Of),
new Vector3(), new Vector3(0,1,0));
dev.Lights[0].Type = LightType.Directional;
dev.Lights[0].Diffuse = Color.White;
dev.Lights[0].Direction = new Vector3(0, 0, 1);
dev.Lights[0].Commit();
dev.Lights[0].Enabled = true;

}

Камера и освещение выбираются только для трехмерного тесненного
текста. Для двухмерного текста, который предварительно преобразован
и освещен, эти опции не востребованы.
Теперь добавим метод, который будет рисовать трехмерный теснен­
ный текст:
private void Draw3DText(Vector3 axis, Vector3 location)
{
device.Transform.World = Matrix.RotationAxis(

axis, angle) *

Matrix.Translation(location);

device.Material = meshMaterial;
mesh.DrawSubset(O);

Глава 10. Использование вспомогательных классов 199

angle += O.Olf;

}
Как вы можете видеть, мы пересылаем координаты mesh-объекта в
мировом пространстве и оси, относительно которых будет вращаться
текст. Данный метод рисования напоминает метод DrawMesh, который
мы использовали в предыдущих примерах, он просто задает материал и
рисует первое подмножество тесненного объекта (для этого объекта это
будет только одно подмножество). Далее мы увеличиваем угловой пара­
метр. В нашем случае при управлении «анимацией» мы будем привязы­
вать скорость перемещения объекта к частоте смены кадров (как мы уже
выясняли, это не совсем обосновано, но пока остановимся на этом). Те­
перь добавим метод рисования 2D-текста:

private void Draw2DText (string text, int x, int y, Color c)

{

font.DrawText(null, text, new Rectangle(x, y,
this.Width , this.Height ),
DrawTextFormat.NoClip | DrawTextFormat.ExpandTabs !
DrawTextFormat.WordBreak , c);

}

Здесь мы пересылаем текст, который хотим отобразить, и местораспо­
ложение (в аппаратных координатах устройства) верхнего левого угла
текста. Последний параметр, естественно, — цвет. Обратите внимание
на то, что в нашем запросе к DrawText мы включаем ширину и высоту
окна отображения, а также пересылаем флажок WordBreak (перенос стро­
ки). Все это позволяет управлять переходом текста на новую строку или
в новое положение, учитывая размер соответствующего ограничиваю­
щего прямоугольника.
Теперь мы можем выполнить процедуру рендеринга текстового фраг­
мента, для этого необходимо переписать наш метод OnPaint, см. лис­
тинг 10.4.

Листинг 10.4. Рендеринг фрагмента текста.
protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)

{
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, l.Of, 0);
device.BeginScene();
Draw2DText("Here's some text", 10, 10, Color.WhiteSmoke);
Draw2DText("Here's some text\r\nwith\r\nhard\r\nline breaks",
100, 80, Color.Violet);
Draw2DText("This\tis\tsome\ttext\twith\ttabs.",

200 Часть II. Основные концепции построения графики
this.Width / 2, this.Height - 80 , Color.RoyalBlue);
Draw2DText("If you type enough words in a single sentence, " +
"you may notice that the text begins to wrap. Try resizing " +
"the window to notice how the text changes as you size it.",
this.Width / 2 + this.Width / 4, this.Height / 4 , Color.Yellow);
// Draw our two spinning meshes
Draw3DText(new Vector3(l.Of, 1.Of, O.Of),

new Vector3(-3.0f, O.Of, O.Of));

Draw3DText(new Vector3(O.Of, l.Of, l.Of),
new Vector3(0.0f, -l.Of, l.Of)) ;

device.EndScene();

device.Present ();

this.Invalidated;

}

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

static void Main()

{
using (Forml frm = new Forml()

{

// Show our form and initialize our graphics engine

frm.Show() ;

frm.InitializeGraphics() ;

Application.Run(frm);

}
}

РАСШИРЕННЫЕ ВОЗМОЖНОСТИ ШРИФТА

Класс Font рисует текст, основываясь на текстурах, которые созда­

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

графический интерфейс GDI и может быть на самом деле достаточ­

но медленным. Возможно, было бы целесообразнее вызвать два

метода предварительной загрузки класса Font в течение запуска,

например: PreloadCharacters, чтобы загрузить определенный набор

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

При запуске приложения на экране отобразится текст, который можно
увидеть на рис. 10.2. Размеры окна, как и размер текстов, можно изменять.

Глава 10. Использование вспомогательных классов 201
Рис. 10.2. Отображаемый текст

Рендеринг на поверхности

Если вы когда-нибудь запускали гоночный симулятор, то наверняка
помните о возможности использования зеркала заднего обзора. Эти эф­
фекты можно получить, отображая ту же самую сцену (несколько раз с
различной привязкой камеры) на имеющуюся текстуру. На первый взгляд
это кажется довольно сложным, но на самом деле это вполне реализуе­
мо. Вернемся к примеру из главы 5 и попробуем изменить его должным
образом. Естественно, в начале нам необходимо объявить новую тексту­
ру, которую мы будем отображать, плюс, некоторые параметры, которые
следует добавить сразу:

private Texture renderTexture = null;
private Surface renderSurface = null;
private RenderToSurface rts = null;
private const int RenderSurfaceSize = 128;

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

202
Часть II. Основные концепции построения графики
device = new Device(0, DeviceType.Hardware, this,
CreateFlags.SoftwareVertexProcessing, presentParams);
device.DeviceReset +=new EventHandler(OnDeviceReset);
OnDeviceReset(device, null);
Задание параметров и поддерживаемых устройством опций приведе­
но в листинге 10.5.

Листинг 10.5. Сброс устройства или установка параметров по умолчанию
private void OnDeviceReset(object sender, EventArgs e)

{

Device dev = (Device)sender;
if (dev.DeviceCaps.VertexProcessingCaps.SupportsDirectionalLights)
f uint maxLights = (uint)dev.DeviceCaps.MaxActiveLights;
if (maxLights > 0)

{

dev.Lights[0].Type = LightType.Directional;
dev.Lights[0].Diffuse = Color.White;
dev.Lights[0].Direction = new Vector3(0, -1, -1);

dev.Lights[0].Commit();

dev.Lights[0].Enabled = true;

}

if (maxLights > 1)

{

dev.Lights[l].Type = LightType.Directional;
dev.Lights[l].Diffuse = Color.White;
dev.Lights[l].Direction = new Vector3(0, -1, 1);

dev.Lights[l].Commit();

dev.Lights[l].Enabled = true;

}

}

rts = new RenderToSurface(dev, RenderSurfaceSize, RenderSurfaceSize,
Format.X8R8G8B8, true, DepthFormat.D16);
renderTexture = new Texture(dev, RenderSurfaceSize, RenderSurfaceSize, 1,
Usage.RenderTarget, Format.X8R8G8B8, Pool.Default);
renderSurface = renderTexture.GetSurfaceLevel(O);

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

Глава 10. Использование вспомогательных классов
203

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

тия сброса, необходимо удалить данную установку из метода SetupCamera,

уже существующего в этом примере. Далее нужно добавить новый метод
для рендеринга объекта на поверхность, см. метод, приведенный в лис­
тинге 10.6.

Листинг 10.6. Рендеринг на поверхность.
private void RenderlntoSurface()

f

// Render to this surface
Viewport view = new Viewport();
view.Width = RenderSurfaceSize;
view.Height = RenderSurfaceSize;
view.MaxZ = l.Of;

rts.BeginScene(renderSurface, view);

device.Clear(ClearFlags.Target ! ClearFlags.ZBuffer, Color.DarkBlue, l.Of,

Ob-

device.Transform.Projection = Matrix.PerspectiveFovLH((float)Math.PI / 4,
this.Width / this.Height, l.Of, 10000.Of);
device.Transform.View = Matrix.LookAtLH(new Vector3(0,0, -580.Of),

new Vector3(), new Vector3(0, 1,0));

DrawMesh(angle / (float)Math.PI, angle / (float)Math.PI * 2.Of,
angle / (float)Math.PI / 4.Of, O.Of, O.Of, O.Of);
DrawMesh(angle / (float(Math.PI, angle / (float)Math.PI / 2.Of,
angle / (float)Math.PI * 4.Of, 150.Of, -100.Of, 175.Of);

rts.EndScene(Filter.None);

)

Данный код представляет собой обычный метод рендеринга. Мы вы­
зываем сцену, устанавливаем камеру и рисуем наш объект. Затем мы вы-

204 Часть II. Основные концепции построения графики
зываем текстуры для нашей сцены и отображаем каждый элемент сцены.
В данном случае, помимо обычного расположения камеры, мы еще рас­
полагаем камеру и с другой стороны нашей модели, чтобы мы могли ви­
деть, что происходит, если б находились «сзади» модели. Обратите так­
же внимание, что в этой сцене у нас имеется два варианта отображения:
первый, когда мы видим только одну модель (представление спереди, по
умолчанию), и второй, когда мы добавляем изображение модели с распо­
ложенной позади объекта камеры (в этом случае мы будем видеть обе

модели).

Параметром процедуры BeginScene является поверхность, на которую
будет осуществлен рендеринг объекта. Поскольку мы используем повер­
хность, восстановленную или полученную из текстуры, любые обновле­
ния этой поверхности будут отражаться и на текстуре. Метод EndScene
позволяет использовать текстурную фильтрацию для нашей поверхнос­
ти. В нашем примере мы пока не знаем ничего о поддержке устройством
данного фильтра, поэтому фильтрацию опускаем. Последнее, на что сле­
дует обратить внимание, — мы изменили цвет для текстурируемой сце­
ны, для того чтобы показать различие между «реальной» сценой и той,
«другой» сценой.
Таким образом, мы должны слегка изменить наш метод рендеринга.
Для начала необходимо отобразить сцену в нашу текстуру прежде, чем
мы начнем отображать ее в нашем основном окне. Добавьте вызов к на­
шему методу в качестве первого пункта в методе OnPaint:

RenderlntoSurfасе();

Далее мы хотим разместить текстуру на экране. В нашем примере мы

можем использовать один из вспомогательных классов, называемый Sprite

(более подробно мы его обсудим главой позже). Данный класс позволяет
простым образом отображать текстуру в аппаратных координатах уст­
ройства. Добавьте следующую секцию кода перед методом завершения
сцены EndScene:

using (Sprite s = new Sprite(device))
( s.Begin(SpriteFlags.None);
s.Draw(renderTexture, new Rectangle(O, 0, RenderSurfaceSize,
RenderSurfaceSize), new Vector3(0, 0, 0), new Vector3(0, 0, l.Of),

Color.White);

s.End();

}

Этот код просто отображает поверхность всей текстуры в левом верх­
нем углу экрана. Результат рендеринга можно увидеть на рис. 10.3.

Глава 10. Использование вспомогательных классов
205

Рис. 10.3. Рендеринг на поверхность

Рендеринг текстур Environment Maps

Environment Maps — карты окружающей среды, использующиеся для
моделирования рельефных поверхностей, например, при отображении
облаков, перемещающихся объектов и пр. Наиболее общий способ для
реализации этих карт состоит в том, чтобы использовать кубическую
(шестисторонную) текстуру.
Прежде чем начать писать соответствующий код, необходимо создать
новый проект и выполнить все необходимые приготовления (включая
добавление ссылок, переменных устройства, установки окон и пр.). Так­
же понадобятся два объекта (которые включены в DirectX SDK) — мо­
дель автомобиля и модель неба skybox2 (с соответствующими текстура-
ми). После чего объявляются следующие переменные:

private Mesh skybox = null;
private Material[] skyboxMaterials;
private Texture[] skyboxTextures;
private Mesh car = null;
private Material[] carMaterials;
private Textured carTextures;
private CubeTexture environment = null;
private RenderToEnvironmentMap rte = null;
private const int CubeMapSize = 128;
private readonly Matrix ViewMatrix = Matrix.Translation(0.Of, O.Of, 13.Of);

206
Часть II. Основные концепции построения графики

Итак, мы описали два mesh-объекта для рисования: небо (наша окру­
жающая среда) и автомобиль, на который мы хотим «отражать» окружа­
ющую среду. Также необходимо иметь кубическую текстуру, которая со­
хранит среду, и вспогательный класс для отображения карты среды.
Но, прежде всего, мы должны выяснить, поддерживает ли наша карта
кубические текстуры или нет. Поэтому нам нужен новый графический
метод инициализации нашего устройства, см. листинг 10.7.

Листинг 10.7. Инициализация устройства для отображения карт
public bool InitializeGraphicsO
(
// Set our presentation parameters
PresentParameters presentParams = new PresentParametersO;
presentParams.Windowed = true;
presentParams.SwapEffeet = SwapEffeet.Discard;
presentParams.AutoDepthStencilFormat = DepthFormat.D16;
presentParams.EnableAutoDepthStencil = true;
// Create our device
device = new Device(0, DeviceType.Hardware, this,
CreateFlags.SoftwareVertexProcessing, presentParams);
device.DeviceReset +=new EventHandler(OnDeviceReset);

OnDeviceReset(device, null);

// Do we support cube maps?
if (!device.DeviceCaps.TextureCaps.SupportsCubeMap)
return false;
// Load our meshes
skybox = LoadMesh(@"..\..\skybox2.x", ref skyboxMaterials,
ref skyboxTextures);
car = LoadMesh(@".,\..\car.x", ref carMaterials, ref carlextures)
return true;

}

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

static void Main()

{

using (Forml frm = new Forml())
(
// Show our form and initialize our graphics engine

frm.Show();

Глава 10. Использование вспомогательных классов 207

if (lfrm.InitializeGraphi.es ())

{

MessageBox.Show("Your card does not support cube maps.");

frm. Closed;

}

else

{

Application.Run(frm);

}
}

}

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

Листинг 10.8. Загрузка объекта с данными нормалей.
private Mesh LoadMesh(string file,ref Material[] meshMaterials,ref
Texture[] meshTextures)

{

ExtendedMaterial[] mtrl;
// Load our mesh
Mesh mesh = Mesh.FromFile(file, MeshFlags.Managed, device, out mtrl);
// If we have any materials, store them
if ((mtrl != null) SS (mtrl.Length > 0))

{

meshMaterials = new Material[mtrl.Length];
meshTextures = new Texture[mtrl.Length];
// Store each material and texture
for (int i = 0; i < mtrl.Length; i++)

{

meshMaterials[i] = mtrl[i],Material3D;
if ((mtrl[i].TextureFilename != null) 4&
(mtrl[i].TextureFilename != string.Empty))

{

//We have a texture, try to load it
meshTextures[i] = TextureLoader.FromFile(device, @"..\..\" +

mtrl[i].TextureFilename);

}

}

}
if ((mesh.VertexFormat & VertexFormats.Normal) != VertexFormats.Normal)

{

208
Часть II. Основные концепции построения графики

// We must have normals for our patch meshes
Mesh tempMesh = mesh.Clone(mesh.Options.Value,
mesh.VertexFormat | VertexFormats.Normal, device);
tempMesh.ComputeNormals();
mesh.Disposed;
mesh = tempMesh;

}

return mesh;

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

private void OnDeviceReset(object sender, EventArgs e)
(
Device dev = (Device)sender;
rte = new RenderToEnvironmentMapjdev, CubeMapSize, 1,
Format.X8R8G8B8, true, DepthFormat.D16);
environment = new CubeTexture(dev, CubeMapSize, 1,
Usage.RenderTarget, Format.X8R8G8B8, Pool.Default);

}
Мы создали вспомогательный класс и кубическую текстуру. Чем боль­
ший размер вы пересылаете (в нашем случае константа CubeMapSize),
тем более детальной получится карта среды. Во многих случаях более
эффективным было бы сохранять карту окружающей среды статически,
тогда вы могли бы просто загружать кубическую текстуру из файла (или
другого источника данных). Однако, здесь мы хотим показать карту сре­
ды, создаваемую динамически, исходя из отображаемой сцены, поэтому
мы создаем текстуру для рендеринга.
В последнем примере мы отображали сцену в отдельную текстуру, а в
данном случае помимо этого мы по крайней мере шесть раз (для каждой
стороны нашей карты куба) осуществим рендеринг нашей сцены,. До­
бавьте метод, приведенный в листинге 10.9, к вашему приложению.

Листинг 10.9. Рендеринг карты окружающей сцены.
private void RenderScenelntoEnvMap()

{

// Set the projection matrix for a field of view of 90 degrees
Matrix matProj;
matProj = Matrix.PerspectiveFovLH((float)Math.PI * 0.5f, l.Of,

0.5f, 1000.Of);

// Get the current view matrix, to concat it with the cubemap view vectors

Глава 10. Использование вспомогательных классов
209
Matrix matViewDir = ViewMatrix;
matViewDir.M41 = O.Of; matViewDir.M42 = O.Of; matViewDir.M43 = O.Of;
// Render the six cube faces into the environment map
if (environment != null)
rte.BeginCube(environment);
for (int
i =
0;
i <
6; i++)

{

rte.Facef(CubeMapFace) i , 1);
// Set the view transform for this cubemap surface
Matrix matView = Matrix.Multiply(matViewDir,
GetCubeMapViewMatrix((CubeMapFace) i));
// Render the scene (except for the teapot)
RenderScene(matView, matProj, false);

}

rte.End(l);

)

Итак, сначала мы создаем матрицу проекции с полем зрения 90 граду­
сов (соответствует углам между гранями куба). Затем получаем матрицу
вида, которую мы сохранили для этого приложения и изменяем после­
днюю строку матрицы таким образом, чтобы можно было объединить ее
с матрицами вида для каждой стороны куба.
Далее мы вызываем метод BeginCube, принадлежащий вспомогатель­
ному классу, для создания кубической карты окружающей среды. В этом
классе имеются и другие методы создания карт среды, включая
BeginHemisphere и BeginParabolic (использующие две поверхности, одна
для положительной ветви Z, другая для отрицательной), а также
BeginSphere (использующий единственную поверхность).
Когда карта среды готова для отображения, мы запускаем цикл для
каждой стороны куба. Далее для каждой стороны мы вначале вызываем
метод Face, аналогичный методу BeginScene, который мы использовали
для нашего устройства, и текстурные рендеры. Метод «отслеживает» со­
бытие, когда последняя сторона закончена, а новая готова к отображе­
нию. Затем мы объединяем текущую матрицу вида с теми, которые были
получены в методе GetCubeMapViewMatrix. Данный метод приведен в
листинге 10.10.

Листинг 10.10. Создание матрицы вида, ViewMatrix.
private Matrix GetCubeMapViewMatrix(CubeMapFace face)

{

Vector3 vEyePt = new Vector3(0.0f, O.Of, O.Of);
Vector3 vLookDir = new Vector3();
Vector3 vUpDir = new Vector3();
switch (face)

210
Часть II. Основные концепции построения графики

case CubeMapFace.PositiveX:
vLookDir = new Vector3(1.0f, O.Of, O.Of);
vUpDir = new Vector3(O.Of, l.Of, O.Of);
break;
case CubeMapFace.NegativeX:
vLookDir = new Vector3(-1.0f, O.Of, O.Of);
vUpDir = new Vector3(0.0f, l.Of, O.Of);
break;
case CubeMapFace.PositiveY:
vLookDir = new Vector3(0.0f, l.Of, O.Of);
vUpDir = new Vector3(O.Of, O.Of,-l.Of);
break;
case CubeMapFace.NegativeY:
vLookDir = new Vector3(O.Of,-l.Of, O.Of);
vUpDir = new Vector3(O.Of, O.Of, l.Of);
break;
case CubeMapFace.PositiveZ:
vLookDir = new Vector3(0.0f, O.Of, l.Of);
vUpDir = new Vector3(0.0f, l.Of, O.Of);
break;
case CubeMapFace.NegativeZ:
vLookDir = new Vector3(0.0f, 0.Of,-l.Of);
vUpDir = new Vector3(0.0f, l.Of, O.Of);
break;

}

// Set the view transform for this cubemap surface
Matrix matView = Matrix.LookAtLH(vEyePt, vLookDir, vUpDir);
return matView;

}
Здесь мы просто изменяем параметры вида в зависимости от того, на
какую сторону мы смотрим, и возвращаем матрицу вида, составленную
на основе этих векторов. После всех этих действий мы отображаем всю
сцену без освещенного солнцем автомобиля (параметр «false» в методе
RenderScene). Добавьте код, приведенный в листинге 10.11.

Листинг 10.11. Рендеринг всей сцены.
private void RenderScene(Matrix View, Matrix Project, bool shouldRenderCar)

{
// Render the skybox first
device.Transform.World = Matrix.Scaling(10.Of, 10.Of, lO.Of);
Matrix matView = View;
matView.M41 = matView.M42 = matView.M43 = O.Of;
device.Transform.View = matView;
device.Transform.Projection = Project;

Глава 10. Использование вспомогательных классов
211
device.TextureState[0].ColorArgumentl = TextureArgument.TextureColor;
device,TextureStateiO].ColorOperation = TextureOperation.SelectArgl;
device.SamplerState[0].MinFilter = TextureFilter.Linear;
device.SamplerState[0].MagFilter = TextureFilter.Linear;
device.SamplerState[0].AddressU = TextureAddress.Mirror;
device.SamplerState[0].AddressV = TextureAddress.Mirror;
// Always pass Z-test, so we can avoid clearing color and depth buffers
device.RenderState.ZBufferFunction = Compare.Always;
DrawSkyBoxO;
device.RenderState.ZBufferFunction = Compare.LessEqual;
// Render the shiny car
if (shouldRenderCar)
(
// Render the car
device.Transform.View = View;
device.Transform.Projection = Project;
using (VertexBuffer vb = car.VertexBuffer)

{

using (IndexBuffer ib = car.IndexBuffer)
(
// Set the stream source
device.SetStreamSource(0, vb, 0,
VertexInformation.GetFormatSize(car.VertexFormat));
// And the vertex format and indices
device.VertexFormat = car.VertexFormat;
device.Indices = ib;
device.SetTexture(0, environment);
device.SamplerState[0].MinFilter = TextureFilter.Linear;
device.SamplerState[0].MagFilter = TextureFilter.Linear;
device.SamplerState[0].AddressQ = TextureAddress.Clamp;
device.SamplerState[0].AddressV = TextureAddress.Clamp;
device.SamplerState[0].AddressW = TextureAddress.Clamp;
device.TextureState[0].ColorOperation =
TextureOperation.SelectArgl;
device.TextureState[0].ColorArgumentl =
TextureArgument.TextureColor;
device.TextureState[0].TextureCoordinatelndex =
(int)TextureCoordinatelndex.CameraSpaceReflectionVector;
device. TextureState[0].TextureTransform =
TextureTransform.Count3;
device.Transform.World = Matrix.RotationYawPitchRoll(
angle / (float)Math.PI, angle / (float)Math.PI * 2.Of,
angle / (float)Math.PI / 4.0f);
angle += O.Olf;
device.DrawIndexedPrimitives(PrimitiveType.TriangleList,
0, 0, car.NumberVertices, 0, car.NumberFaces);

}
}
}

}

212
Часть II. Основные концепции построения графики

Первое, что мы здесь делаем, — отображаем объект skybox. Посколь­
ку мы знаем, что размер skybox меньше, чем нам необходимо, мы увели­
чиваем его в 10 раз. Затем мы задаем текстуру и состояние сэмплера,
который необходим для рендеринга текстуры skybox (с этим можно оз­
накомиться в документах MSDN).
Если вы обратили внимание, мы никогда не очищали устройство в
наших примерах. Поскольку нам бы не хотелось вызывать эту процеду­
ру при отображении каждой из сторон куба, мы выполняем ее до ото­
бражения карты среды skybox (которая, как мы знаем, будет иметь са­
мое большое значение глубины в нашей сцене) и устанавливаем состо­
яние рендера таким образом, чтобы буфер глубины был всегда досту­
пен во время отображения текстуры skybox. С другой стороны, мы ото­
бражаем текстуру skybox и переключаем функцию буфера глубины на­
зад к нормали. Выполнение метода Skybox должно показаться знако­
мым для нас:

private void DrawSkyBoxO

(
for (int i = 0; i < skyboxMaterials.Length; i++)
(
device.Material = skyboxMaterials[i];
device.SetTexture(0, skyboxTextures[i]);
skybox.DrawSubset(i) ;
)
)
После рендеринга текстуры skybox необходимо решить, будем ли мы
отображать автомобиль, также используя пересылаемый параметр. Если
это так, необходимо сбросить процедуру преобразования вида и проек­
ции. Теперь, поскольку мы хотим управлять созданием координат тек­
стур автоматически, мы не будем использовать метод DrawSubset для
нашего объекта.
Вместо этого мы будем использовать вершинный и индексный буфе­
ры непосредственно, для чего вызовем метод DrawIndexedPrimitives.
После этого мы должны быть уверены, что устройство готово к ренде­
рингу объекта.
Вначале мы задаем источник потоковых данных для вершинного бу­
фера из нашего объекта. Также мы, опираясь на наш объект, устанавли­
ваем формат вершин и индексный буфер. Далее мы определяем кубичес­
кую текстуру и рисуем наши примитивы. Обратите внимание на следую­
щие строки:

device.TextureState[0].TextureCoordinatelndex =
(int)TextureCoordinatelndex.CameraSpaceReflectionVector;
device.TextureState[0].TextureTransform = TextureTransform.Count3;

Глава 10. Использование вспомогательных классов 213
Так как мы не имеем координат текстуры объекта автомобиль, первая
строка подразумевает использование вектора отражения (преобразован­
ного в пространстве камеры) вместо использования координат текстур.
Значения вектора автоматически сгенерированы в непрограммируемом

конвейере fixedfunction pipeline, использующем данные местоположения

вершины и нормали к нашей ЗD-текстуре.
Теперь мы можем преобразовать координаты и нарисовать наши при­
митивы. Приложение практически готово к выполнению, но сначала мы
должны добавить наш метод рендеринга:

protected override void 0nPaint(System.Windows.Forms.PaintEventArgs e)
[
RenderScenelntoEnvMap();
device.BeginSceneO;
RenderScene(ViewMatrix, Matrix.PerspectiveFovLHf(float)Math.PI / 4,

this.Width / this.Height, l.Of, 10000.Of), true);

device. EndSceneO;

device.Present!);

this.Invalidate!);

I

Для каждого рендера мы сначала отображаем карту окружающей сре­
ды и уже затем отображаем нашу «реальную» сцену, включая автомобиль.
Приложение готово к запуску. В результате мы должны увидеть на экране
освещенный солнцем автомобиль, вращающийся на фоне неба, рис. 10.4.
Рис. 10.4. Изображение автомобиля и окружающего фона

214 Часть II. Основные концепции построения графики

Краткие выводы

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

ЧАСТЬ III

БОЛЕЕ СОВЕРШЕННЫЕ МЕТОДЫ

ПОСТРОЕНИЯ ГРАФИКИ

Глава 11. Введение в программируемый конвейер, язык
шейдеров
Глава 12. Использование языка шейдеров HLSL
Глава 13. Рендеринг скелетной анимации

216 Часть III. Более совершенные методы построения графики

Глава 11. Введение

в программируемый конвейер,

язык шеидеров

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

вершинных шеидеров и обработкой пикселей с помощью пиксельных шеи­

деров. Программы, использующие язык шеидеров оказались весьма мощ­
ными, но на тот момент не совсем удобными. Синтаксис языка напоми­
нал ассемблирование и требовал некоторых доработок и упрощений.
В Управляемом DirectX 9 был реализован язык HLSL — язык шеиде­
ров высокого уровня. Язык HLSL был более простым для разработчиков
и напоминал язык С, который мог быть откомпилирован в реальный код
шейдера. Таким образом, могли быть реализованы все преимущества
программируемого конвейера в более доступной и удобной форме. В этой

главе мы рассмотрим основные особенности языка шеидеров HLSL, вклю­

чая.

Использование программируемого конвейера.
Преобразование вершин с помощью шеидеров.
• Использование пиксельных шеидеров.

Рендеринг треугольника с использованием

программируемого конвейера

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

Глава 11. Введение в программируемый конвейер, язык шейдеров 217
Одним из главных недостатков такого подхода являлось то, что для
каждого отдельного свойства или возможности, которую графическая
карта должна реализовать, необходимо было использовать непрограм­
мируемый API интерфейс. С быстрым развитием аппаратной части ком­
пьютерной графики (даже более быстрым, чем, например, процессоров),
число интерфейсов API быстро бы вышло из-под контроля. Кроме того,
не было возможности управлять интерфейсами, что весьма необходимо
для разработчиков компьютерной графики (особенно разработчиков игр).
Если вспомнить, одним из первых приложений, рассмотренных в этой
книге, было отображение вращающегося треугольника. Это было весьма

просто сделать с использованием непрограммируемого конвейера. Теперь

для этого примера мы будем использовать программируемый конвейер.
Как обычно, вначале создаем новые формы windows-приложения, объяв­
ляем переменную устройства, стиль окна и т. д. Для этого добавим сле­
дующие переменные:

private VertexBuffer vb = null;
private Effect effect = null;
private VertexDeclaration decl = null;
// Our matrices
private Matrix worldMatrix;
private Matrix viewMatrix;
private Matrix projMatrix;
private float angle = 0. Of;

Естественно, мы будем записывать данные вершин в вершинном бу­
фере. Необходимо также сохранить матрицы преобразования до того
момента, когда мы будем использовать их в программируемом конвей­
ере. Вторая и третья переменные, описанные здесь, — новые для нас.
Effect object— главный объект, который вы будете использовать при
программировании на языке шейдеров HLSL. Класс объявления вер­
шин VertexDeclaration подобен вершинному формату в непрограмми­
руемом конвейере. Данный класс сообщает приложению Direct3D
runtime о размере и типах данных, которые будут считываться из вер­
шинного буфера.
Поскольку это приложение будет использовать относительно новую
возможность графических карт, а именно программируемый конвейер,
вполне возможно, что ваша графическая плата не будет поддерживать
эту опцию. Если это так, необходимо подключить ссылки на эмулиро­
ванное устройство, которое включено в DirectX SDK, другим словами,
создать программную эмуляцию устройства. Для данного случая работа
API будет выполняться несколько медленнее, и возникает необходимость
в использовании более быстрой процедуры инициализации нашего уст­
ройства, см. листинг 11.1.

218 Часть III. Более совершенные методы построения графики

Листинг 11.1. Инициализация графики, проверка поддерживаемых режимов
(Fallback).
public bool InitializeGraphics()

{

// Set our presentation parameters
PresentParameters presentParams = new PresentParameters();
presentParams.Windowed = true;
presentParams.SwapEffeet = SwapEffeet.Discard;
presentParams.AutoDepthStencilFormat = DepthFormat.D16;
presentParams.EnableAutoDepthStencil = true;
bool canDoShaders = true;
// Does a hardware device support shaders?
Caps hardware = Manager.GetDeviceCapsfO, DeviceType.Hardware);
if (hardware.VertexShaderVersion >= new Version(1, 1))

{

// Default to software processing
CreateFlags flags = CreateFlags.SoftwareVertexProcessing;
// Use hardware if it's available
if (hardware.DeviceCaps.SupportsHardwareTransformAndLight)
flags = CreateFlags.HardwareVertexProcessing;
// Use pure if it's available
if (hardware.DeviceCaps.SupportsPureDevice)
flags |= CreateFlags.PureDevice;
// Yes, Create our device
device = new Device(0, DeviceType.Hardware, this, flags, presentParamss :

}

else

{

//No shader support
canDoShaders = false;
// Create a reference device
device = new Device(0, DeviceType.Reference, this,
CreateFlags.SoftwareVertexProcessing, presentParams);

}

// Create our vertex data
vb = new VertexBuffer(typeof(CustomVertex.PositionOnly), 3, device,
Usage.Dynamic | Usage.WriteOnly, CustomVertex.PositionOnly.Format,

Pool.Default);

vb.Created += new EventHandler(this.OnVertexBufferCreate);

OnVertexBufferCreate(vb, null);

// Store our project and view matrices
projMatrix = Matrix.PerspectiveFovLH((float)Math.PI / 4,
this.Width / this.Height, l.Of, 100.Of);
viewMatrix = Matrix.LookAtLH(new Vector3(0,0, 5.Of), new Vector3(),

new Vector3(0,1,0));

// Create our vertex declaration

Глава 11. Введение в программируемый конвейер, язык шейдеров 219
VertexElement[] elements = new VertexElement[]
(
new VertexElement(0, 0, DeclarationType.Float3,

DeclarationMethod.Default,

DeclarationUsage.Position, 0),
VertexElement.VertexDeclarationEnd

I;

decl = new VertexDeclaration(device, elements);
return canDoShaders;

}

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

емые им возможности, если вспомнить, данная структура называлась Caps

(возможности).

В настоящем приложении, поскольку здесь мы используем для ренде­
ринга вершин программируемый конвейер, необходимо убедиться, что
наша карта поддерживает по крайней мере шейдеры первого поколения.
С появлением новых версий API версии вершинных и пиксельных шей­
деров также обновлялись. Например, DirectX 9 позволяет нам использо­
вать шейдеры версии 3.0 и старше (хотя в настоящее время нет подходя­
щих графических карт, поддерживающих, к примеру, третью версию).
Первое поколение шейдеров имело версию 1.0. В DirectX 9 эта устарев­
шая версия была заменена версией 1.1, и это то, с чем мы здесь будем

работать.

Предполагая, что карта поддерживает эту версию, мы можем создать
«более продвинутый» тип устройства. Мы задаем по умолчанию про­
граммную обработку вершин, а если устройство поддерживает и аппа­
ратную обработку, будем использовать ее. В случае, если плата не под­
держивает программы шейдеров, нам ничего не остается, кроме как ис­
пользовать программное устройство — эмулятор, которое поддерживает
режим runtime, хотя это будет намного медленнее.
Далее необходимо создать вершинный буфер для нашего отображае­
мого треугольника. Обработчик событий в этом случае будет иметь сле­
дующий вид:

private void OnVertexBufferCreate(object sender, EventArgs e)

{

VertexBuffer buffer = (VertexBuffer)sender;
CustomVertex.PositionOnly[] verts = new CustomVertex.Position0nly[3];

220 Часть III. Более совершенные методы построения графики

verts[0].SetPosition(new Vector3(0.0f, l.Of, l.Of));

verts[l].SetPosition(new Vector3(-1.0f, -l.Of, l.Of));

verts[2].SetPosition(new Vector3(1.0f, -l.Of, l.Of));

buffer.SetData(verts, 0, LockFlags.None);
}
После создания вершинного буфера необходимо сохранить результа­
ты преобразования координат для дальнейшего использования. Данные
преобразования выполняются тем же самым способом, что и раньше, с
единственным отличием — теперь для записи этих данных мы не будем
использовать свойство преобразования устройства.
Итак, мы дошли до процедуры объявления вершин, «сообщающей»
Direct3D всю необходимую информацию о вершинах, которая будет пере­
сылаться в программируемый конвейер. При создании объекта класса •
VertexDeclaration в используемое устройство пересылается массив вершин­
ных элементов, каждый из которых описывает один компонент данных
вершин. Рассмотрим следующий конструктор для элемента вершины:

public VertexElement ( System.Intl6 stream , System.Intl6 offset ,
Microsoft.DirectX.Direct3D.DeclarationType declType ,
Microsoft.DirectX.Direct3D.DeclarationMethod declMetftod ,
Microsoft.DirectX.Direct3D.DeclarationUsage declUsage ,
System.Byte usagelndex )

Первый параметр stream — поток данных о вершинах. Когда мы вы­
зывали метод SetStreamSource, этот параметр представлял собой поток,
пересылаемый в вершинный буфер. До сих пор мы хранили все данные в
одном вершинном буфере, используя один поток; теперь мы можем про­
водить рендеринг объекта, используя данные из различных вершинных
буферов с различными потоками данных. В данном примере, поскольку
мы имеем только один вершинный буфер (поток с нулевым порядковым
номером), мы задаем нулевое значение для этого параметра.
Второй параметр offset — смещение в буфере, где хранятся данные.
Поскольку в нашем случае имеется только один тип данных вершинного
буфера, данное значение также будет нулевым. При использовании не­
скольких типов данных значение смещения задается для каждого. На­
пример, если первый компонент — местоположение вершины (три зна­
чения с плавающей точкой), а второй компонент — нормаль (также три
значения с плавающей точкой), тогда первый компонент будет иметь сме­
щение «О» (поскольку это первый компонент в буфере), тогда как нор­
маль — смещение «12» (четыре байта на каждую цифру).
Третий параметр declType сообщает приложению Direct3D тип ис­
пользуемых данных. Так как в этом примере мы используем только ме­
стоположение вершины, можно использовать тип Float3 (этот тип мы
обсудим позже).

Глава 11. Введение в программируемый конвейер, язык шейдеров 221
Четвертый параметр declMethod описывает используемый метод. В
большинстве случаев (если не используются примитивы более высокого
порядка), метод устанавливается по умолчанию.
Пятый параметр declUsage описывает использование компонентов,
таких как: местоположение, нормаль, цвета и пр. Для описания местопо­
ложения используются три числа с плавающей запятой.
Последний параметр изменяет данные использования, что позволяет
определять множественные типы использования. В большинстве случа­
ев это нулевое значение.
Важно обратить внимание, что ваш массив элементов вершины дол­
жен иметь в качестве последнего значения запись VertexElement.Vertex-
DeclarationEnd. Так, для простого объявления вершины можно использо­
вать поток с нулевым значением номера, состоящий из трех чисел с пла­
вающей запятой, представляющих месторасположения вершины. После
создания массива элементов вершин можно создавать объект объявления
вершины. Окончательно, программа возвращает булеву переменную,
имеющую значение «true», если аппаратное устройство поддерживает
шейдеры, и значение «false», если используется эмулированное устрой­

ство.

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

static void Main()

{

using (Forml frm = new Forml())

{

// Show our form and initialize our graphics engine

frm.Show();

if (Ifrra.InitializeGraphics())
{

MessageBox.Show("Your card does not support shaders. " +
"This application will run in ref mode instead.");

}

Application.Run(frm);

}
}
Теперь осталось вызвать метод рендеринга сцены, который мы исполь­
зовали неоднократно, для этого необходимо переписать метод OnPaint
следующим образом:

protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)

{

device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.CornflowerBlue,
l.Of, 0);

222
Часть III. Более совершенные методы построения графики

UpdateWorldO;

device.BeginScene ();

device.SetStreamSource(0, vb, 0);
device.VertexDeclaration = decl;

device.DrawPrimitives(PrimitiveType.TriangleList, 0, 1);

device.EndScenef);
device.Present ();
this.Invalidate));
}
Затем, после очистки устройства, мы должны вызвать метод преобра­
зования мировых координат, который в данном примере определяет при­
ращение угловой переменной и изменяет сохраненную матрицу преоб­

разований:

private void UpdateWorld()

{

worldMatrix = Matrix.RotationAxis(new Vector3(angle / ((float)Math.PI *

2.Of),

angle / ((float)Math.PI * 4.Of), angle / ((float)Math.PI * 6.0f)),
angle / (float)Math.PI);
angle += O.lf;
)

Достаточно знакомый код, за исключением того, что мы устанавлива­
ем свойство объявления вершины vertex declaration вместо свойства фор­
мата вершины vertex format. Выполняя приложение в том виде, каком
оно есть на данный момент, мы ничего не увидим кроме синего экрана. С

чем это может быть связано? Все достаточно просто, приложение Direct3D

runtime понятия не имеет, что вы хотите сделать. Мы должны написать
реальную «программу» для программируемого конвейера.
Итак, добавьте новый пустой текстовый файл simple.fx к вашему про­
екту. В этот файл мы будем сохранять программу, написанную на языке
HLSL. Теперь необходимо добавить следующий HLSL код в этом файле:

// Shader output, position and diffuse color
struct VS_0UTPUT

{

float4 pos : POSITION;
float4 diff : COLOR0;

};

// The world view and projection matrices
float4x4 HorldViewProj : WORLDVIEWPROJECTION;
float Time = l.Of;
// Transform our coordinates into world space
VS OUTPUT Transform)

Глава 11. Введение в программируемый конвейер, язык шейдеров 223
float4 Pos : POSITION)
{
// Declare our return variable
VS_0UTPUT Out = (VS_OUTPUT)0;
// Transform our position
Out.pos = mul(Pos, WorldViewProj);
// Set our color
Out.diff.r = 1 - Time;

Out.diff.b = Time * WorldViewProj[2].yz;

Out.diff.ga = Time * WorldViewProj[0].xy;

// Return
return Out;

I

Легко заметить, что код HLSL напоминает язык С (и С#). Вначале мы
объявляем структуру, которая будет связывать выходные данные вершин.

Процедура объявления переменных несколько отличается от привычного нам

алгоритма. К каждой переменной была добавлена семантика (другими сло­
вами, тэги, указывающие на переменную класса usage: в нашем случае это
местоположение и первоначальный цвет, соответственно position и color).
Возникает вопрос, почему в структуре вывода находятся и местопо­
ложение, и цвет, тогда как вершинный буфер содержит данные только о
местоположении? Поскольку структура вывода содержит и местополо­
жение, и цвет (вместе с соответствующей семантикой), Direct3D будет
«знать» что рендерингу подлежат новые данные, возвращенные из про­
граммы обработки вершин или вершинных шейдеров, вместо данных,
сохраненных в вершинном буфере.
Далее, имеются две «глобальные» переменные, затрагивающие раз­
личные преобразования: первая — комбинацию матрицы вида, проекции
и пр., и вторая — время анимирования цвета треугольника. Во время
выполнения приложения необходимо обновлять или перезаписывать все
эти параметры для каждого кадра.
Итак, у нас имеется реальный код вершинного шейдера. Как можно
видеть, он возвращает структуру, которую мы уже создали, и принимает
в качестве параметра положение вершин. Этот метод будет вызываться
для каждой из вершин, находящихся в вершинном буфере (в нашем слу­
чае трех). Обратите внимание, что входная переменная также имеет опи­
сание, указывающее приложению Direct3D тип используемых данных.
Сам по себе код внутри приведенного метода весьма прост. Мы объяв­
ляем возвращаемую переменную Out. Далее выполняется процедура пре­
образования, при котором начальное значение местоположения умножа­
ется на сохраненную матрицу преобразования. Здесь используется встро­
енная функция mull, причем ранг матрицы преобразования — float4x4, a
вектора местоположения — float4. Необходимо строго согласовывать
форматы при перемножении в соответствии с известными операциями

224
Часть III. Более совершенные методы построения графики
над матрицами, в противном случае, оператор не выполнит данную опе­
рацию из-за несоответствия типов.
После этого мы определяем цвета, используя простую формулу для
каждого компонента цвета. Сначала устанавливается красный, затем си­
ний и в конце зеленый. Таким образом, установив значения расположе­
ния и цвета, мы имеем заполненную структуру, которая будет использо­
ваться в дальнейших операциях.

ОБЪЯВЛЕНИЕ ПЕРЕМЕННЫХ В ЯЗЫКЕ HLSL И ВСТРОЕННЫЕ ТИПЫ

Обратите внимание на то, что мы используем некоторые встроен­
ные типы, которых нет в языках С или С#, а именно float4 и float4x4.
Следует отметить, что язык шейдеров поддерживает следующие
скалярные типы.

Bool — булева переменная, «true» или «false».

Int — 32-разрядное целое число со знаком.
Half— 16-разрядное число с плавающей запятой.
Float — 32-разрядное число с плавающей запятой.
Double — 64-разрядное число с плавающей запятой.
Объявление переменных этих типов просходит также, как и в языке
С#. Однако, добавление отдельного целого числа в конце одного
из этих скалярных типов объявит «векторный» тип. Векторные типы
могут использоваться как векторы или массивы. Например:

float4 pos;

Данная строка объявляет переменную Vector4, которая содержит
информацию о месторасположении. Если мы хотим объявить двух­
мерный вектор, можно записать следующее:

float2 someVector;

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

pos[0] = 2.Of;

Также можно обращаться к этому типу аналогичным образом, что и
к вектору в С#:

pos.x = 2.Of;

В этом случае мы можем обращаться к одному или к нескольким ком­
понентам вектора. Это называется «swizzling» или обращение по ад­
ресам. Мы можем использовать компоненты (x,y,z,w) вектора, также

Глава 11. Введение в программируемый конвейер, язык шейдеров 225
как составляющие цвета (r,g,b,a); однако, мы не можем смешивать
эти компоненты в данном процессе. Пример корректной записи:

pos.xz = O.Of;

pos.rg += pos.xz;

Пример некорректной записи:

pos.xg = O.Of;

Запись xg недействительна, поскольку смешиваются компоненты
разных типов.
Переменные в языке шейдеров могут иметь модификаторы похо­
жие на модификаторы языка С или С#. Вы можете объявлять кон­
станты тем же самым образом, что и ранее:
const float someConstant = 3. Of;
Вы можете совместно использовать переменные в различных про­
граммах:
shared float someVariable = l.Of;
При необходимости более подробую информацию относительно
HLSL можно найти в документации DirectX SDK.

Использование шейдеров для рендеринга,

использование техник «TECHNIQUE»

Теперь, когда мы написали программу вершинного шейдера, необхо­
димо определить «точки входа» в данную программу и написать соот­
ветствующий алгоритм. Для этого мы можем использовать процедуру,
называемую «техника» («technique»). Под техникой понимается способ
(или последовательность кода), реализующий ту или иную функцию
шейдера. Такой прием позволяет осуществить один или несколько про­
ходов, каждый раз с помощью кода HLSL определяя состояние устрой­
ства, а также вершинные и пиксельные шейдеры. Рассмотрим простой
алгоритм, который применим к нашему приложению. Добавьте следую­
щий код к вашему файлу simple.fx:

technique TransformDiffuse

{

pass PO

{

S Зак. 604

226 Часть III. Более совершенные методы построения графики
CullMode = None;
// shaders

VertexShader = compile vs_l_l Transform();
PixelShader = NULL;

Здесь мы объявляем технику TransformDifruse, позволяющую преоб­
разовать вершину и добавить диффузный цвет. В данной технике опре­
делен только один цикл. Режим отбрасывания невидимых сторон Cull не
включен, так что мы можем видеть обе стороны нашего единственного
треугольника. Если вспомнить, мы уже писали аналогичный код на язы­

ке С#.

Теперь мы попробуем «запрограммировать» обработку вершин, ис­
пользуя вершинный шейдер версии 1.1 (в программе vs_l_l). При ис­
пользовании версии 2.0 в программе нужно указать vs_2_0. Пиксельный
шейдер определяется как ps_2_0.
Так как мы не используем здесь обработку пиксела, мы определяем:
PixelShader = NULL. Далее мы должны переписать С# код, чтобы ис­
пользовать эту технику и соответствующий цикл.
Для начала используем объект Effect HLSL-кода, объявленный ранее
как основной. Добавьте следующие строки к методу InitializeGraphics
(после создания устройства):

// Create our effect
effect = Effect.FromFile(device, @". .\..\simple.fx", null,
ShaderFlags.None,

null);

effect.Technique = "TransformDiffuse";

Объект Effect создается из файла simple.fx. Затем мы объявляем тех­
нику Effect для ее использования в нашей HLSL-программе. Если вы по­
мните, у нас имелись две переменные, которые необходимо было переза­
писывать каждый раз при смене кадра. Поэтому добавим следующий код
в конце метода UpdateWorld:

Matrix worldViewProj = worldMatrix * viewMatrix * projMatrix;
effect.SetValue("Time", (float)Math.Sin(angle / 5.Of));
effect.SetValue("WorldViewProj", worldViewProj);

Здесь мы объединяем наши сохраненные матрицы и изменяем пере­
менные в коде HLSL. Этот метод вызывается каждый раз при смене кадра,
поэтому переменные будут обновляться автоматически. Теперь осталось
переписать процедуру рендеринга, используя программу вершинного шей-
дера. Перепишите ваш метод DrawPrimitives следующим образом:

Глава 11. Введение в программируемый конвейер, язык шейдеров 227
int numPasses = effect.Begin(O);
for (int i = 0; i < numPasses; i++)
{
effect.Pass(i);

device.DrawPrimitives(PrimitiveType.TriangleList, 0, 1);

}

effect.End();

Вначале мы вызываем метод effectBegin для нашей техники Effect.
Используя флажки для этого метода, мы могли бы выбрать режим, позво­
ляющий не сохранять отдельные состояния, но для этого примера это не
так важно.
Метод возвращает число циклов в используемой технике и создает
соответствующий цикл рендеринга (в нашем случае один). Перед тем

(

как создать рисунок, необходимо вызвать метод прохода или цикла Pass
для нашего объекта. Единственный принимаемый в этом методе пара­
метр — индекс i. Данный метод подготавливает устройство к процедуре
рендеринга для обозначенного цикла, обновляет состояние устройства и
устанавливает методы для вершинных и пиксельных шейдеров. И, нако­
нец, знакомый нам метод DrawPrimitives рисует примитивы (в нашем
случае треугольник).
В конце метода необходимо добавить команду завершения efFectEnd.
При запуске приложения на экране отобразится вращающийся треуголь­
ник с последовательно изменяющимися цветами, см. рис. 11.1.
Рис. 11.1. Красочный вращающийся треугольник

228 Часть III. Более совершенные методы построения графики

Использование программируемого

конвейера для рендеринга mesh-объектов

Пример с отображением треугольника является чересчур простым.
Попробуем отобразить объект mesh, используя программируемый кон­

вейер.

Для этого заменим переменные в разделе объявления вершин и вер­
шинном буфере на следующее:

private Mesh mesh = null;

Одно из преимуществ mesh-объектов состоит в том, что при ренде­
ринге они автоматически задают параметр объявления вершин vertex
declaration. Поэтому в нашем случае необходимо убрать в используемом
коде все ссылки на вершинные буферы или параметры объявления вер­

шин.

Необходимо также изменить метод инициализации для создания mesh-
объекта, для этого после создания устройства и объекта добавьте следу­
ющий код:

// Create our cylinder
mesh = Mesh.Cylinder(device, 1.5f, 1.5f, 1.5f, 36, 36);

И в завершении необходимо изменить метод рисования объекта. За­
мените вызов метода DrawPrimitives на DrawSubset:

mesh.DrawSubset(0);

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

вещения.

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

Глава 11. Введение в программируемый конвейер, язык шейдеров 229
// The direction of the light in world space
float3 LightDir = (O.Of, O.Of, -l.Of);
Теперь мы можем заменить существующий метод на следующий:

// Transform our coordinates into world space
VSJIUTPUT Transform)
float4 Pos : POSITION,
float3 Normal : NORMAL )

{

// Declare our return variable
VSJXJTPUT Out = (VSJXJTPUT) 0;
// Transform the normal into the same coord system
float4 transformedNormal = mul(Normal, WorldViewProj);
// Set our color
Out.diff.rgba = l.Of;
Out.diff *= dot(transformedNormal, LightDir);
// Transform our position
Out.pos = mul(Pos, WorldViewProj);
// Return
return Out;

}
Обратите внимание, что в метод включен новый параметр, а именно
данные о нормали («normal»). Необходимо убедиться, что каждая вер­
шина, которую мы прогоняем в процессе обработки, имеет данные о нор­
мали, иначе это вызовет ошибку. Цилиндр, созданный классом mesh, уже
содержит эту информацию, так что все в порядке.
Далее необходимо преобразовать координаты нормали в ту же самую
систему координат, в которой будет описываться вершина, поскольку мы
не сможем рассчитать освещение, имея различные системы координат
для наших данных.
В литературе по DirectX SDK можно найти следующую информацию,
касательно освещения: направленный свет рассчитывается с помощью
скалярного произведения нормали к вершине на вектор направления ос­
вещения, умножая это на цвет индикатора.
Вы можете установить значение «l.Of» для компонента цвета
(r,g,b,a) и произвести это вычисление, чтобы получить конечный цвет

цилиндра.

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

рис.11.2.

230 Часть III. Более совершенные методы построения графики
Рис. 11.2. Вращающийся цилиндр, выполненный на языке шейдеров
Изменяя цвет освещения можно получать различные цветовые эффекты.

Использолвание языка HLSL для создания

пиксельного шейдера

Вершинные шейдеры — это только часть того, что можно реализо­
вать, используя программируемый конвейер. Было бы весьма заманчиво
рассмотреть цвета каждого пиксела. Для этого мы возьмем пример
MeshFile, рассмотренный нами в главе 5 (Рендеринг mesh-объектов) и
изменим его с помощью программируемого конвейера. В примере из гл.
5 помимо обработки вершин мы использовали обработку данных тек­
стур, поэтому попытка применить пиксельный шейдер может оказаться
весьма наглядной.
После загрузки данного проекта нам нужно будет внести несколько
изменений в исходник программы, чтобы можно было использовать про­
граммируемый конвейер.
Вначале объявляем переменные для объекта Effect и матриц преобра­

зования:

private Effect effect = null;
// Matrices
private Matrix worldMatrix;
private Matrix viewMatrix;
private Matrix projMatrix;

Глава 11. Введение в программируемый конвейер, язык шейдеров 231
Необходимо также переписать метод инициализации эмулируемого
устройства в случае, если графическая карта не поддерживает шейдеры.
Метод инициализации приведен в листинге 11.2.

Листинг 11.2. Инициализация графики, проверка поддерживаемых режимов

(Fallback).

public bool InitializeGraphics ()
(
// Set our presentation parameters
PresentParameters presentParams = new PresentParameters();
presentParams.Windowed = true;
presentParams.SwapEffeet = SwapEffect.Discard;
presentParams.AutoDepthStencilFormat = DepthFormat.D16;
presentParams.EnableAutoDepthStencil = true;
bool canDoShaders = true;
// Does a hardware device support shaders?
Caps hardware = Manager.GetDeviceCaps(3, DeviceType.Hardware);
if ((hardware.VertexShaderVersion >= new VersionU, 1)) &&
(hardware.PixelShaderVersion >= new Version(1, 1)))

{

// Default to software processing
CreateFlags flags = CreateFlags.SoftwareVertexProcessing;
// Use hardware if it's available
if (hardware.DeviceCaps.SupportsHardwareTransformAndLight)
flags = CreateFlags.HardwareVertexProcessing;
// Use pure if it's available
if (hardware.DeviceCaps.SupportsPureDevice)
flags |= CreateFlags.PureDevice;
// Yes, Create our device
device = new Device(0, DeviceType.Hardware, this, flags, presentParams)

}

else

(
// No shader support
canDoShaders = false;
// Create a reference device
device = new Device(0, DeviceType.Reference, this,
CreateFlags.SoftwareVertexProcessing, presentParams);

I

// Create our effect
effect = Effect.FromFile(device, @"..\. .\simple.fx", null,

ShaderFlags.None, null);

effect.Technique = "TransformTexture";
// Store our project and view matrices
projMatrix = Matrix.PerspectiveFovLH((float)Math.PI / 4,

232 Часть III. Более совершенные методы построения графики
this.Width / this.Height, Of, 10000.Of);
viewMatrix = Matrix.LookAtLH(new Vector3(0,0, 580.Of), new Vector3(),
new Vector3(0,1,0));
// Load our mesh

LoadMesh(@"..\..\tiny.x");

return canDoShaders;
}
Данный метод аналогичен методу инициализации, который мы уже
использовали в этой главе, только помимо вершинных шейдеров здесь
проверяется возможность поддержки и пиксельных шейдеров (как и рань­
ше, возвращается булева переменная). Для изменения основного метода
Main мы можем обратиться к тому же алгоритму, который использовали
в этой главе при отображении треугольника.
Необходимо отметить, что, поскольку метод SetupCamera использует­
ся только в непрограммируемом конвейере, мы можем исключить его из
программы при преобразовании координат или установке освещения.
Естественно при этом необходимо также удалить соответствующий вы­
зов в методе OnPaint.
И последнее, мы должны заменить вызов рисунка DrawMesh соответ­
ствующим кодом рендеринга, написанном на языке HLSL и приведен­
ном в листинге 11.3.

Листинг 11.3. Код вызова рисунка mesh-объекта, написанный на языке HLSL.
private void DrawMesh(float yaw, float pitch, float roll, float x, float y.
float z)

{

angle += O.Olf;
worldMatrix = Matrix.RotationYawPitchRoll(yaw, pitch, roll)
* Matrix.Translation(x, y, z);
Matrix worldViewProj = worldMatrix * viewMatrix * projMatrix;
effect.SetValue("WorldViewProj", worldViewProj);
int numPasses = effect.Begin(O);
for (int iPass = 0; iPass < numPasses; iPass++)

{

effect.Pass(iPass);

for (int i = 0; i < meshMaterials.Length; i++)

{

device.SetTexturefO, meshTextures[i]);
mesh.DrawSubset (i);

}
}
effect.End();

}

Глава 11. Введение в программируемый конвейер, язык шейдеров 233
Данный метод вызывается при каждой смене кадра. Как видно из ме­

тода, мы объединяем матрицы преобразования и изменяем в соответствии

с этим код HLSL.
Затем мы отображаем каждое подмножество объекта mesh для каждо­
го цикла техники. Однако, мы до сих пор не объявили и не создали для
этого приложения исходник на языке HLSL, так что необходимо доба­
вить новый пустой файл «simple.fx» и добавить код, приведенный в лис­
тинге 11.4.

Листинг 11.4. Код HLSL для рендеринга текстурных объектов.
// The world view and projection matrices
float4x4 WorldViewProj : WORLDVIEWPROJECTION;
sampler TextureSampler;
// Transform our coordinates into world space
void Transform(
in float4 inputPosition : POSITION,
in float2 inputlexCoord : IEXCOORD0,
out float4 outputPosition : POSITION,
out float2 outputTexCoord : TEXCOORDO
)

{

// Transform our position
outputPosition = mul(inputPosition, WorldViewProj);
// Set our texture coordinates
outputTexCoord = inputlexCoord;

}

void TextureColor(
in float2 textureCoords : TEXCOORDO,
out float4 diffuseColor : COLORO)

{

// Get the texture color
diffuseColor = tex2D(TextureSampler, textureCoords);

};

technique TransformTexture

{

pass PO

{

// shaders
VertexShader = compile vs_1_1 Transform();
PixelShader = compile ps_1_1 TextureColor();

}
}

234 Часть III. Более совершенные методы построения графики
Легко заметить, чем отличаются программы шейдеров. Вместо сохра­
нения возвращаемых значений в структуре, мы просто добавили выход­
ные параметры в раздел объявления метода.
Для программирования вершины нас интересуют только данные ее
положения и координаты текстуры.
Используемый нами пиксельный шейдер принимает координаты тек­
стуры для соответствующего пиксела и возвращает цвет данного отобра­
жаемого пиксела.
Для нашего случая мы используем заданный по умолчанию цвет тек­
стуры, и встроенный метод tex2D производит выборку текстуры в дан­
ном наборе координат и возвращает цвет в этой точке.

Результат использования пиксельного шейдера для нашего mesh-объек­

та приведен на рис. 11.3.
Рис. 11.3. Результат рендеринга mesh-объекта с использованием

пиксельного шейдера

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

HLSL:

void InverseTextureColor(
in float2 textureCoords : TEXCOORDO,

Глава 11. Введение в программируемый конвейер, язык шейдеров 235
out float4 diffuseColor : COLORO)

{

// Get the inverse texture color
diffuseColor = 1.Of — tex2D(TextureSampler, textureCoords);

};

technique TransformInverseTexture

{

pass PO

{
// shaders
VertexShader = compile vs_l_l Transform();
PixelShader = compile ps_l_l InverselextureColor();

}
}

Данный код аналогичен нашему первому пиксельному шейдеру с той
лишь разницей, что теперь при определении цвета мы вычитаем выбо­
рочный цвет из значения «1.Of». Поскольку значение «lOf» рассматрива­
ется как «fully on» для цвета, произведя вычитание, мы обращаем цвет
пиксела. Помимо этого мы будем использовать еще одну технику
TransformlnverseTexture, которая отличается только методом вызываемо­
го шейдера.

Теперь нам необходимо переписать наш основной С# код, чтобы иметь

возможность переключать эти методы. Для этого необходимо написать
обработку нажатия клавиш «1» и «2» на клавиатуре:

protected override void OnKeyPress(KeyPressEventArgs e)

{

switch (e.KeyChar)

{

case '1':
effect.Technique = "TransformTexture";
break;
case '2':
effect.Technique = "TransformlnverseTexture";
break;

}

base.OnKeyPress (e);

}

Теперь запустите приложение и нажмите клавишу «2». Объект теперь
выглядит как негатив, рис.11.4.
Пример программы, позволяющей изменять цвета объекта, включен в
прилагаемый CD диск.

236 Часть III. Более совершенные методы построения графики

Рис. 11.4. Рендеринга mesh-объекта с обращенными цветами

Краткие выводы

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

HLSL.

Глава 12. Использование языка шейдеров HLSL 237

Глава 12. Использование языка

шейдеров HLSL

В предыдущей главе мы ввели понятие программируемого конвейера
и рассмотрели его возможности в сравнении с непрограммируемым кон­

вейером.

В этой главе мы рассмотрим особенности использования языка шей­
деров HLSL для создания и отображения на экране более реалистичных
картинок, нежели те, которые мы получали ранее, используя непрограм­
мируемый конвейер.
Мы коснемся следующих вопросов.
• Простая анимация вершины.
Простая цветная анимация.
• Объединение цвета текстуры с цветами поверхности.
• Световые модели с текстурами.
• Различие между повершинным per-vertex и попиксельным per-pixel
наложением света.

Использование простых формул для

моделирования анимации

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

// Create our sphere
mesh = Mesh.Sphere(device, 3.Of, 36, 36);

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

viewMatrix = Matrix.LookAtLH(new Vector3(0,0, 9.Of), new Vector3(),
new Vector3(0,1,0));

Теперь, запуская приложение, мы должны увидеть монотонно враща­
ющуюся сферу, освещенную единственным направленным источником

238 Часть III. Более совершенные методы построения графики
света. Для создания эффекта анимации попробуем в коде шейдера заме­
нить строку, описывающую преобразование, следующим кодом:

// Store our local position
float4 tempPos = Pos;
// Make the sphere 'wobble' some
tempPos.y += cos(Pos + (Time * 2.0f));
// Transform our position
Out.pos = mulftempPos, WorldViewProj) ;

Обратите внимание, что переменная Time используется уже неоднок­
ратно в наших примерах. Для данного примера необходимо переопреде­
лить эту переменную, добавив ее к коду шейдера:
float Time = O.Of;
Кроме того, необходимо перезаписывать эту переменную при каждой
смене кадра, поэтому в главном коде, в конце метода UpdateWorld, до­
бавьте следующий код:
effect.SetValue("Time", angle);
Теперь опишем наши последние действия. Вначале исходное положе­

ние (входной параметр) вершины сохраняется как переменная. Затем ком­

понента Y этой переменной модулируется путем добавления косинуса
от суммы текущего местоположения вершины и значения Time*2.0f. Так
как косинус меняется в пределах от -1 до +1, функция будет периодичес­
ки повторятся. Переменная Time влияет на результат анимации в боль­
шей степени, нежели значение расположения Pos.
Можно добавить еще одно новшество, например, переменную анима­
ции для цвета. Замените код инициализации Out.diff следующим:

// Set our color
Out.diff = sin(Pos + Time);

Очевидно, данный код аналогичен только что описанному методу вер­

шинной анимации.

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

Глава 12. Использование языка шейдеров HLSL 239
Объединение цветов текстуры с цветами
поверхности

На практике встречается не так много приложений, использующих
простые псевдослучайные цвета. Как правило, модели создаются или с
помощью сложных текстур, или из нескольких текстур. Допустим, име­
ется сценарий, где необходимо смешать или наложить две или более тек­
стуры. Бесспорно, это можно было бы сделать и на непрограммируемом
конвейере. Но допустим, мы используем объект, похожий на «tiny.x», ко­
торый мы уже неоднократно использовали в нашей книге. Данная мо­
дель использует только одну текстуру. Теперь попробуем для этой моде­
ли реализовать две текстуры, объединяя цвет текстуры с цветом поверх­
ности (иногда используется термин интерполяция текстуры).
Для этого используем пример текстуры объекта, написанный в пре­
дыдущей главе. Попробуем добавить вторую текстуру, смешать эти тек­
стуры и выдать окончательный цвет.

ПРЕДЕЛ ДОСТУПНЫХ КОМАНД ДЛЯ ПИКСЕЛЬНОГО

ШЕЙДЕРА

Поскольку мы будем манипулировать пиксельным шейдером, не­
обходимо обратить внимание на то, что количество доступных ко­
манд, которые могут быть использованы в шейдерах версии 1.1,
чрезвычайно ограничено. Например, для шейдеров версий не стар­
ше 1.4 мы ограничены 12-ю командами в пределах всей програм­
мы. Для версии 1.4 мы имеем уже 28 команд и до 8 констант. Версия
шейдера 2.0 и выше может выполнять гораздо более сложные опе­
рации с достаточным количеством команд и используемых констант.
Вы можете заранее выяснить возможности вашей графической кар­
ты, чтобы определить, какие версии она поддерживает.

Зная теперь эти ограничения, будем создавать метод объединения дву­
мя способами. Первый использует очень простой код шейдера 1.1, под­
держиваемый практически всеми платами, второй — более сложный, для
версии 2.0, с соответствующим ограничением на выбор платы.
Естественно, мы начнем с версии 1.1, как с более простой. Перед на­
писанием соответствующего кода необходимо внести некоторые измене­
ния. В первую очередь нужно определить и создать вторую текстуру.
Добавьте следующую переменную для этой текстуры в ваш класс:

private Texture skyTexture;

240 Часть III. Более совершенные методы построения графики
Поскольку загружаемая нами модель имеет один материал и одну тек­
стуру, можно удалить ссылку на использование дополнительных масси­
вов материалов и текстур. Код, включенный в CD диск, уже включает в
себя это изменение, поэтому на этом останавливаться не будем.
Итак, мы создаем или загружаем вторую текстуру, чтобы затем объе­
динить ее с первой. В данном примере мы копируем текстуру
skybox_top.JPG, которая находится в папке «application» DirectX SDK
(можно в дальнейшем при желании использовать и другие текстуры). Как
только мы выбрали вторую текстуру, необходимо ее создать. Наилучшим
образом подойдет метод LoadMesh, которым была создана и первоначаль­
ная текстура. Исправьте строку создания текстуры:
// We have a texture, try to load it

meshTexture = TextureLoader.FromFile(device, @"..\..\" +

mtrl[i].TextureFilename);

skyTexture = TextureLoader.FromFile(device, @"..\..\skybox_top.JPG");
Если вы выбрали другой файл текстуры, необходимо просто заменить
имя файла в листинге. Теперь напишем код, позволяющий интерполиро­
вать имеющиеся текстуры. Добавьте следующие переменные к вашему
коду шейдера:
float Time;

Texture meshTexture;
Texture skyTexture;
sampler TextureSampler = sampler_state { texture = ;
mipfilter = LINEAR; };
sampler SkyTextureSampler = sampler_state { texture = ;
mipfilter = LINEAR; };

Переменная Time использовалась нами достаточно часто, поэтому не
требует разъяснений, а вот две переменные текстуры являются новыми.
Используемая здесь выборка текстур с помощью процедуры сэмплиро­
вания более предпочтительна, нежели вызов SetTexture, который мы ис­
пользовали раньше. По этой причине вызов SetTexture убирается из на­
шего приложения.
Две новые переменные являются внутренними переменными языка
шейдеров и служат для определения того, как текстура сэмплирована.
Таким образом, каждая сэмплируемая текстура основывается на текущей
текстуре и использует линейный фильтр mipmap. Мы бы могли также
включить фильтры растяжения или сжатия, но для данного случая филь­
тра mipmap достаточно.
Прежде чем использовать переменные текстурирования, необходимо
определить их в программе инициализации основного кода , для этого
добавьте следующий код после вызова загрузки mesh-объекта:

Глава 12. Использование языка шейдеров HLSL 241

effect.SetValue("meshIexture", meshTexture);
effect.SetValue("skyTexture", skyTexture);

Таким образом, после загрузки mesh-объекта создаются наши тексту­
ры. Однако, даже после этого наша модель имеет только один единствен­
ный набор координат текстуры. Используйте следующий код вершинно­
го шейдера:

// Transform our coordinates into world space
void TransformVl_l(
in float4 inputPosition : POSITION,
in float2 inputTexCoord : TEXCOORDO,
out float4 outputPosition : POSITION,
out float2 outputTexCoord : TEXCOORDO,
out float2 outputSecondTexCoord : TEXC00RD1
)

{

// Transform our position
outputPosition = mul(inputPosition, WorldViewProj);
// Set our texture coordinates
outputTexCoord = inputTexCoord;
outputSecondTexCoord = inputTexCoord;
}
Понятно, что здесь вводятся местоположение и набор координат отдель­
ной текстуры. Однако, на выходе программа не просто возвращает преобра­
зованное местоположение текстуры, но также пересылает входную коорди­
нату текстуры к обоим наборам выходных координат. По существу, код дуб­
лирует координаты текстуры для каждой вершины поверхности. Теперь мы
можем заменить код пиксельного шейдера на следующий:
void TextureColorVl_l (
in float4 P : POSITION,
in float2 textureCoords : TEXCOORDO,
in float2 textureCoords2 : TEXC00RD1,
out float4 diffuseColor : COLORO)
{
// Get the texture color
float4 diffuseColorl = tex2D(TextureSampler, textureCoords);
float4 diffuseColor2 = tex2D(SkyTextureSampler, textureCoords2);
diffuseColor = lerp(diffuseColorl, diffuseColor2, Time);

};

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

242 Часть III. Более совершенные методы построения графики
мы сэмплируем каждую из двух загруженных текстур (с идентичными
координатами текстур), а затем выполняем линейную интерполяцию
(встроенная функция lerp). Значение переменной Time определяет то, как
долго мы видим каждую текстуру. Пока мы не задавали данную перемен­
ную в нашем приложении. Можем сделать это в методе mesh drawing
следующим образом:

effect.SetValue("Time", (float)Math.Abs(Math.Sin(angle)));

Напрашивается вопрос, почему мы выполняем «математику» именно
здесь, а не в программе шейдера? Конечно, было бы предпочтительнее
возложить данные операции на графическую карту, чем на центральный
процессор, но мы об этом уже писали. Имеются в виду ограничения, свя­
занные с версией 1.1 используемого шейдера и нашей картой.
Итак, перед запуском приложения с нашими текстурами осталось вы­
полнить одну замену. Поскольку имена функций для вершинного и пик­
сельного шейдеров были изменены, необходимо заменить используемую
нами технику:

technique TransformTexture

{

pass РО

{
// shaders
VertexShader = compile vs_l_l TransformVl_l();
PixelShader = compile ps_l_l TextureColorVl_l();

I

1

Название самой техники не изменилось, и теперь мы можем запус­
тить наше приложение. Обратите внимание на то, что текстурируемая
при запуске модель «смешивается» с текстурой неба Sky Texture (пола­
гая, что мы использовали эту текстуру) и затем снова объединяется с ис­
ходной текстурой. Это повторяется до тех пор, пока приложение не будет

закрыто.

Теперь предположим, что ваша графическая карта поддерживает пик­
сельный шейдер версии 2.0. Мы должны переписать код таким образом,
чтобы иметь возможность работать с обеими версиями пиксельных шей­
деров 1.1 и 2.0. Чтобы узнать, поддерживает ли плата версию 2.0, необ­
ходимо добавить переменную к основному коду:

private bool canDo2_0Shaders = false;

Значение «false» предполагает, что плата не поддерживает версию 2.0
первоначально. После того как мы создали устройство в методе инициа-

Глава 12. Использование языка шейдеров HLSL 243
лизации, необходимо выяснить, может ли шейдер 2.0 поддерживаться
самим устройством. Этот вызов необходимо определить непосредствен­
но перед командой Effect:

canDo2_0Shaders = device.DeviceCaps.PixelShaderVersion >= new Version(2, 0);

Поскольку мы добавляем вторую технику для шейдера, необходимо,
основываясь на более продвинутой модели шейдера, определить, какая
именно техника будет являться базовой. Для этого перепишите запись
effect.Technique:
effect.Technique = canDo2JShaders ? "TransformTexture2_0" :
"TransformTexture";
В этом случае, если модель 2.0 поддерживается, приложение будет
использовать эту технику, в противном случае будет использоваться тех­
ника, которую мы уже написали. Теперь перепишем строку, которая оп­
ределяет переменную Time:
if (canDo2_0Shaders)
{
effect.SetValue("Time", angle);
}

else

{
effeet.SetValue("Time", (float)Math.Abs(Math.Sin (angle)));

}

Обратите внимание, что с более совершенной программой шейдера и
соответствующей графической картой выполнение математических опе­
раций будет возложено на графическую карту, и мы воспользуемся все-
• ми преимуществами данной конфигурации. Теперь нам необходимо до­
бавить новый код шейдера, который позволит нам выполнить приложе­
ние. Добавьте код, приведенный в листинге 12.1, к вашему коду HLSL.

Листинг 12.1. Процедура объединение текстур на языке шейдера версии 2.0.
// Transform our coordinates into world space
void TransformV2_0(
in float4 inputPosition : POSITION,
in float2 inputTexCoord : TEXCOORDO,
out floats outputPosition : POSITION,
out float2 outputTexCoord : TEXCOORDO
)
(

244 Часть III. Более совершенные методы построения графики
// Transform our position
outputPosition = mul(inputPosition, WorldViewProj);
II Set our texture coordinates
outputTexCoord = inputTexCoord;

)

void TextureColorV2_0(
in float4 P : POSITION,
in float2 textureCoords : TEXCOORDO,
out float4 diffuseColor : COLORO)
(
// Get the texture color
float4 diffuseColorl = tex2D(TextureSampler, textureCoords);
float4 diffuseColor2 = tex2D(SkyTextureSampler, textureCoords);
diffuseColor = lerp(diffuseColorl, diffuseColor2, abs(sin(Time)));

};

technique TransformTexture2_0

{
pass PO

{

// shaders
VertexShader = compile vs_l_l TransformV2_0();
PixelShader = compile ps_2_0 TextureColorV2_0() ;

}
}
Наша программа стала намного проще. Вместо дублирования коорди­
нат текстуры код просто преобразовывает местоположение и пересылает
первоначальный набор координат. Нет ничего похожего на программы
вершинных шейдеров (vertex program).
Пиксельный шейдер вообще выглядит намного проще. Здесь нет не­
обходимости в использовании двух наборов координат текстур, вместо
этого смешивание двух различных текстур происходит с помощью одно­
го и того же набора текстурных координат. В более старых версиях пик­
сельных шейдеров (до версии 2.0) мы могли читать координаты тексту­
ры только один раз, и процедура смешивания двух текстур с помощью
одного набора координат вызвала бы два считывания, а это было невоз­
можно при наличии старой версии шейдера. Следует также заметить, что
для определения уровня интерполяции (функция lerp) благодаря тому,
что математика выполняется в коде шейдера, используется одна и та же
формула. Единственные различия в данной технике — это имена функ­
ций и то, что пиксельный шейдер компилируется с помощью ps_2_0.

Текстуры освещения

В предыдущей главе мы обсуждали простое направленное освеще­
ние. На том этапе цилиндр не текстурировался, и расчет освещения вы-

Глава 12. Использование языка шейдеров HLSL
245

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

float4x4 WorldMatrix : WORLD;
floats DiffuseDirection;
Texture meshTexture;
sampler TextureSampler = sampler^state { texture = ; mipfilter
= LINEAR; };
struct VS_0UTPUT

{

float4 Pos : POSITION;
float2 TexCcord : TEXC0ORD3;
float3 Light : TEXC00RD1;
float3 Normal : TEXC00RD2;

};

Обратите внимание, что мы не просто сохраняем комбинированную
матрицу вида и проекции как раньше, а имеется другая переменная для
записи непосредственно мировой матрицы. Мы поймем необходимость
этого, как только обсудим данный код шейдера. Также имеется перемен­
ная, отвечающая за направление света. Как и в предыдущем примере,
имеется текстура и состояние сэмплера для чтения текстуры.
Выходная структура данной процедуры несколько отличается. Пере­
сылаются не только местоположение и координаты текстуры, пересыла­
ются также два новых значения координат текстуры. В действительнос­
ти они не являются координатами текстуры как таковыми, они использу­
ются только для передачи необходимых данных из вершинного шейдера
в пиксельный шейдер.
Мы должны также переопределить эти значения в методе рисования
объекта после вызова строки с переменной WorldViewProj:

effect.SetValue("WorldMatrix", worldMatrix);
effect.SetValue("DiffuseDirection", new Vector4(0, 0, 1, I));

А также устанавливаем переменную текстуры, добавляя в метод ини­
циализации следующий код после процедуры загрузки mesh-объекта (и
текстуры):

effect.SetValue("meshTexture", meshTexture);

246 Часть III. Более совершенные методы построения графики
Теперь все готово к тому, чтобы мы могли переписать наш код пик­
сельного шейдера и отобразить текстуру освещения. Осталось выбрать
цвет освещения (любой кроме белого, для наглядности) и проверить вер­
шинный шейдер:

// Transform our coordinates into world space
VS_OUTPUT Transform)
float4 inputPosition : POSITION,
float3 inputNormal : NORMAL,
float2 inputTexCoord : TEXCOORDO
//Declare our output structure
VS_0UTPUT Out = (VS_OUTPUT)0;
// Transform our position
Out.Pos = mul(inputPosition, WorldViewProj);
// Store our texture coordinates
Out.TexCoord = inputTexCoord;
// Store our light direction
Out.Light = DiffuseDirection;
// Transform the normals into the world matrix and normalize them
Out.Normal = normalize(mul(inputNormal, WorldMatrix));
return Out;

}

Начало этой программы шейдера для нас достаточно ясно, хотя в ней
имеется значительное число входных параметров. Вначале преобразует­
ся местоположение и записываются координаты текстуры. Затем пара­
метр направления света «light direction» размещается во второй набор
координат текстуры. Обратите внимание на то, что тип параметра на­
правления света — float4, тогда как тип координат текстуры — float3.
В третьем наборе координат текстуры необходимо сохранить данные
о нормалях. Прежде чем это сделать, необходимо преобразовать норма­
ли в мировую систему координат. Без этого расчет освещения будет вы­
полняться некорректно, нельзя выполнять математические операции над
объектами в различных системах координат. Выполнив все необходимые
действия с освещением и текстурами, мы можем добавить следующий
код пиксельного шейдера:

floats TextureColor(
float2 textureCoords : TEXCOORDO,
float3 lightDirection : TEXC00RD1,
float3 normal : TEXC00RD2) : COLORO

{

// Get the texture color
float4 textureColor = tex2D(TextureSampler, textureCoords);

Глава 12. Использование языка шейдеров HLSL
247
// Make our diffuse color purple for now
float4 diffuseColor = (l.Of, O.Of, l.Of, l.Of);
// Return the combined color after calculating the effect of
// the diffuse directional light
return textureColor * (diffuseColor * saturate(dot(lightDirection,

normal))) ;

};

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

вым шагом является выбор текущей текстуры. Затем устанавливается цвет

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

Моделирование световых бликов

Другим типом освещения, который мы еще не обсуждали, является
«specular highlighting» или моделирование световых бликов на поверх­
ности. Данный метод позволяет отобразить объект на экране более реа­
листично. Мы можем реализовать данный тип освещения с помощью
непрограммируемого конвейера, однако при этом эти подсветки будут
рассчитаны повершинно. В этой главе мы покажем, как можно реализо­
вать световые блики, используя программируемый конвейер.

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

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

// Load our mesh
mesh = Mesh.Teapot(device);

248 Часть III. Более совершенные методы построения графики
Поскольку этот пример будет демонстрировать различные эффекты,
следует позаботиться о возможности переключения между ними, и, кро­
ме того, было бы неплохо добавлять соответствующие текстовые ком­
ментарии. Поэтому необходимо определить переменную шрифта:
// Out font

private Direct3D.Font font = null;

Инициализируем переменную шрифта сразу после создания объекта
teapot:
//Create our font
font = new Direct3D.Font(device, new System.Drawing.Font("Arial", 12.Of));
Теперь необходимо добавить константы и переменные, которые будут
задействованы в коде пиксельного шейдера:

float4x4 WorldViewProj : WORLDVIEWPROJECTION;

float4x4 WorldMatrix : WORLD;
float4 DiffuseDirection;
float4 EyeLocation;
// Color constants
const float4 MetallicColor = { 0.8f, 0.8f, 0.8f, l.Of };

const float4 AmbientColor = { 0.05f, 0.05f, 0.05f, l.Of };

Для преобразования вершин здесь используются мировая матрица, мат­
рица вида и матрица проекции. Мировая матрица будет еще раз использова­
на для преобразования нормалей к вершинам. Значение DiffuseDirection по­
зволит приложению определять направление света быстрее, чем при исполь­
зовании шейдера в предыдущих примерах. И последняя переменная
EyeLocation — положение глаза наблюдателя. Световые блики рассчитыва­
ются, исходя из отражения света между нормалью к поверхности и глазом.
Обратите внимание на то, что в нашей подпрограмме имеются две
объявленные константы. Цвет MetallicColor выбирается, благодаря свой­
ствам металлической поверхности и падающего на него диффузного ос­
вещения. Вторая объявленная константа — общее освещение Ambient-
Color. Данный параметр включен для полноты математических опера­
ций при расчете освещения.
Для данного примера выходная структура повершинного освещения
per-vertex рассматривает и задает местоположение и цвет каждой верши­
ны. Мы можем объявить ее следующим образом:
struct VS_OOTPUT_PER_VERTEX

1 float4 Position : POSITION;
float4 Color : COLORO;

I;

Глава 12. Использование языка шейдеров HLSL 249
Прежде чем написать код шейдера для моделирования световых бли­
ков, необходимо переписать код шейдера для диффузного освещения.
Таким образом мы создадим отдельные шейдеры для каждой свето­
вой модели. Замените программу для диффузного освещения следую­
щим кодом:

VS_OUTPUT_PER_VERTEX TransformDiffuse(
floats inputPosition : POSITION,
float3 inputNormal : NORMAL,
uniform bool metallic
)

{

//Declare our output structure
VS_0UTPUT_PER_VERTEX Out = (VS_OUIPUT_PER_VERTEX)0;
// Transform our position
Out.Position = mul(inputPosition, WorldViewProj);
// Transform the normals into the world matrix and normalize them
float3 Normal = normalize(mul(inputNormal, WorldMatrix));
// Make our diffuse color metallic for now
float4 diffuseColor = MetallicColor;
if(!metallic)
diffuseColor.rgb = sin(Normal + inputPosition);
// Store our diffuse component
float4 diffuse = saturate(dot(DiffuseDirection, Normal));
// Return the combined color
Out.Color = AmbientColor + diffuseColor * diffuse;
return Out;

}
Обратите внимание, что в шейдере появился новый входной параметр,
булева переменная, объявленная с атрибутом «uniform». Модификатор
«uniform» позволяет приложению Direct3D обработать эту переменную
как константу, которая не может быть изменена в течение вызова рисова­

ния draw.

При запуске данного шейдера преобразуется местоположение и затем
нормаль, а для диффузного освещения выбирается объявленный ранее
цвет «metallic».
Также присутствует оператор, который мы еще не рассматривали, а
именно, управление потоком данных (flow control). Язык HLSL под­
держивает несколько механизмов управления потоками данных, вклю­
чая знакомые нам условные операторы «if», операторы циклов, преры­
вание цикла «while loop» и т. д. Каждый из механизмов управления по­
токами данных имеет свой синтаксис, подобный эквивалентным опера­
торам в С#.

250
Часть III. Более совершенные методы построения графики

УПРАВЛЕНИЕ ПОТОКАМИ ДАННЫХ НА СТАРЫХ ВЕРСИЯХ

ШЕЙДЕРОВ

Более старые версии шейдеров не поддерживают управление по­
токами данных или переходы.
Компилятор HLSL может раскручивать цикл или выполнять все вет­
ви условных операторов. Это необходимо знать, чтобы при написа­
нии сложных шейдеров не достичь предельного количества опера­
торов. Возьмем простой цикл:
for(int i = 0; i<10; i++)

{
pos.y += (float)i;
}

Даже при том, что здесь имеется только один оператор, данный код
шейдера инициировал бы по крайней мере выполнение 20 команд.
И если бы шейдер имел ограничение в 12 команд (например, шей-
дер версии 1.1), этот простой цикл не был бы откомпилирован.

Итак, вернемся к нашей программе. Если переменная metallic истинна,
то сохраняется металлический цвет освещения.
Если ложное, цвет будет переключен на цвет «animating», аналогично
первому примеру в этой главе.
Теперь, имея два различных типа цвета, которые могут использовать­
ся в этой программе шейдера, мы добавляем две техники:

technique TransformSpecularPerVertexMetallic

{

pass PO

{

// shaders
VertexShader = compile vs_l_l TransformSpecular(true) ;
PixelShader = NULL;

}

}
technique TransformSpecularPerVertexColorful

{

pass PO

{

// shaders
VertexShader = compile vs_l_l TransformSpecular(false);
PixelShader = NULL;

}

}

Глава 12. Использование языка шейдеров HLSL 251
Следует обратить внимание, что единственное различие между этими
двумя техниками (помимо разных названий) — значение, которое пере­
сылается в код шейдера.
Далее, поскольку названия используемых техник изменились, необ­
ходимо переписать основной код:

effect.Technique = "TransformDiffusePerVertexMetallic";

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

Листинг 12.2. Преобразования и использование световых бликов.
VS_OUTPUT_PER_VERTEX TransformSpecular (
float4 inputPosition : POSITION,
float3 inputNormal : NORMAL,
uniform bool metallic
)

{ (
//Declare our output structure
VS_OUTPUT_PER_VERTEX Out = (VS_OUTPUT_PER_VERTEX)0;
// Transform our position
Out.Position = mul(inputPosition, WorldViewProj);
// Transform the normals into the world matrix and normalize them
float3 Normal = normalize(mul(inputNormal, WorldMatrix));
// Make our diffuse color metallic for now
float4 diffuseColor = MetallicColor;
// Normalize the world position of the vertex
float3 worldPosition = normalize(mul(inputPosition, WorldMatrix));
// Store the eye vector
float3 eye = EyeLocation - worldPosition;
// Normalize our vectors
float3 normal = normalize(Normal);
float3 light = normalize(DiffuseDirectipn);
float3 eyeDirection = normalize(eye);
if([metallic)
diffuseColor.rgb = cos(normal + eye);
// Store our diffuse component
float4 diffuse = saturate(dot(light, normal));
// Calculate specular component
float3 reflection = normalize(2 * diffuse * normal - light);
floats specular = pow(saturate(dot(reflection, eyeDirection)), 8);

252
Часть III. Более совершенные методы построения графики

// Return the combined color
Out.Color = AmbientColor + diffuseColor * diffuse + specular;
return Out;

}
Это самая длинная программа шейдера в этой книге из рассмотрен­
ных до настоящего момента. Начало аналогично предыдущему случаю,
когда мы преобразовывали местоположение и нормаль и затем устанав­
ливали диффузное освещение для константы цвета «metallic». После этого
в программе сохраняется местоположение каждой вершины в мировых
координатах, поскольку наблюдатель расположен в пространстве миро­
вых координат, а вершины — в пространстве модели. И, поскольку при
вычислении световых бликов будет использоваться направление от на­
блюдателя, все значения должны находиться в одной системе координат. -
Далее каждый из векторов нормализуется к значению l.Of, после чего
проверяется булева переменная, и пересчитывается значение цвета с уче­
том нового нормализованного вектора и сохраненного диффузного осве­
щения, входящих в формулу расчета, таким образом, моделируется слу­
чайный цвет анимации и окончательно рассчитывается модель световых
бликов. Для получения дополнительной информации по формуле расче­
та освещения см. документацию DirectX SDK.
После того как рассчитаны компоненты световой модели, программа
шейдера возвращает результирующий цвет, используя те же самые мате­
матические формулы для освещения. После того как мы написали тен­
деры для моделирования световых бликов, можно добавить следующие
процедуры обращения к ним:

technique TransformSpecularPerVertexMetallic

{

pass PO

{

// shaders
VertexShader = compile vs__l_l TransformSpecular(true);
PixelShader = NULL;

}
}
technique TransformSpecularPerVertexColorful

{
pass PO

{

// shaders
VertexShader = compile vs_l_l TransformSpecular(false);
PixelShader = NULL;

}
}

Глава 12. Использование языка шейдеров HLSL 253
Перед запуском приложения необходимо переписать основной код,
чтобы вызвать программу шейдера для моделирования световых бликов:

effect.Technique = "TransformSpecularPerVertexMetallic";

На рис.12.1 изображен вращающийся, освещенный светом чайник.

Рис. 12.1 Модель чайника использующая повершииное (per-vertex)
моделирование световых бликов

ИСПОЛЬЗОВАНИЕ ПОПИКСЕЛЬНОГО (PER-PIXEL)

МОДЕЛИРОВАНИЯ СВЕТОВЫХ БЛИКОВ

Легко заметить, что освещенный солнцем чайник выглядит гораздо
реалистичнее, если мы используем световые блики. Тем не менее,
может показаться, что повершинное освещение, рассчитываемое в
этой программе, не так гладко освещает изогнутую поверхность
заварочного чайника, как хотелось бы. Чтобы получить более мяг­
кую игру света, можно рассчитать освещение, используя попиксель-
ное моделирование освещения.
Поскольку вычисление освещения требует большего количества ко­
манд, чем позволяет пиксельный шейдер версии 1.1, необходимо
убедиться, что ваше приложение поддерживает по крайней мере
шейдеры версии не ниже 2.0. Чтобы проверить эту «логику» пере­
пишите основной код:

254 Часть III. Более совершенные методы построения графики
if ((hardware.VertexShaderVersion >= new Version(1, 1)) &&
(hardware.PixelShaderVersion >= new Version(2, 0)))
Нам все еще понадобится вершинный шейдер для преобразования
координат и передачи данных, которые будут использоваться в пик­
сельном шейдере. Теперь добавьте программу шейдера, приведен­
ную в листинге 12.3.

Листинг 12.3. Программа шейдера для моделирования световых бликов.
struct VS_OUTPUT_PER_VERTEX_PER_PIXEL

{

float4 Position : POSITION;
float3 LightDirection : TEXCOORDO;
float3 Normal : TEXCOORD1;
float3 EyeWorld : TEXCOORD2;

};

// Transform our coordinates into world space
VS_OUTPUT_PER_VERTEX_PER_PIXEL Transform(
float4 inputPosition : POSITION,
float3 inputNoraal : NORMAL
)

{
//Declare our output structure
VS_OUTPUT_PER_VERTEX_PER_PIXEL Out = (VS_OUTPUT_PER_VERTEX_PER_PIXEL)
// Transform our position
Out.Position = mul(inputPosition, WorldViewProj);
// Store our light direction
Out.LightDirection = DiffuseDirection;
// Transform the normals into the world matrix and normalize them
Out.Normal = normalize(mul(inputNormal, WorldMatrix));
// Normalize the world position of the vertex
float3 worldPosition = normalize(mul(inputPosition, WorldMatrix));
// Store the eye vector
Out.EyeWorld = EyeLocation - worldPosition;
return Out;

}

float4 ColorSpecular(
float3 lightDirection : TEXCOORDO,
float3 normal : TEXC00RD1,
float3 eye : TEXC00RD2,
uniform bool metallic) : COLORO

Глава 12. Использование языка шейдеров HLSL 255

// Make our diffuse color metallic for now
floats diffuseColor = MetallicColor;
if(!metallic)
diffuseColor.rgb = cos(normal + eye);
// Normalize our vectors
float3 normalized = normalize(normal);
float3 light = normalize(lightDirection);
float3 eyeDirection = normalize(eye);
// Store our diffuse component
float4 diffuse = saturate(dot(light, normalized));
// Calculate specular component
float3 reflection = normalize(2 * diffuse * normalized- light);
float4 specular = pow(saturate(dot(reflection, eyeDirection)), 8);
// Return the combined color
return AmbientColor + diffuseColor * diffuse + specular;

};

Написанная программа напоминает код для повершинной обработ­
ки света. Вершинный шейдер выполняет преобразования и сохра­
няет необходимые данные для последующей программы пиксель­
ного шейдера, которая в свою очередь выполняет все математи­
ческие операции для определения конечного цвета. Поскольку по-
пиксельные операции выполняются быстрее чем повершинные,
полученная в результате картинка будет более мягкой и реалистич­
ной. Добавьте следующую методику к вашему файлу шейдера:
technique TransformSpecularPerPixelMetallic
{
pass РО

{

// shaders
VertexShader = compile vs_l_l Transform!);
PixelShader = compile ps_2_0 ColorSpecular(true);
}
}
Переключите приложение, чтобы можно было сравнить результаты
использования двух методик.
На рис.12.2 изображена более реалистичная картинка вращающе­
гося освещенного чайника.

256
Часть III. Более совершенные методы построения графики

Рис. 12.2. Модель чайника, использующая попиксельное (per-pixel)
моделирование световых бликов

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

Краткие выводы

В этой главе мы рассмотрели следующие вопросы.
• Простая анимация вершины и цветная анимация.
• Объединение цвета текстуры с цветами поверхности.
• Более совершенные модели освещения.
В следующей мы обсудим создание анимации в Управляемом DirectX

Глава 13. Рендеринг скелетной анимации
257

Глава 13. Рендеринг скелетной

анимации

Как правило, в современных играх мы наблюдаем непрерывные сгла­
женные динамические перемещения объектов. Элементы полностью ани-
мированы, при анимации используется система захвата движения
объекта (motion capture studio). Скелетная анимация используется при
моделировании различных движений объекта или его частей. Помимо
сложных мультипликаций имеются также другие, более простые типы
анимации, имеющие дело главным образом с масштабированием, вра­
щением и перемещением. В этой главе мы рассмотрим рендеринг mesh-
объектов с анимацией данных, включая.
• Загрузку иерархической системы фреймов.
• Формирование скелетных данных.
Рендеринг каждого фрейма.
• Оптимизацию времени анимации.
Использование индексированной анимации для улучшения быст­

родействия.

Создание иерархической системы фреймов

Большинство mesh-объектов (даже не имеющих встроенной анима­
ции) обладают некоторой иерархией: рука, приложенная к груди, палец,
приложенный к руке и т. д. Данные иерархии можно загружать и удержи­
вать с помощью библиотеки расширений Direct3D.
Чтобы сохранять эту информацию, существует два абстрактных клас­
са, которые поддерживают иерархию: класс Frame и класс MeshContainer.
Каждый фрейм может содержать родственные или дочерние фреймы.
Каждый фрейм может также содержать нулевой или свободный указа­
тель zero к контейнерам класса MeshContainer.
Как обычно, начнем написание программы для Direct3D с создания
нового проекта, определения переменных, окон и т. п. Объявите следую­
щие переменные в приложении:

private AnimationRootFrame rootFrame;
private Vector3 objectCenter;
private float objectRadius;
private float elapsedTime;

Структура AnimationRootFrame содержит корневой фрейм дерева клас­
са анимации. Следующие две переменные будут содержать центр загру­
жаемого объекта mesh и радиус сферы, ограничивающей объект. Это по­
зволит позиционировать камеру таким образом, чтобы захватывать всю
9
Зак.
604

258 Часть III. Более совершенные методы построения графики
модель. Последняя переменная определяет время выполнения, которое
будет использоваться для обновления анимации.
Поскольку различные объекты анимируются по-разному, необходимо
создать новый производный класс из объекта иерархий AllocateHierarchy.
Для этого добавьте к приложению следующий класс:

public class AllocateHierarchyDerived : AllocateHierarchy

{

Forml app = null;
///
/// Create new instance of this class
///

/// Parent of this class
public AllocateHierarchyDerived(Forml parent)

{

app = parent;

}

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

public class FrameDerived : Frame

{

// Store the combined transformation matrix
private Matrix combined = Matrix.Identity;
public Matrix CombinedTransformationMatrix

{

get { return combined; } set { combined = value; }

}

}
Таким образом, в дополнении к данным нормали, записанным во фрей­
ме, каждый фрейм будет сохранять матрицу преобразований, скомбиниро­
ванную из данных фрейма и данных всех его «родителей». Это может при­
годиться в дальнейшем при формировании мировых матриц. Теперь необ­
ходимо включить производный класс mesh container, см. листинг 13.1.

Глава 13. Рендеринг скелетной анимации 259

Листинг 13.1. Добавление класса MeshContainer.
public class MeshContainerDerived : MeshContainer

{

private Texture[] meshTextures = null;
private int numAttr = 0;
private int numlnfl = 0;
private BoneCombination[] bones;
private FrameDerived[] frameMatrices;
private Matrix[] offsetMatrices;
// Public properties
public Texture[] GetTextures() { return meshTextures; }
public void SetTextures(Texture[] textures) { meshTextures = textures; }
public BoneCombination[] GetBones() { return bones; }
public void SetBones(BoneCombination[] b) { bones = b; }
public FrameDerived[] GetFrames() { return frameMatrices; }
public void SetFrames(FrameDerived[] frames) { frameMatrices = frames; }
public Matrix[] GetOffsetMatrices() { return offsetMatrices; )
public void SetoffsetMatrices(Matrix[] matrices){offsetMatrices = matrices; }
public int NumberAttributes {get{return numAttr;} set{numAttr = value;}}
public int Numberlnfluences {get{return numInfl;}set{numInfl = value;}}

}

Каждый контейнер MeshContainer будет содержать информацию, вклю­

чающую таблицу комбинаций каркасов, номера атрибутов, данные о мат­
рицах влияний и матрицах смещения. Каждый параметр этих данных
будет использоваться при рендеринге нашего анимационного объекта.
Создав необходимые производные классы, можно добавить абстракт­
ные методы. Вначале добавьте перегрузку CreateFrame к производному
классу allocate hierarchy:

public override Frame CreateFrame(string name)

{

FrameDerived frame = new FrameDerived();
frame. Name = name;
frame.TransformationMatrix = Matrix.Identity;
frame.CombinedTransformationMatrix = Matrix.Identity;
return frame;

}

Данный код записывает название фрейма, объявляет матрицы преоб­
разования и т. д. Родственные и дочерние фреймы, а также контейнеры
MeshContainer будут заполняться автоматически за время выполнения

приложения.

260 Часть III. Более совершенные методы построения графики

Для создания контейнера MeshContainer добавьте код, приведенный в

листинге 13.2.

Листинг 13.2. Создание раздела MeshContainer.
public override MeshContainer CreateMeshContainer(string name,
MeshData meshData, ExtendedMaterial[] materials,
Effectlnstance effectlnstances, GraphicsStream adjacency,
Skinlnformation skinlnfo)

{

// We only handle meshes here
if (meshData.Mesh == null)
throw new ArgumentException();
// We must have a vertex format mesh
if (meshData.Mesh.VertexFormat == VertexFormats.None)
throw new ArgumentException();
MeshContainerDerived mesh = new MeshContainerDerived();
mesh. Name = name;
int numFaces = meshData.Mesh.NumberFaces;
Device dev = meshData.Mesh.Device;
// Make sure there are normals
if ((meshData.Mesh.VertexFormat & VertexFormats.Normal) == 0)

{

// Clone the mesh
Mesh tempMesh = meshData.Mesh.Clone(meshData.Mesh.Options.Value,
meshData.Mesh.VertexFormat | VertexFormats.Normal, dev);
meshData.Mesh = tempMesh;

meshData.Mesh.ComputeNormals();

}

// Store the materials

mesh.SetMaterials(materials) ;

mesh.SetAdjacency(adjacency);

Texture[] meshTextures = new Texture[materials.Length];
// Create any textures
for (int i = 0; i < materials.Length; i++)

{
if (materials[i].TextureFilename != null)

{

meshTextures[i]
= TextureLoader.FromFile(dev,
@"..\..\"
+
materials[i].TextureFilename);
}
}

mesh.SetTextures(meshTextures);

mesh.MeshData = meshData;
// If there is skinning info, save any required data
if (skinlnfo != null)

Глава 13. Рендеринг скелетной анимации 261
mesh.Skinlnformation = skinlnfo;
int numBones = skinlnfo.NumberBones;
Matrix[] offsetMatrices = new Matrix[numBones];
for (int i = 0; i < numBones; i++)
offsetMatrices[i] = skinlnfo.GetBoneOffsetMatrix(i);
mesh.SetOffsetMatrices(offsetMatrices) ;

app.GenerateSkinnedMesh(mesh);

}

return mesh;

}
Это выглядит несколько сложнее, чем на самом деле. В первую оче­
редь проверяется, поддерживает ли приложение данный объект. Очевид­
но, что при отсутствии объекта, уже включенного в структуру данных,
параметр будет исключен (строка throw new ArgumentException). To же
самое произойдет, если включенный в структуру объект не использует
допустимый вершинный формат.
В случае, если данные объекта mesh достоверны, создается новый
контейнер MeshContainer, куда наряду с устройством записываются имя
и число поверхностей объекта. Код может также использовать дополни­
тельную индивидуальную переменную для доступа к винформам уст­

ройства.

Далее идет более-менее знакомый нам фрагмент кода — проверяются
данные нормали для объекта. Если данные отсутствуют, программа до­
бавляет их к объекту. Затем сохраняются материалы и информация смеж­
ности «adjacency», а также создается массив данных текстур заданных

материалов. Далее записывается соответствующая текстура в каждый член

массива, который затем сохраняется в контейнере MeshContainer.
В конце проверяется наличие скелетной информации в контейнере
MeshContainer, после чего информация сохраняется, и формируется мас-
• сив из матриц смещения (для каждого каркаса). После этого из нашей
формы вызывается пока еще не существующий метод GenerateSkinned-
Mesh. По этой причине приложение все еще не будет компилировать про­
грамму, необходимо добавить метод GenerateSkinnedMesh, приведенный
в листинге 13.3, в наш основной класс.

Листинг 13.3. Создание каркасных объектов Skinned Meshes.
public void GenerateSkinnedMesh(MeshContainerDerived mesh)

{

if (mesh.SkinInformation == null)
throw new ArgumentException() ;
int numlnfl = 0;

262
Часть III. Более совершенные методы построения графики

BoneCombination[] bones;
// Use ConvertToBlendedMesh to generate a drawable mesh
MeshData m = mesh.MeshData;
m.Mesh = mesh.Skinlnformation.ConvertToBlendedMesh(m.Mesh,
MeshFlags.Managed
| MeshFlags.OptimizeVertexCache, mesh.GetAdjacencyStream(), out numlnfl,

out bones);

// Store this info
mesh.Numberlnfluences = numlnfl;

mesh.SetBones (bones);

// Get the number of attributes
mesh.NumberAttributes = bones.Length;
mesh.MeshData = m;

}

Данный метод никогда не вызывается, если не имеется никакой ске­
летной информации. Мы временно сохраняем данные объекта и исполь­
зуем метод ConvertToBlendedMesh, чтобы создать новый объект с повер-
шинной комбинацией весов и таблицей комбинаций каркасных элемен­
тов. Это — «корневой» метод для анимирования объекта. Наконец, мы
сохраняем набор связей в этом объекте, таблицу комбинаций каркасных
элементов и атрибуты.

Загрузка объектов с анимацией

Итак, в предыдущем параграфе была установлена основная иерархия
объекта. Теперь нам необходимо записать некоторый код, чтобы факти­
чески использовать ее. Как обычно, нам нужно инициализировать гра­
фическое устройство, используя метод, аналогичный используемым нами
ранее в программируемом конвейере, см. листинг 13.4.

Листинг 13.4. Инициализация графики.
public bool InitializeGraphics()

{

// Set our presentation parameters
PresentParameters presentParams = new PresentParameters();
presentParams.Windowed = true;
presentParams.SwapEffeet = SwapEffeet.Discard;
presentParams.AutoDepthStencilFormat = DepthFormat.D16;
presentParams.EnableAutoDepthStencil = true;
bool canDoHardwareSkinning = true;
// Does a hardware device support shaders?
Caps hardware = Manager.GetDeviceCaps(O, DeviceType.Hardware);
// We will need at least four blend matrices
if (hardware.MaxVertexBlendMatrices >= 4)

Глава 13. Рендеринг скелетной анимации 263
// Default to software processing
CreateFlags flags = CreateFlags.SoftwareVertexProcessing;
// Use hardware if it's available
if (hardware.DeviceCaps.SupportsHardwareTransformAndLight)
flags = CreateFlags.HardwareVertexProcessing;
// Use pure if it's available
if (hardware.DeviceCaps.SupportsPureDevice)
flags != CreateFlags.PureDevice;
// Yes, Create our device
device = new Device(0, DeviceType.Hardware, this, flags, presentParams);

}

else

{

//No shader support
canDoHardwareSkinning = false;
// Create a reference device
device = new Device(0, DeviceType.Reference, this,
CreateFlags.SoftwareVertexProcessing, presentParams);

}

// Create the animation
CreateAnimation(@".,\..\tiny.x", presentParams);
// Hook the device reset event
device.DeviceReset += new EventHandler(OnDeviceReset);

OnDeviceReset(device, null);

return canDoHardwareSkinning;

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

Листинг 13.5. Обработчик события сброса устройства.
private void OnDeviceReset(object sender, EventArgs e)

{

Device dev = (Device)sender;
// Set the view matrix
Vector3 vEye = new Vector3( 0, 0, -1.8f * objectRadius );
Vector3 vUp = new Vector3( 0, 1, 0 );

264 Часть III. Более совершенные методы построения графики

dev.Transform.View = Matrix.LookAtLH(vEye, objectCenter, vUp);
// Setup the projection matrix
float aspectRatio = (float)dev.PresentationParameters.BackBufferWidth
/ (float)dev.PresentationParameters.BackBufferHeight,
dev.Transform.Projection = Matrix.PerspectiveFovLH( (float)Math.PI / 4,
aspectRatio, objectRadius/64.0f, objectRadius*200.0f );
// Initialize our light
dev.Lights[0].Type = LightType.Directional;
dev.Lights[0].Direction = new Vector3(0.0f, O.Of, l.Of);
dev.Lights[0].Diffuse = Color.White;

dev.Lights[0].Commit () ;

dev.Lights[0].Enabled = true;

}

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

private void CreateAnimation(string file, PresentParameters presentParams)

{

// Create our allocate hierarchy derived class
AllocateHierarchyDerived alloc = new AllocateHierarchyDerived(this);
// Load our file
rootFrame = Mesh.LoadHierarchyFromFile(file, MeshFlags.Managed,

device, alloc, null);

// Calculate the center and radius of a bounding sphere
obj ectRadius = Frame.CalculateBoundingSphere(rootFrame.FrameHierarchy,
out objectCenter);
// Setup the matrices for animation
SetupBoneMatrices((FrameDerived)rootFrame.FrameHierarchy);
// Start the timer

DXUtil.Timer(DirectXTimer.Start) ;

}

Метод кажется довольно простым, но в действительности он вызыва­
ет другие методы.
Сначала реализуется производный класс allocate hierarchy. Затем вызыва­
ется метод LoadffierarchyFromFile. При вызове этого метода следует учесть,
что перегрузки CreateFrame и CreateMeshContainer вызываются неоднократ­
но, в зависимости от числа фреймов и контейнеров MeshContainer в вашем
объекте. Возвращаемый объект AnimationRootFrame будет включать корне­
вой фрейм иерархичного дерева и контроллер анимации для этого объекта.

Глава 13. Рендеринг скелетной анимации 265
После создания иерархии рассчитывается граничная сфера всего фрей­
ма (метод CalculateBoundingSphere). Метод CalculateBoundingSphere воз­
вращает радиус этой сферы и центр объекта (который уже использовался
для установки камеры).
И, последнее, создаются матрицы каркасов (Bone Matrices). Это пер­
вый метод, который будет обходить дерево иерархии фрейма, и он же
будет базовым для остальных методов, приведенных в листинге 13.6.

Листинг 13.6. Создание матриц каркасов.
private void SetupBoneMatrices(FrameDerived frame)

{

if (frame.MeshContainer != null)

{

SetupBoneMatrices((MeshContainerDerived)frame.MeshContainer);

}

if (frame.FrameSibling != null)

{

SetupBoneMatrices((FrameDerived)frame.FrameSibling) ;

}

if (frame.FrameFirstChild != null)

{
SetupBoneMatrices((FrameDerived)frame.FrameFirstChild);

}

}

private void SetupBoneMatrices(MeshContainerDerived mesh)

{

// Is there skin information? If so, setup the matrices
if (mesh.Skinlnformation != null)

{

int numBones = mesh.Skinlnformation.NumberBones;
FrameDerived[] frameMatrices = new FrameDerived[numBones];
for (int i = 0; i< numBones; i++)

{

FrameDerived frame = (FrameDerived)Frame.Find(
rootFrame.FrameHierarchy,

mesh.Skinlnformation.GetBoneName(i)) ;

if (frame == null)
throw new ArgumentException();
frameMatrices [i] = frame;

}

mesh.SetFrames(frameMatrices);

}
}

266 Часть III. Более совершенные методы построения графики
Как вы можете видеть, обход иерархии не представляется сложным.
Если имеется родственный фрейм, вызывается непосредственно метод, в
котором мы в настоящее время находимся. То же самое происходит, если
имеются дочерние фреймы. Следует отметить, что при дочерних фрей­
мах вызывать метод из самого себя целесообразно только один раз, по­
скольку последующие дочерние фреймы будут друг для друга родствен­
ными. В этом случае мы сохраняем каждый фрейм в соответствии с на­
званием его каркаса.
Перегрузка, которая принимает фрейм, не представляет интереса, ее
единственное назначение заключается в обходе иерархичного дерева и
передаче контейнера MeshContainer во вторую перегрузку. Таким обра­
зом, мы создали массив фреймов (для каждого каркаса объекта), описы­
вающий скелетную информацию, которая понадобится нам в дальней­

шем.

ИСПОЛЬЗОВАНИЕ ТАЙМЕРА DIRECTX

Для системы анимации понадобится использование высокоточно­

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

ние таймера DirectX, который включен в SDK. Мы можем добавить

этот файл к проекту, щелкнув по папке Add Existing Item и выбрав

исходный файл утилиты dxutil.cs.

Теперь настало время переписать наш основной метод с учетом ини­
циализации нашей новой графики, см. листинг 13.7.

Листинг 13.7. Основная точка входа.
static void Main()

{

using (Forml frm = new Forml())

{

// Show our form and initialize our graphics engine

frm.Show();

if (!frm.InitializeGraphics())

{
MessageBox.Show("Your card can not perform skeletal animation on " +
"this file in hardware. This application will run in " +
"reference mode instead.");

}

Application.Run(frm);
}
}

Глава 13. Рендеринг скелетной анимации 267

Рендеринг анимированных объектов

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

Листинг 13.8. Рендеринг анимированного бъекта.
protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)

{

ProcessNextFrame();

device.Clear(ClearFlags.Target | ClearFlags.ZBuffer,
Color.CornflowerBlue, l.Of, 0);

device.BeginScene(),

// Draw our root frame
DrawFrame((FrameDerived)rootFrame.FrameHierarchy);

device. EndScene() ;

device.Present();

this. Invalidated();

}
Далее мы объявляем метод обработки фрейма «ProcessNextFrame»,
очищаем устройство и рисуем корневой фрейм:

private void ProcessNextFrame()

{

// Get the current elapsed time
elapsedTime = DXUtil.Timer(DirectXTimer.GetElapsedTime);
// Set the world matrix
Matrix worldMatrix = Matrix.Translation(objectCenter) ;
device.Transform.World = worldMatrix;
if (rootFrame.AnimationController != null)
rootFrame.AnimationController.AdvanceTime(elapsedTime, null);
UpdateFrameMatrices((FrameDerived)rootFrame.FrameHierarchy, worldMatrix);

}
Вначале сохраняется текущее время исполнения, параметр elapsed
time. Затем создается мировая матрица для корневого фрейма (в прин­
ципе, это матрица перемещения в центр объекта, с последующим об­
новлением устройства). Полагая, что объект можно анимировать, мы
устанавливаем временной параметр advance time, используя сохранен­
ный параметр elapsed time. Теперь необходимо перезаписать матрицы

преобразования:

268 Часть III. Более совершенные методы построения графики

private void UpdateFrameMatrices(FrameDerived frame, Matrix parentMatrix)

{

frame.CombinedTransformationMatrix = frame.TransformationMatrix *
parentMatrix;
if (frame.FrameSibling != null)

{

UpdateFrameMatrices((FrameDerived)frame.FrameSibling, parentMatrix);

}

if (frame.FrameFirstChild != null)

{

UpdateFrameMatrices((FrameDerived)frame.FrameFirstChild,
frame.CombinedTransformationMatrix);

}
}
В этом методе общая матрица преобразования текущего фрейма по­
лучена путем умножения матрицы преобразования имеющегося фрейма
на родительскую матрицу преобразования. Каждый из родственных фрей­
мов использует соответствующую родительскую матрицу текущего фрей­
ма. Каждый из дочерних фреймов должен использовать общую матрицу
преобразования текущих фреймов, чтобы объединить ее с собственной.
Таким образом, формируется цепочка матриц, где окончательный дочер­
ний фрейм имеет собственную матрицу преобразования, объединенную
с каждой родительской матрицей.
Теперь мы можем нарисовать наш объект, используя знакомый нам
метод рисования DrawFrame:

private void DrawFrame(FrameDerived frame)

{

MeshContainerDerived mesh = (MeshContainerDerived)frame.MeshContainer;
while(mesh != null)

{

DrawMeshContainer(mesh, frame);

mesh = (MeshContainerDerived)mesh.NextContainer;

}

if (frame.FrameSibling != null)

{

DrawFrame((FrameDerived)frame.FrameSibling);

}

if (frame.FrameFirstChild != null)

{

DrawFrame((FrameDerived)frame.FrameFirstChild);

}

}

Глава 13. Рендеринг скелетной анимации 269

Здесь выполняется знакомый нам обход иерархии, программа пытает­
ся нарисовать каждый контейнер MeshContainer, на который ссылается
используемый фрейм. Для рендеринга соответствующего MeshContainer
добавьте к приложению метод, приведенный в листинге 13.9.

Листинг 13.9. Рендеринг контейнера MeshContainer.
private void DrawMeshContainer(MeshContainerDerived mesh, FrameDerived
frame)

{

// Is there skin information?
if (mesh.Skinlnformation != null)

{

int attribldPrev = -1;
// Draw
for (int iattrib = 0; iattrib < mesh.NumberAttributes; iattrib++)

{

int numBlend = 0;
BoneCombination[] bones = mesh.GetBones() ;
for (int i = 0; i < mesh.Numberlnfluences; i++)

{

if (bones[iattrib].BoneId[i] != -1)

{

numBlend = i;

}
}
if (device.DeviceCaps.MaxVertexBlendMatrices >= numBlend + 1)

{

// first calculate the world matrices for the current set of
// blend weights and get the accurate count of the number of
// blends
Matrix[] offsetMatrices = mesh.GetOffsetMatrices();
FrameDerived[] frameMatrices = mesh.GetFrames();
for (int i = 0; i < mesh.Numberlnfluences; i++)

{

int matrixlndex = bones[iattrib].BoneId[i];
if (matrixlndex != -1)

{

Matrix tempMatrix = offsetMatrices[matrixlndex] *
frameMatrices[matrixlndex].
CombinedTransformationMatrix;
device.Transform.SetWorldMatrixByIndex(i, tempMatrix);

}
}

270
Часть III. Более совершенные методы построения графики
device.RenderState.VertexBlend = (VertexBlend)numBlend;
// lookup the material used for this subset of faces
if ((attribldPrev != bones[iattrib].Attribld) ||
(attribldPrev == -1))

{

device.Material = mesh.GetMaterials() [

bones[iattrib].Attribld].Material3D;

device.SetTexture(0, mesh.GetTextures() [

bones[iattrib].Attribld]) ;

attribldPrev = bones[iattrib].Attribld;

}

mesh.MeshData.Mesh.DrawSubset(iattrib);

}

}

)
else // standard mesh, just draw it after setting material properties

{

device.Transform.World = frame.CombinedTransformationMatrix;
ExtendedMaterial[] mtrl = mesh.GetMaterials();
for (int iMaterial = 0; iMaterial < mtrl.Length; iMaterial++)

{

device.Material = mtrl[iMaterial].Material3D;
device.SetTexture(0, mesh.GetTextures() [iMaterial]);
mesh.MeshData.Mesh.DrawSubset(iMaterial);

}

}

}
Размер листинга данного метода впечатляет, хотя, если рассматривать
его по частям, это выглядит не так сложно. Вначале проверяются данные
об оболочке, значение Skinlnformation. Если контейнер Meshcontainer не
содержит никакой скелетной информации, объект будет рендирован точ­
но так же, как мы делали это ранее при отображении обычных объектов.
При наличии скелетной информации способы рендеринга могут быть

различными.

АНИМАЦИЯ ОБЪЕКТОВ, НЕ ИМЕЮЩИХ КАРКАСА

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

Глава 13. Рендеринг скелетной анимации 271
Далее в листинге для каждого принимаемого атрибута объекта (набор
материалов, текстур и пр.) выполняются различные операции. Вначале
просматривается таблица комбинаций каркасов, и определяются весо­
вые коэффициенты, которые объект будет использовать. Файл примера,
включенный к CD диск, использует максимум четыре весовых парамет­
ра, при этом подразумевается, что устройство имеет возможность объе­
динять и оперировать большим количеством матриц.
После проверки того, что устройство может отображать объект с оп­
ределенными весовыми коэффициентами, необходимо выполнить пре­
образование координат.
Для каждого элемента, найденного по идентификационному номеру
в таблице комбинаций каркасов, матрица смешения объединяется с об­
шей матрицей преобразования фрейма, и текущая индексированная ми­
ровая матрица, преобразованная в результирующую матрицу, сохраня­
ется. Это позволит приложению Direct3D отобразить каждую интерпо­
лированную вершину (blended vertex) в соответствии с преобразовани­
ем координат.
После выполнения этих операций устанавливается состояние рейде­
ра интерполированной вершины в соответствии с номером numBlend
объекта. И, наконец, устанавливаются и затем отображаются материал и
текстура данного подмножества.
Запуская приложение, мы должны увидеть на экране модель, идущую
по направлению к нам, рис.13.1

Рис. 13.1. Аиимированный объект

272
Часть III. Более совершенные методы построения графики

ИСПОЛЬЗОВАНИЕ ОБЪЕКТОВ «INDEXED MESH» ДЛЯ АНИМАЦИИ

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

кода.

Прежде чем модифицировать наш объект, необходимо выполнить
некоторые действия. Сначала следует добавить новый объект к про­
изводному классу mesh container:

private int numPal = 0;
public int NumberPaletteEntries

{

get ( return numPal; } set ( numPal = value; }

}

Это позволит сохранить число каркасных матриц, которые могут ис­
пользоваться для матричной палитры skinning при преобразовании
нашего объекта. Затем, поскольку мы больше не будем использо­
вать стандартную интерполяцию вершин для нашей анимации, не­

обходимо переписать метод инициализации, проверяя возможность

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

if (hardware.MaxVertexBlendMatrixIndex >= 12)

Все, что теперь требуется, — заменить запрос создания объекта
(листинг 13.10) и затем вызов рисунка (листинг 13.11).

Листинг 13.10. Создание объекта Mesh.
public void GenerateSkinnedMesh(MeshContainerDerived mesh)

{

if (mesh.Skinlnformation == null)
throw new ArgumentException();
int numMaxFacelnfl;
MeshFlags flags = MeshFlags.OptimizeVertexCache;
MeshData m = mesh.MeshData;
using(IndexBuffer ib = m.Mesh.IndexBuffer)

{

numMaxFacelnfl = mesh.SkinInformation.GetMaxFaceInfluences(ib,

m.Mesh.NumberFaces);

Глава 13. Рендеринг скелетной анимации
273

}

//12 entry palette guarantees that any triangle (4 independent
// influences per vertex of a tri) can be handled
numMaxFacelnfl = (int)Math.Min(numMaxFacelnfl, 12);
if (device.DeviceCaps.MaxVertexBlendMatrixIndex + 1 >= numMaxFacelnfl)

{

mesh.NumberPaletteEntries = (int)Math.Minf(device.DeviceCaps.
MaxVertexBlendMatrixIndext 1) /2,

mesh.Skinlnformation.NumberBones);

flags != MeshFlags.Managed;

}

BoneCombination[] bones;
int numlnfl;
m.Mesh = mesh.Skinlnformation.ConvertToIndexedBlendedMesh(m.Mesh, flags,
mesh.GetAdjacencyStreamf), mesh.NumberPaletteEntries, out numlnfl,

out bones);

mesh.SetBones(bones);

mesh.Numberlnfluences = numlnfl;
mesh.NumberAttributes = bones.Length;
mesh.MeshData = m;

Вначале определяется максимальное число влияний поверхности
(face influences), в этом объекте их необходимо по крайней мере 12
(4 значения интерполяции для каждой вершины в треугольнике).
Полагая, что наше устройство поддерживает эту возможность (про­
веряется в методе инициализации), мы вычисляем число входов
палитры (либо число каркасов, либо половина от максимального
числа поддерживаемых влияний поверхности).
Теперь мы можем преобразовывать наш объект в индексный и со­
хранять те же самые данные, которые мы использовали в нашей не-
индексированной версии. Итак, заменяем вызов рисунка, см. лис­
тинг 13.11. Для краткости мы включаем только код внутри блока, под­
разумевая, что значение оболочки «skin» ненулевое.

Листинг. 13.11. Вызов рисунка.
if (mesh.Numberlnfluences == 1)
device.RenderState.VertexBlend = VertexBlend.ZeroWeights;
else
device.RenderState.VertexBlend = (VertexBlend)(mesh.Numberlnfluences - 1);
if (mesh.Numberlnfluences > 0)
device.RenderState.IndexedVertexBlendEnable = true;
BoneCombination[] bones = mesh.GetBonesf);
for(int iAttrib = 0; iAttrib < mesh.NumberAttributes; iAttrib++)

{

274
Часть III. Более совершенные методы построения графики
// first, get world matrices
for (int iPaletteEntry = 0; iPaletteEntry < mesh.NumberPaletteEntries;

++iPaletteEntry)

{

int iMatrixIndex = bones[iAttrib].BoneId[iPaletteEntry];
if (iMatrixIndex != -1)
{
device.Transform.SetWorldMatrixByIndex(iPaletteEntry,
mesh.GetOffsetMatricesO [iMatrixIndex] *

mesh.GetFramesO [iMatrixIndex].

CombinedTransformationMatrix);

}
}
// Setup the material
device.Material = mesh.GetMaterials()[bones[iAttrib].Attribld].Material3D; '
device.SetTexture(0, mesh.GetTextures()[bones[iAttrib].Attribld]) ;
// Finally draw the subset
mesh.MeshData.Mesh.DrawSubset(iAttrib);
}
Этот метод более прост в написании. Вначале мы определяем состоя­
ние рендера интерполированной вершины как «-1». Затем, если есть
влияния (для случая скелетной анимации), состояние рендера прини­
мает значение «true» для параметра IndexedVertexBlendEnable.
Остальная часть кода подобна предыдущему методу. Для каждого
входа палитры записывается соответствующая мировая матрица с
учетом индекса общей матрицы смещения и фреймов общей мат­
рицы преобразования. После записи мировых матриц можно уста­
навливать материалы, текстуры и рисовать каждое подмножество.
Использование индексированного mesh-объекта более предпочти­
тельно в плане быстродействия (от 30% и более, в зависимости от
типа данных), чем использование обычного mesh-объекта.
Краткие выводы

В этой главе мы ознакомились с основами анимации, включая скелет­

ную анимацию. Основные рассмотренные в этой главе темы.

• Создание и загрузка иерархической системы фреймов.

• Просмотр иерархии, рендеринг фреймов.

Формирование скелетных данных.

Использование контроллера анимации.

Использование «indexed mesh».

В следующей главе мы обсудим использование звука в создаваемых

приложениях.

ЧАСТЬ IV

ЗВУК И УСТРОЙСТВА ВВОДА

Глава 14. Добавление звука
Глава 15. Управление устройствами ввода

276 Часть IV. Звук и устройства ввода

Глава 14. Добавление звука

Ни одно графическое приложение или игра не будет живым, если вы
не добавили соответствующее окружение, атмосферу и особенно звук.
Можете ли вы представить известную игру Рас-Man без знакомого звуко­
вого сопровождения? В этой главе мы изучим добавление звука в наши
приложения. Темами, которые мы обсудим, являются.
• Загрузка и проигрывание статических звуков.
• Проигрывание звуков в 3D пространстве.
• Проигрывание звуков с эффектами.

Включение пространства имен SOUND

Звуковые ресурсы, которые мы будем использовать, отсутствуют в
списке имен Direct3D, вместо этого необходимо использовать простран­
ство имен Microsoft.DirectX.DirectSound. Для каждого из примеров, ко­
торые будут рассмотрены в этой главе, необходимо добавить ссылку на
указанную сборку, также как и директиву using.

Загрузка и проигрывание статических

звуков

В начале выясним, что мы хотим сделать для добавления звука? Напри­

мер, иметь некоторый тип звуковых данных, выводимых на динамики, при­

ложенные к системе. Подобно классу Device для приложения Direct3D,
который управляет аппаратным обеспечением компьютерной графики, в
приложении DirectSound имеется класс Device, который управляет звуко­
выми аппаратными средствами. Поскольку оба этих классов совместно
используют одно и тоже название (в различных пространствах имен), не­
обходимо строго описывать ссылки на переменную Device, если мы под­
разумеваем использование Direct3D и DirectSound в одном файле кода.
Подобно графическим буферам в Direct3D, приложение DirectSound
имеет буферы для обработки, передачи и вывода звуковых данных. В
DirectSound существуют только два типа буферов: либо основной класс
Buffer, либо производный от него объект SecondaryBuffer.
Итак, вначале мы создаем новый проект, включаем в него ссылки на
DirectSound, а затем добавляем следующие объявления переменных:
private Device device = null;
private SecondaryBuffer sound = null;

Для проигрывания загружаемых звуковых данных нам нужно иметь одно

звуковое устройство и один буфер SecondaryBuffer. Теперь мы можем запи­
сать метод инициализации звука InitializeSound, который позволяет запус-

Глава 14. Добавление звука
277

кать и проигрывать звук. Поскольку указанный метод будет ссьшаться на
звуковой файл, необходимо это предусмотреть. Используемый в этом мето­
де звуковой файл скопирован из DirectX SDK. Добавьте следующий код:
public void InitializeSound()
{

device = new Device ();

device.SetCooperativeLevel(this, CooperativeLevel.Normal);
sound = new SecondaryBuffer(@"..\..\drumpad-crash.wav", device);
sound.Play(0, BufferPlayFlags.Default);
}
Приведенный здесь код достаточно прост. Используя простой конструк­
тор параметров, мы создаем новое устройство (другие варианты загрузки
этого объекта мы рассмотрим позднее) и определяем уровень совместного
доступа к устройству CooperativeLevel.Normal. Поясним подробнее.
Звуковые устройства компьютера используются многими приложени­
ям. Система Windows может подавать звуковой сигнал каждый раз, когда
возникает ошибка. Система Messenger может подавать звуковой сигнал,
когда кто-то вошел или зарегистрировался, и все это может происходить,
например, во время прослушивания музыки. Уровень совместного досту­
па используется, чтобы определить степень совместного с другими прило­
жениями использования звуковых карт. В нашем примере данный пара­
метр определен по умолчанию. Это подразумевает многозадачный режим
и совместно используемые ресурсы. Описание других уровней доступа,
например, приоритетных, можно найти в документации DirectX SDK.
После установки уровня доступа можно создать или загрузить буфер
из файла (код, включенный в CD диск DirectX SDK, использует простой
звук) и затем уже проигрывать звук. Первый параметр вызова проигры­
вания звука — приоритет, который имеет смысл только, если буфер со­
здается с задержкой (чего мы пока не имеем). Теперь, используя задан­
ные по умолчанию флажки, вызываем процедуру проигрывания содер­
жимого буфера:
static void Main()

{

using (Forml frm = new Forml())
{
frm.InitializeSoundO ;
Application.Run(frm);

}

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

278 Часть IV. Звук и устройства ввода
Конструктор для буфера SecondaryBuffer требует несколько отличных
параметров. Рассмотрим две основных разновидности этого конструктора:
public SecondaryBuffer ( System.String fileName ,

Microsoft.DirectX.DirectSound.BufferDescription desc ,

Microsoft.DirectX.DirectSound.Device parent )

public SecondaryBuffer ( System.10.Stream source , System.Int32 length ,

Microsoft.DirectX.DirectSound.BufferDescription desc ,

Microsoft.DirectX.DirectSound.Device parent )
Все конструкторы вторичного буфера оперируют с устройством, ко­
торое будет использоваться для проигрывания звуковых данных. Конст­
рукторы могут принимать либо имя JileName файла загружаемых звуко-
вых данных, либо поток, который содержит звуковые данные. Для опи­
сания различных опций буфера, который вы создаете, существует конст­
руктор BufferDescription. Все создаваемые буферы имеют характеристи­
ки, и, если вы не задаете конструктор BufferDescription, то значения его
параметров и флажков устанавливаются по умолчанию. Свойства конст­
руктора BufferDescription приведены в таблице 14.1.

Таблица 14.1. Свойства и флажки конструктора BufferDescription

Название
Описание

BufferBytes
Размер буфера в байтах (чтение-запись). Если вы создаете первичный буфер или буфер из потока или звукового файла, вы можете оставить этотму параметру нулевое значение

CanGetCurrentPosition
Атрибут чтение-запись. Является булевой переменной, уточняет, нужна ли точная позиция
проигрывания

Contro3D
Атрибут чтение-запись. Является булевой переменной, сообщает, можно ли манипулировать вашим буфером в 3D-пространстве. Эта опция не может использоваться, если ваш буфер содержит формат стерео (два канала), или опция ControlPan установлена в значение «true»
ControlEffects Атрибут чтение-запись. Является булевой переменной, указывает на то, что буфер может или не может использовать обработку эффектов. Чтобы использовать эти эффекты, необходимо иметь 8- или 16-разрядные аудио данные формата РСМ, при этом возможно использование не более двух каналов (стерео)

Глава 14. Добавление звука 279
Название

ControlFrequency

ControlPan

ControlPositionNotify
ControlVolume
Описание
Атрибут чтение-запись. Является булевой переменной, устанавливает возможность изменения частоты обращения к буферу (при значении «true»)
Атрибут чтение-запись. Является булевой переменной, определяет возможность поддержки опции panning (панорама), не может использоваться с флажком Contro3D
Атрибут чтение-запись. Является булевой переменной, показывает, поддерживает ли буфер указание на позицию
Атрибут чтение-запись. Является булевой переменной, указывает на то, что буфер может или не может управлять громкостью
DeferLocation Атрибут чтение-запись. Является булевой пере­ менной, указывает, может ли буфер присоединять­ся к устройству во время проигрывания. Данный флажок должен принимать значение «true» для буферов, поддерживающих голосовое управление.
Flags Поразрядная комбинация перечисления BufferDescriptionFlags. Значения для этих элементов установлены как логические переменные, например:
desc. ControlPan = true; desc.ControlEffects = true;
что аналогично следующему:
desc.Flags = BufferDescriptionFlags.ControlPan BufferDescriptionFlags.ControlEffects;
Format Атрибут чтение-запись. Определяет акустический формат создаваемых или загружаемых в буфер звуковых данных
GlobalFocus Атрибут чтение-запись. Булева переменная. При значении по умолчанию («false») звук проигрывается, если приложение активно. При значении «true» звук будет проигрываться в любом состоянии приложения
Guid3DAlgorithm Атрибут чтение-запись. Идентификатор GUID. Определяет алгоритм, используемый для 3D-виртуализации. Вы можете использовать любую из констант DSoundHelper.Guid3Dxxxx, перечисленных в Управляемом DirectX для встроенных режимов

280 Часть IV. Звук и устройства ввода
Название Описание

LocatelnHardware
Атрибут чтение-запись, булева переменная. Определяет обработку буфера аппаратными средствами. Если значением является «true», a необходимая аппаратная поддержка отсутствует, при создании буфера произойдет ошибка
LocatelnSoftware Атрибут чтение-запись, булева переменная. Определяет обработку буфера программными средствами, значение «true» разрешает программную обработку независимо от аппаратных ресурсов

Mute3DAtMaximumDistance
Атрибут чтение-запись, булева переменная, определяет остановку проигрывания при достижении максимальной дистанции. Параметр применим только к программным буферам
PrimaryBuffer Атрибут чтение-запись. Показывает, является ли буфер первичным.
StaticBuffer Атрибут чтение-запись, булева переменная. Определяет размещение буфера в аппаратной памяти (значение «true»), если она поддерживается, либо в программной памяти, если аппаратная недоступна. При использовании данного флажка вы не можете задавать значение «true» для флажка ControlEffects (см. выше)
StickyFocus Атрибут чтение-запись. Булева переменная. Определяет использование закрепленного фокуса. Как уже упоминалось при обсуждении флажка глобального фокуса, значение по умолчанию для DirectSound прекращает проигрывание буфера, если ваше окно не активно. Если флажок установлен в значение «true», буфер будет продолжать проигрывание, даже если окно уже не использует DirectSound
Таким образом, имеется несколько опций для буфера. В следующем
примере мы рассмотрим работу некоторых из них. Мы постараемся уп­
равлять некоторыми параметрами, как-то: перетекание звука, панорама
звука и т. д.
Чтобы выполнить это, нам необходимо использовать определение клас­
са «buffer description». Добавьте следующий код после вызова установки
уровня доступа SetCooperativeLevel:

BufferDescription desc = new BufferDescription(
desc.ControlPan = true;
desc.GlobalFocus = true;

Глава 14. Добавление звука 281
По существу, мы сообщаем приложению DirectSound, что создадим
буфер и будем управлять панорамой звука. Также определяем буфер как
глобальную переменную.
Теперь мы должны определить процедуру создания буфера с помо­
щью конструктора, использующего описание уже созданного нами буфе­
ра. Для улучшения эффекта мы зацикливаем буфер на время проигрыва­
ния. Для выполнения этого измените код следующим образом:

sound = new SecondaryBuffer(@".,\..\drumpad-crash.wav",desc, device);
sound.Play(0, BufferPlayFlags.Looping);

При запуске приложения произойдет непрерывное проигрывание зву­
кового файла, но при этом мы пока еще не изменяли панорамное значение
нашего буфера. Для разнообразия можно обновлять его каждые 50 милли­
секунд. Для в этого в окне design view нашей формы добавим таймер и
установим интервал 50 миллисекунд. Добавьте следующий код обработ­
чика таймера (либо дважды кликните на таймер в окне design view):

private void timerl_Tick(object sender, System.EventArgs e)

{

// Adjust the pan

sound.Pan *= -1;

}
Панорамное значение — целочисленное значение, которое определя­

ет позицию стерео звука; чем «отрицательнее» значение, тем больше звука

выходит из левого динамика. Чем больше положительное значение — из
правого. Нулевое значение (значение по умолчанию) уравнивает звук из
обоих динамиков. Теперь установите начальное значение панорамирова­
ния на левый динамик и запустите таймер. Добавьте этот код непосред­
ственно после вызова проигрывания в InitializeSound:

sound.Pan = -5000;
timerl.Enabled = true;

Добавив таймер, запускаем приложение. Мы должны услышать про­
игрывание нашего звукового файла, при этом звук должен перетекать из
динамика в динамик. Как оказалось, использовать звуки для нашего при­
ложения — не такая сложная процедура.

Использование 3D-звука

Многие компьютерные мультимедийные системы в настоящее время
используют новейшие модели колонок и звуковых плат класса «Hi-End».

282 Часть IV. Звук и устройства ввода
Уже трудно кого-нибудь удивить системами объемного звучания, а для
разработчиков компьютерных игр это вообще является нормой.
Приложение DirectSound API уже имеет возможность запускать звуки
в трехмерном пространстве и может использовать их особенности (если
компьютер поддерживает эти опции). Опции управляются посредством
объектов Buffer3D (чтобы управлять источником звука) и Listener3D (что­
бы управлять позицией и ориентацией слушателя). Обратите внимание
на то, что каждый из этих конструкторов использует ЗD-звук. Эти буфе­
ры должны создаваться с разрешенным флажком ControBD (значение
«true»).
Какие же преимущества дает ЗD-звук? Это наиболее ощутимо, когда
мы находимся в кинотеатре, где используются системы объемного звуча­
ния, когда различные объекты издают звук из различных динамиков. Со­
временные игры также требуют все большего развития систем воспроиз­
ведения звука.
Когда мы хотим манипулировать ЗD-звуком, мы можем управлять ис­

точниками звука или «ушами» (то есть слушателем), принимающими звук.

Для начала, используя объект Buffer3D, мы можем рассмотреть переме­
щение вокруг источника звука
Этот объект-класс предназначен для управления ЗD-настройками бу­
фера. Параметры объекта Buffer3D и их описание приведены в табли­
це 14.2.
Таблица 14.2. Параметры и свойства объекта Buffer3D
Название Описание
ConeAngles Атрибут чтение-запись. Используется для установки углов относительно конуса проекции. Оба угла (внутренний и внешний) определены в градусах. Звуки в пределах внутреннего конического угла находятся на нормальном уровне, в то время, как вне его — на окружающем фоновом уровне
ConeOrientation Атрибут чтение-запись. Используется для ориентирова­
ния конуса проекции. Приложение DirectSound автома­тически нормализует соответствующий вектор (цент­ральный вектор конуса проекции)
ConeOutsideVolume Атрибут чтение-запись. Используется для регулировки уровня звука, находящегося за пределами угла звукового конуса
Deferred Атрибут чтение-запись. Булева переменная. Определяет, изменяются ли регулируемые параметры сразу либо они задерживаются, пока пользователь изменяет установки. По умолчанию данное значение «false», то есть свойства изменяются сразу

Глава 14. Добавление звука 283

Название

MaxDistance

MinDistance

Описание

Атрибут чтение-запись. Определяет максимальное расстояние до слушателя, при котором звук еще не
затухает

Атрибут чтение-запись. Определяет минимальное расстояние до слушателя, при котором звук начинает
затухать

Mode Атрибут чтение-запись. Определяет режим звуковой обработки. Значение по умолчанию — режим Mode3D.Normal. Вы можете также использовать Mode3D.Disable, который отключает обработку 3D-звука, или Mode3D.HeadRelative, который подразумевает регулировку звука слушателем
Position Атрибут чтение-запись. Определяет текущее местоположение источника звука в мировых
координатах

Velocity Атрибут чтение-запись. Определяет скорость перемещения источника звука (по умолчанию значение в метрах на секунду)
Имеется и другой флажок AllParameters, позволяющий изменять все
установки сразу. Можно попробовать переписать последний пример, ис­
пользующий параметр панорамы, установив вместо него параметр

3Dprocessing.

Звуковой файл, который мы использовали до настоящего времени,
имеет стерео звучание, т. е. имеет два отдельных канала для левого и
правого динамиков. Чтобы использовать трехмерную обработку, мы дол­
жны использовать файл с монозвуком (или стерео, но с только одним
каналом). Таким образом, для нашего примера будем загружать монозву-
. ковой файл с CD диска DirectX SDK. Добавьте ссылку на объект Buffer3D,
который будет использоваться при управлении трехмерным буфером:

private Buffer3D buffer = null;

Также необходимо переписать метод инициализации InitializeSound,
чтобы использовать ЗD-обработку вместо панорамирования, которое мы
использовали прежде:
public void InitializeSound!)
(
device = new Device();
device.SetCooperativeLevel(this, CooperativeLevel.Normal);
BufferDescription desc = new BufferDescription();

284 Часть IV. Звук и устройства ввода

desc.Control3D = true;
desc.GlobalFocus = true;
sound = new SecondaryBuffer(@".A..\drumpad-bass_drum.wav", desc, device);
buffer = new Buffer3D(sound);
sound.Play(0, BufferPlayFlags.Looping);
buffer.Position = new Vector3(-0.1f, O.Of, O.Of);
timerl.Enabled = true;

}
Мы заменили панорамирование трехмерной обработкой, плюс, заме­
нили звуковой файл. Затем создали объект Buffer3D, установив его на
непрерывное проигрывание (значение loop). Далее устанавливается про­
игрывание по левому каналу (напомним, что по умолчанию это значение

О,
0, 0).
Теперь необходимо переписать код таймера и определить круговое

звучание:

private void timerl_Tick(object sender, System.EventArgs e)
{
// Adjust the position
buffer.Position *= mover;
if ((Math.Abs(buffer.Position.X) > MoverMax) && (mover == MoverUp))
{
mover = MoverDown;
}

if ((Math.Abs(buffer.Position.X) < MoverMin) && (mover == MoverDown))

{
mover = MoverUp;

}

)

Как мы видим, в этом коде появились несколько новых переменных и
констант, определяющих круговое звучание.
Для правильной компиляции их необходимо добавить к нашему
классу:
private const float MoverMax = 35.Of;
private const float MoverMin = 0.5f;
private const float MoverUp = -1.05f;
private const float MoverDown = -0.95f;
private float mover = MoverUp;
Запуская приложение, обратите внимание на то, как звук перемещает­
ся от динамика к динамику, а также медленно удаляется, пропадает и
возвращается вновь. Приложение будет выполняться, пока вы не выйде­
те из него.

Глава 14. Добавление звука 285

Управление слушателем

Объект Listener3D создается и используется так же, как объект
Buffer3D. Однако, вместо управления фактическим звуковым источни­
ком (которых может быть несколько), мы имеем дело непосредственно
со слушателем, который может быть в устройстве только одним. По этой
причине, при создании объекта listener мы не можем использовать
SecondaryBuffer, а только первичный объект Buffer.
Прежде чем написать код, используя объект listener, необходимо учесть
свойства и параметры настройки, которые мы можем изменять (анало­
гично тому, что мы делали с объектом 3D Buffer). Параметры и свойства
приведены в таблице 14.3.
Таблица 14.3. Параметры и свойства объекта Listener3D

Название
Описание

CommitDeferredSettings

DistanceFactor

DopplerFactor

При установленной задержке параметров настройки в 3D буферах или листенере этот метод перешлет все новые значения в то же самое время. Метод не выполняется при отсутствии задержки установленных изменений
Атрибут чтение-запись. Устанавливает число метров в векторном модуле
Атрибут чтение-запись. Определяет коэффициент для эффекта Доплера. Любой буфер, который работает со скоростью перемещения источника звука, учитывает изменения тона, связанные с эффектом Доплера
Deferred Определяет то, изменяются ли регулируемые параметры сразу либо насколько они задерживаются, пока пользователь изменяет установки. По умолчанию данное значение «false», то есть свойства изменяются сразу

Orientation
Атрибут чтение-запись. Определяет местоположе­ние слушателя. Приложение DirectSound автомати­чески нормализует соответствующий вектор
RolloffFactor

Position

Атрибут чтение-запись. Определяет параметр rolloff factor — скорость затухания по мере увеличения
расстояния

Атрибут чтение-запись. Определяет текущее местоположение слушателя в мировых координатах
Velocity Атрибут чтение-запись. Определяет скорость перемещения слушателя (по умолчанию значение в метрах на секунду)

286 Часть IV. Звук и устройства ввода
Теперь мы должны взять имеющийся пример, в котором перемещает­
ся звуковой буфер, и переписать код, вставив в него перемещение слуша­
теля. Можно убрать ссылку на объект 3D buffer, который мы использова­
ли, и заменить соответствующую переменную нижеприведенными:

private Listener3D listener = null;
private Microsoft.DirectX.DirectSound.Buffer primary = null;

Мы должны использовать первичный буфер для создания объекта
listener. Также необходимо учесть, что поскольку имя класса Buffer нахо­
дится в пространстве имен системы, мы должны полностью определить
переменную buffer.
Для этого нужно переписать метод инициализации InitializeSound.
Замените код создания звукового буфера на следующий:

BufferDescription primaryBufferDesc = new BufferDescriptionO;
primaryBufferDesc.Control3D = true;
primaryBufferDesc.PrimaryBuffer = true;
primary = new Microsoft.DirectX.DirectSound.Buffer(primaryBufferDesc,

device);

listener = new Listener3D(primary);
listener.Position = new Vector3(0.1f, O.Of, O.Of);

Здесь мы создаем первичный буфер, объявляем объект listener и затем
устанавливаем его местоположение (несколько «левее» от заданного по
умолчанию). Теперь мы должны переписать код таймера, чтобы переме­
щать слушателя:

private void timerl_Tick(object sender, System.EventArgs e)

{

// Adjust the position
listener.Position *= mover;
if ((Math.Abs(listener.Position.X) > MoverMax) && (mover == MoverUp))
mover = MoverDown;
if ((Math.Abs(listener.Position.X) < MoverMin) && (mover == MoverDown))
mover = MoverUp;

}
Легко заметить, что мы не сделали ничего, кроме замены буфера на
слушателя. Этот пример должен проигрываться аналогично предыду­

щему.

Глава 14. Добавление звука 287

ФЛАЖОК CONTROL3D

Важно обратить внимание, что для создания объекта listener исполь­

зуется флажок Control3D, в противном случае звук будет проигры­

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

Использование звуковых эффектов

Кроме обычных ЗD-манипуляций со звуком, мы в нашем приложении
можем использовать различные эффекты. Например, звук шагов по дере­
вянным полам в маленькой комнате отличался бы от звука шагов, разда­
ющихся в большом концертном зале. Крики в пещере вызвали бы много­
кратное эхо, отражаемое от стен пещеры. Эти эффекты — неотъемлемая
часть того реального погружения, которое вы будете пробовать создавать
при разработке игры.

БУФЕРЫ, ПОДДЕРЖИВАЮЩИЕ ЗВУКОВЫЕ ЭФФЕКТЫ

Звуковые эффекты и методы их программирования могут быть реа­

лизованы только с использованием вторичного буфера Secondary-

Buffer и соответствующих ссылок на этот объект.

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

фекты.

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

разом:

public void InitializeSound()

{

device = new Device));
device.SetCooperativeLevel(this, CooperativeLevel.Normal);
BufferDescription desc = new BufferDescription() ;
desc.ControlEffects = true;
desc.GlobalFocus = true;
sound = new SecondaryBuffer(@"..\..\drumpad-crash.wav",desc, device);
EffectDescription[] effects = new EffectDescription[l];
effects[0].GuidEffectClass = DSoundHelper.StandardEchoGuid;

sound.SetEffects(effects);

sound.Play(0, BufferPlayFlags.Looping) ;

}

288
Часть IV. Звук и устройства ввода

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

УСТАНОВКА ЭФФЕКТОВ

Эффекты могут быть установлены только на остановленном буфе­

ре. Если буфер проигрывается, вызов SetEffects игнорируется. Вы

можете просмотреть свойство состояния буфера (Status property,

статус буфера), чтобы определить, проигрывается буфер или нет.

Также вы можете вызывать оператор Stop перед обращением к эф­

фектам.

Определив и установив эффекты, мы можем запустить приложение.
При проигрывании мы должны услышать эффект эха, которого не было
до сих пор. Возможно и добавление «пачки» наложенных друг на друга
эффектов (stacks). Чтобы использовать эффект эха вместе с эффектом
гребня, сопровождаемым эффектом искажения, мы можем переписать
метод следующим образом:

EffectDescription[] effects = new EffectDescription[3] ;
effects[0].GuidEffectClass = DSoundHelper.StandardEchoGuid;
effects[l].GuidEffectClass = DSoundHelper.StandardFlangerGuid;
effects[2].GuidEffectClass = DSoundHelper.StandardDistortionGuid;
sound.SetEffects(effects);

Мы получили некоторую смесь звуков барабана кимвал и работающе­
го двигателя самолета (этот звук очень понравился автору книги — прим.
ред.). Как уже упоминалось, существует несколько встроенных типов
эффектов, см. таблицу 14.4.

Таблица 14.4. Типы встроенных звуковых эффектов

Название

Chorus

Compression

Описание

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

Эффект сжатия — по существу уменьшает сигнал
до некоторой амплитуды.

1

Глава 14. Добавление звука 289

Название

Distortion

Echo

Environment Reverberation

Flange

Gargle

Parametric
Equalizer

Waves Reverberation

Описание

Эффект искажения. Осуществляется добавлением гармоник к сигналу, при увеличении уровня изменяется форма волны
Эффект эхо, повторяет многократно первоначальный звук с заданной задержкой и спадом амплитуды последующего сигнала
. Эффект отражения или раскаты. Осуществляется спецификацией 3D Audio Level 2 (I3DL2)
Эффект гребня, напоминает эффект хора, плюс эффект эхо только с маленькой задержкой и сменой тона через какое то время
Просто модулирует амплитуду сигнала
Этот эффект действует как эквалайзер, позволяя усиливать или подавлять сигналы определенной
частоты

Этот эффект предназначен для использования вместе с музыкой, напоминает эффект раскатов

Теперь мы можем выбрать и применить любой из эффектов, выпол­
нив предварительно соответствующие настройки. Вы можете делать это
для вторичного буфера с помощью метода GetEffects. Чтобы лучше слы­
шать изменения при установке, необходимо отключить остальные эф­
фекты, за исключением эха. Добавьте следующую секцию кода сразу после
вызова SetEffects:

EchoEffect echo = (EchoEffect)sound.GetEffects(0);
EffectsEcho param = echo.AllParameters;
param.Feedback = 1 .Of;
param.LeftDelay = 1060.2f;
param.RightDelay = 1595.3f;
param.PanDelay = 1;
echo.AllParameters = param;

Здесь мы используем метод GetEffects для создания объекта
EchoEffect, определяющего все изменяемые параметры используемого
эффекта эха. Теперь проиграв звук с изменениями, выполненными в дан­
ном методе, и без них, мы должны сразу почувствовать разницу. Таким
образом, мы можем управлять любым загружаемым эффектом.

10 Зак.
604

290 Часть IV. Звук и устройства ввода

ИЗМЕНЕНИЕ СВОЙСТВ ЭФФЕКТА

Даже при том, что вызов SetEffects может осуществляться только

когда буфер остановлен, вы можете изменять параметры загружен­

ных эффектов в реальном времени, даже при проигрывающем бу­

фере.

Краткие выводы

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

Глава 15. Управление устройствами ввода 291

Глава 15. Управление устройствами

ввода

К настоящему моменту мы охватили концепции построения 3D-rpa-
фики и рассмотрели вопросы использования звука.
Тем не менее, до сих пор не обсуждались темы, связанные с пользова­
тельским интерфейсом. В главе 6, при написании простой игры, управ­
ляющей движением автомобиля, мы использовали только клавиатуру, не
затрагивая мышь или джойстик. Также мы не рассматривали возможнос­
ти обратной связи при управлении приложением.
В этой главе мы коснемся интерфейса Directlnput API и узнаем, как с
ним работать, чтобы считывать и управлять данными, приходящими с
устройств ввода. Разделы этой главы включают.
Управление с клавиатуры.
Управление с помощью мыши.
Управление с помощью джойстика и игровой клавиатуры.
• Работа с обратной связью.

Обнаружение устройств

В первую очередь, чтобы использовать код, который будем обсуждать
далее в этой главе, мы должны обеспечить необходимые ссылки на
Directlnput. Нам также необходимо добавить ссылку на Micro-
soft.DirectX.Directlnput и директиву using для этого пространства имен.
Даже если ваш компьютер является автономной системой, в нем име­
ется по крайней мере два устройства ввода данных: клавиатура и мышь.
Дополняя машину различными USB-устройствами, ставшими доста­
точно распространенными в настоящее время, мы можем иметь несколь­
ко устройств ввода данных, которые мы должны уметь обнаруживать и
.распознавать. Если вспомнить, в начале книги мы говорили о классе
Manager, который входит в Direct3D. Приложение Directlnput имеет по­
добный класс, который мы будем использовать для этих задач.
Самая простая вещь, которую мы можем сделать, состоит в том, что­
бы обнаружить все имеющиеся в системе устройства. Для этого мы мо­
жем использовать свойство devices property в соответствующем классе
manager. Вначале необходимо создать и заполнить соответствующим об­
разом разветвленную схему для нашей формы.
Для этой схемы в приложении необходимо добавить некоторые кон­
станты ключевых имен:

private const string AllItemsNode = "All Items";
private const string KeyboardsNode = "All Keyboard Items";
private const string MiceNode = "All Mice Items";

292 Часть IV. Звук и устройства ввода
private const string GamePadNode = "All Joysticks and Gamepad Items";
private const string FeedbackNode = "All ForceFeedback Items";

Опираясь на эти константы, необходимо создать пять различных уз­
лов или папок в дереве разветвленной схемы: одна папка для всех уст­
ройств вашей системы, затем по одной секции для мыши, клавиатур,
джойстиков и элементов обратной связи. Элементы, находящиеся в пап­
ке «All Items», должны быть продублированы в остальных папках.
Вначале необходимо заполнить папку «All Items». Для этого мы со­
здадим функцию LoadDevices, целью которой является заполнение раз­
ветвленной схемы элементами, находящимися в системе. Добавьте ме­
тод, приведенный в листинге 15.1.

Листинг 15.1. Добавление устройств к разветвленной схеме.
public void LoadDevices()

{

TreeNode allNodes = new TreeNode(AllItemsNode);
// First get all devices
foreach(DeviceInstance di in Manager.Devices)

{

TreeNode newNode = new TreeNode (string. Format)" (01 - (1} ({2})\
di.InstanceName, Manager.GetDeviceAttached(di.InstanceGuid)
? "Attached" : "Detached", di.InstanceGuid));

allNodes.Nodes.Add(newNode);

}

treeViewl.Nodes.Add(allNodes);

}

Как вы можете видеть, класс DeviceList (производный от класса
Devices) возвращает список структур Devicelnstance. Эта структура со­
держит всю полезную информацию относительно устройств, включая
идентификатор GUID (использующийся при создании устройства), на­
звание продукта и тип устройства.
Для проверки наличия устройства вы можете использовать и другие
методы класса Manager. Вполне возможно иметь в системе и виртуаль­
ное устройство «available», которое, в принципе, поддерживается, но на
данный момент отсутствует в системе.
И, наконец, мы добавляем каждое найденное в системе устройство в
соответствующую папку и добавляем папку в разветвленную схему.
Теперь предположим, что мы хотели найти лишь некоторые типы ус­

тройств, например, только клавиатуру? Добавьте код листинга 15.2 в конце

метода LoadDevices.

Глава 15. Управление устройствами ввода
293
Листинг 15.2. Добавление клавиатуры к разветвленной схеме.
// Now get all keyboards
TreeNode kbdNodes = new TreeNode(KeyboardsNode);
foreach(Device!nstance di in Manager.GetDevices(DeviceClass.Keyboard,
EnumDevicesFlags.AttachedOnly))

{

TreeNode newNode = new TreeNode(string.Format)"{0} - {1} ({2})",
di.InstanceName, Manager.GetDeviceAttached(di.InstanceGuid)
? "Attached" : "Detached", di.InstanceGuid));

kbdNodes.Nodes.Add(newNode);

}

treeViewl.Nodes.Add(kbdNodes);

Здесь используется новый метод GetDevices класса Manager (вместо
знакомого нам Devices), который позволяет определять типы перечис­
ленных устройств. В данном примере мы пытаемся обнаружить объекты
keyboards, более того, мы хотим найти только те устройства, которые не­
посредственно подсоединены к системе. Для определения устройств дру­
гих типов код остается таким же, только указываются соответствующие
значение используемого класса:

// Now get all mice
TreeNode miceNodes = new TreeNode(MiceNode);
foreach(DeviceInstance di in Manager.GetDevices(DeviceClass.Pointer,
EnumDevicesFlags.AttachedOnly))

{

TreeNode newNode = new TreeNode(string.Format("{0} - {1} ({2})",
di.InstanceName, Manager.GetDeviceAttached(di.InstanceGuid)
? "Attached" : "Detached", di.InstanceGuid)),•

miceNodes.Nodes.Add(newNode);

}

treeViewl.Nodes.Add(miceNodes);

// Now get all joysticks and gamepads
TreeNode gpdNodes = new TreeNode(GamePadNode);
foreach(DeviceInstance di in Manager.GetDevices(DeviceClass.GameControl,
EnumDevicesFlags.AUDevices))

{

TreeNode newNode = new TreeNode(string.Format("(0} - (1} ((21)",
di.InstanceName, Manager.GetDeviceAttached(di.InstanceGuid)
? "Attached" : "Detached", di.InstanceGuid));

gpdNodes.Nodes.Add(newNode);

}

treeViewl.Nodes.Add(gpdNodes);

294 Часть IV. Звук и устройства ввода
Обратите внимание, что указатель устройства мыши в классе имеет
тип Pointer. Данный класс не подразумевает использование только для
устройства мыши, это более общий тип. Экранные указатели Screen
pointers, например, относятся к этой же категории.
Теперь мы попробуем определить или найти в системе устройства с
обратной связью. Оно не относится к какому-либо определенному типу
устройств, это скорее характеристика или особенность, которую мы хо­
тим поддерживать.
Эта проверка также весьма проста:
// Now get all Force Feedback items
TreeNode ffNodes = new TreeNode(FeedbackNode);
foreach(DeviceInstance di in Manager.GetDe?ices(DeviceClass.All,

EnumDevicesFlags.ForceFeeback))

{

TreeNode newNode = new TreeNode(string.Format("{0} - {1} ({2})",

di.InstanceName, Manager.GetDeviceAttached(di.InstanceGuid)

? "Attached" : "Detached", di.InstanceGuid)) ;

ffNodes.Nodes.Add(newNode);

}
treeViewl.Nodes.Add(ffNodes);

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

ИСПОЛЬЗОВАНИЕ ПАНЕЛИ УПРАВЛЕНИЯ

В классе Manager имеется метод RunControlPanel, который откры­

вает панель управления. Панель управления позволяет установить

доступ к настройкам имеющихся в системе устройств.

Использование клавиатуры

Каждое из устройств, использующихся в Directlnput, имеет свой соб­
ственный объект Device, подобно тому, как графическая или звуковая
карта имеют свои объекты устройств. Количество устройств ввода в
Directlnput может быть значительно больше, чем в графических или зву­
ковых картах.
Создание устройства требует наличия идентификатора GUID. Это
может быть просто компонент объекта SystemGuid, если мы хотим со­
здать клавиатуру или устройство мыши по умолчанию. Устройства, ко­
торые создаются при этом, достаточно универсальны и позволяют извле­
кать данные из любого устройства, поддерживаемого приложением

Directlnput.

Глава 15. Управление устройствами ввода 295
Первое устройство, с которого мы начнем, — клавиатура. Во-первых,
нам понадобится переменная устройства:

private Device device = null;

Теперь у нас есть два пути, которые мы можем использовать в
Directlnput. Мы можем применить обычный цикл и получить текущее

состояние устройства для каждого фрейма, а можем установить Directlnput

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

инициализации:

private bool running = true;
public void Initializelnput()

{

// Create our keyboard device
device = new Device(SystemGuid.Keyboard);
device.SetCooperativeLevel(this, CooperativeLevelFlags.Background \
CooperativeLevelFlags.NonExclusive);

device.Acquire();

while(running)

{

UpdatelnputState();

Application.DoEvents();

}
}

Как вы видите, это — полный цикл ввода, вначале которого, исполь­
зуя стандартный модификатор GUID, создается устройство клавиатуры.
Можно вспомнить, что в разделе DirectSound мы устанавливали уровень
. совместного доступа для различных устройств системы. В нашем случае

также могут использоваться различные флажки и их сочетания при объяв­

лении уровней совместного доступа, см. таблицу 15.1.

Таблица 15.1. Уровни совместного доступа в Directlnput

Флажок Описание

Background Фоновый доступ. Устройство может использоваться на заднем плане или может быть вызвано в любое время, даже если связанное окно не является активным
Foreground Активный доступ. Устройство может использоваться только при активном окне, в противном случае, не может быть
вызвано

296 Часть IV. Звук и устройства ввода
Флажок Описание
Exclusive Эксклюзивный режим. Устройство имеет статус
монопольного доступа из приложения. Кроме него, никакое другое приложение не может иметь такой же статус доступа, однако неэксклюзивные запросы возможны. Из соображений безопасности на некоторых устройствах исключено совместное использование флажков exclusive и background, например, у клавиатуры и мыши
NonExclusive Совместный режим. Устройство может быть распределено по многим приложениям и не требует монопольного доступа.

NoWindowsKey Отключает клавишу «windows key»

Для данного приложения мы можем использовать флажки foreground
и non-exclusive. После входа в цикл при выполнении приложения мы пе­
реписываем состояние ввода устройства InputState и вызываем обработ­
чик событий DoEvents. Прежде чем записать код метода UpdatelnputState,
необходимо создать текстовое поле с атрибутами мультистроки и «толь­
ко для чтения» и установить для него свойство Dock в значении «Fill».
Теперь мы можем добавить следующий метод для изменения текстового
окна textbox:

private void UpdatelnputState()

{

// Check the keys currently pressed first
string pressedKeys = "Using GetPressedKeys(): \r\n";
foreach(Key k in device.GetPressedKeysf))
pressedKeys += k.ToString() + " ";
textBoxl.Text = pressedKeys;

}
Перед запуском этого приложения осталось сделать две вещи. Следу­
ет обратить внимание на то, что цикл будет выполняться до тех пор, пока
переменная running не получит значение «false», поэтому, если мы хо­
тим, чтобы выполнение приложения закачивалось при закрытии формы,
необходимо присвоить переменной running значение «false»:

protected override void OnClosed(EventArgs e)

{

running = false;

}

Это может помочь, когда мы вызываем метод инициализации Initialize-

Input. Изменим основной метод следующим образом:

Глава 15. Управление устройствами ввода 297

static void Main()
(
using (Forml frm = new FormlO)
(

frm.Show();

frm.InitializelnputO ;

I

}

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

УДЕРЖИВАНИЕ НЕСКОЛЬКИХ КЛАВИШ

Большинство клавиатур могут поддерживать нажатие до пяти кла­

виш одновременно. Нажатие большего числа клавиш приведет к иг­

норированию операций.

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

событий.

Создайте новый метод инициализации ввода, листинг 15.3.

Листинг 15.3. Метод инициализация для Directlnput и Second Thread.
private System.Threading.AutoResetEvent deviceUpdated;
private System.Threading.ManualResetEvent appShutdown;
public void InitializelnputWithThreadO

{

// Create our keyboard device
device = new Device(SystemGuid.Keyboard);
device.SetCooperativeLevel(this, CooperativeLevelFlags.Background

CooperativeLevelFlags.NonExclusive);

deviceUpdated = new System.Threading.AutoResetEvent(false) ;
appShutdown = new System.Threading.ManualResetEvent(false);
device.SetEventNotification(deviceUpdated);
System.Threading.Thread threadLoop = new System.Threading.Thread)
new System.Threading.ThreadStart(this.ThreadFunction));

threadLoop.Start ();

device.Acquired ;

}

298 Часть IV. Звук и устройства ввода

Основная предпосылка этого метода такая же, как и в предыдущем, толь­

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

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

private void ThreadFunction()

{

System.Threading.WaitHandlef] handles =
{ deviceUpdated, appShutdown };
// Continue running this thread until the app has closed
while(true)

{

int index = System.Threading.WaitHandle.WaitAny(handles);
if (index == 0)

{

UpdatelnputState();

}

else if (index == 1)

{
return;
} }
}

Эта функция является паритетной, когда мы имеем дело с многопоточ­
ными приложениями. В случае если устройство Directlnput сообщает нам
о событии изменения состояния устройства, мы вызываем метод
UpdatelnputState; если регистрируется другое событие, возвращается фун­
кция, которая прерывает поток. Как и в методе с использованием циклов,
мы должны сделать еще две вещи, чтобы завершить написание приложе­
ния. Необходимо задать обработчик закрытия приложения при регистра­
ции события. Для этого замените перегрузку OnClosed на следующую:

protected override void OnClosed(EventArgs e)

{

if (appShutdown != null)

appShutdown.Set();

}
И мы должны модифицировать нашу основную процедуру, чтобы
вызвать новый метод инициализации:
static void Main()
{
using (Forml frm = new Form())

Глава 15. Управление устройствами ввода 299
frm.Show() ;
frm.InitializelnputWithThread();
Application.Run(frm);
}
}
В большинстве случаев нет необходимости получать список всех на­
жатых в данный момент клавиш; допустим, нам захотелось обнаружить
нажатие определенной клавиши. В этом сценарии мы получаем состоя­

ние клавиш и проверяем или сравниваем с тем состоянием, которое ищем.

Например, чтобы увидеть, была ли нажата клавиша выхода «ESC», мож­
но сделать следующее:

KeyboardState state = device.GetCurrent KeyboardState();
if (state[Key.Escape])

{
/* Escape was pressed */

}

ОТКРЫТИЕ ПАНЕЛИ УПРАВЛЕНИЯ, ЗАВИСЯЩЕЙ ОТ
КОНКРЕТНОГО УСТРОЙСТВА
В классе Device имеется метод RunControlPanel, позволяющий откры­

вать панель управления в зависимости от выбранного устройства. На­

пример, при создании клавиатуры этот метод откроет панель со свой­
ствами клавиатуры; для устройства мыши, откроет папку свойств
мыши. Возможно внесение изменений в некоторые опции.
Использование устройства мыши

Все устройства Directlnput используют один и тот же класс устройств
Devices, так что различия между использованием мыши и клавиатуры
весьма незначительные. Необходимо переписать метод создания устрой­
ства в коде Initializelnput(), чтобы использовать GUID идентификатор
мыши вместо клавиатуры:

device = new Device(SystemGuid.Mouse);

ЭКСКЛЮЗИВНОЕ ИСПОЛЬЗОВАНИЕ МЫШИ
При работе с мышью в эксклюзивном режиме в некоторых случаях
мы можем полностью скрыть курсор мыши. Иногда это востребова­
но, но как правило, это не желательный эффект. Например, если вы
пишете систему меню для вашей игры, которая работает в полно-

300
Часть IV. Звук и устройства ввода

экранном режиме, пользователь может использовать это меню толь­

ко при помощи мыши. Необходимо предусмотреть для этого слу­

чая отдельные курсоры.

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

private void UpdatelnputState!)

{

// Check the mouse state
MouseState state = device.CurrentMouseState;
string mouseState = "Using CurrentMouseState: \r\n";
// Current location of the mouse
mouseState += string. Format ("{0}х{1}х{2}\r\n", state.X,

state.Y, state.Z);

// Buttons
byte[] buttons = state.GetMouseButtons();
for(int i = 0; i < buttons.Length; i++)
mouseState += string.Format("Button {0} (l}\r\n",
i, buttons[i] != 0 ? "Pressed" : "Not Pressed");
textBoxl.Text = mouseState;

}
Здесь, вместо использования вспомогательной функции для получе­
ния текущих данных, мы берем мгновенное состояние (мгновенный от­
печаток) мыши. Затем выводится текущая позиция мыши по осям X, Y, и
Z (Ось Z обычно относится к колесу или скролу мыши), также как и со­
стояние кнопок.
Запуская приложение теперь, мы обратим внимание, что большую
часть времени, «позиция» мыши сообщается как 0x0x0, даже когда мы
вращаем мышь вокруг своей оси. Почему же не обновляется пользова­
тельский интерфейс? В действительности, данные мыши сообщаются в
относительных единицах оси (относительно последнего фрейма), а не в
абсолютных. Если мы хотим сообщить о данных мыши в абсолютных
значениях, необходимо сразу после создания устройства изменить стро­
ку «свойства» следующим образом:

device.Properties.AxisModeAbsolute = true;

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

Глава 15. Управление устройствами ввода
301

Использование игровых клавиатур

и джойстиков

В то время как основные принципы использования джойстика, мыши
и клавиатуры похожи (они совместно используют тот же самый класс
устройств Device), имеются некоторые особенности, касающиеся при­
менения джойстиков, поскольку они в меньшей степени стандартизиро­
ваны. Мы можем хотя бы в какой-то мере предполагать, что у мыши бу­
дут две кнопки, а клавиатура будет иметь по крайней мере 36 клавиш.
Формы, размеры и расположение кнопок и осей на джойстиках не пред­
сказуемы. Вы можете иметь один джойстик с двумя осями и двумя кноп­
ками, другой с 3 осями, 10 кнопками, третий подразумевает педаль и т. д.
Не существует также и значения по умолчанию SystemGuid для созда­
ния джойстика. Мы должны вначале перечислить джойстики. Перепи­
шите функцию создания устройства, используя листинг 15.4.

Листинг 15.4. Инициализация джойстиков.
public bool Initializelnput()

{

// Create our joystick device

foreach(DeviceInstance di in Manager.GetDevices(DeviceClass.GameControl,

EnumDevicesFlags.AttachedOnly))

{

// Pick the first attached joystick we see
device = new Device(di.InstanceGuid) ;
break;

}

if (device == null) // We couldn't find a joystick
return false;

device.SetDataFormat(DeviceDataFormat.Joystick) ;

device.SetCooperativeLevel(this, CooperativeLevelFlags.Background |
CooperativeLevelFlags.NonExclusive);
device.Properties.AxisModeAbsolute = true;

device.Acquired();

while(running)

{

UpdatelnputState();

Application.DoEvents ();

}

return true;

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

302
Часть IV. Звук и устройства ввода
клавиатуру. Поскольку мы не создавали устройство с идентификатором
GUID, необходимо сообщить Directlnput о типе устройства, используя
метод SetDataFormat. Также необходимо возвратить соответствующее
значение в случае, если указанное устройство отсутствует. Перепишем
основную функцию, чтобы обработать этот вариант:

static void Main()

{
using (Forml frm = new Form1())

{

frm.Show ();

if (!frm.Initializelnput())

MessageBox.Show("Couldn't find a joystick.");

}
}
Современные джойстики обычно имеют несколько осей управления,
и диапазон этих осей, как правило, неизвестен. Мы должны обработать
все эти оси в диапазоне 10,000 единиц. Вполне возможно, что устрой­
ство не поддерживает такое разрешение, но Directlnput будет эмулиро­
вать его. Нам необходимо найти оси на джойстике и переопределить ди­
апазон. Добавьте следующий код сразу после создания устройства:

// Enumerate any axes
foreach(DeviceObjectInstance doi in device.Objects)

{

if ((doi.Objectld & (int)DeviceObjectTypeFlags.Axis) != 0)

{

// We found an axis, set the range to a max of 10,000
device.Properties.SetRange(ParameterHow.Byld,
doi.Objectld, new InputRange(-5000, 5000));

}
}
Этим способом мы можем перечислить объекты любого устройства.
Выполнение данного метода на клавиатуре, например, возвратит объект
для каждой клавиши клавиатуры. В нашем случае определяем найден­
ные оси, затем изменяем свойства данного объекта (с учетом номера ID)
таким образом, чтобы гарантировать соответствие указанным диапазо­
нам. И последнее, что мы должны сделать, — переписать пользовательс­
кий интерфейс:

private void UpdatelnputState()

{

// Check the joystick state

Глава 15. Управление устройствами ввода 303

JoystickState state = device.CurrentJoystickState;
string joyState = "Using JoystickState: \r\n";
joyState += string.Format("{0}x{l}",
state.X, state.Y);
textBoxl.Text = joyState;

}
Мы могли бы, используя предшествующее перечисление, обнаружить
все элементы джойстика и соответственно изменить пользовательский
интерфейс, но это не даст нам ничего нового.
В данном примере, использующем метод UpdatelnputState, мы моди­
фицируем только X и Y оси, которые присутствуют в большинстве джой­

стиков.

УПРАВЛЕНИЕ ДИАПАЗОНОМ

Игровые клавиатуры (и цифровые джойстики) обычно перескаки­
вают от одного экстремального значения диапазона к другому. В
примере, рассмотренном ранее, когда игровая клавиатура находи­
лась «в покое», ее значение было бы равно «0». Если бы вы нажали
левую кнопку, ось X переместилась бы мгновенно в минимальное
значение диапазона, то же самое и с правой кнопкой — резкое пе­
ремещение в максимальное значение без каких-либо промежуточ­
ных значений.
Существует два типа джойстиков, цифровые и аналоговые. Цифро­
вой джойстик мы только что описали. В аналоговых джойстиках ди­
апазоны, как правило, встроены. Хороший пример этого — штурва­
лы управления полетом. В этих джойстиках имеется широкий диа­
пазон перемещений по осям, что позволяет достаточно четко от­
слеживать эти перемещения.
Устройства обратной связи

Использование обратной связи в вашем приложении позволяет ощу­
тить наибольшее погружение в игровой процесс. Например, врезаясь в
дерево на скорости 100 миль в час, при наличии джойстика с такой опци­
ей вы можете реально ощутить удар, передающийся в руку.
Первое, что хотелось бы сразу отметить при упоминании эффектов
обратной связи Force Feedback (дословно обратная связь по усилию), это
то, что мы должны иметь эксклюзивный доступ к устройству. К счастью,
для таких устройств используется установка по умолчанию режима экс­
клюзивного доступа и фонового режима.
Итак, создадим устройство для этого примера (аналогично процедуре
для джойстика). Перепишите метод Initializelnput, как в листинге 15.5.

304 Часть IV. Звук и устройства ввода
Листинг 15.5. Инициализация устройства с обратной связью.
private ArrayList effectList = new ArrayList();
public bool Initializelnput()
{ // Create our joystick device
foreach(DeviceInstance di in Manager.GetDevices(DeviceClass.GameControl,
EnumDevicesFlags.AttachedOnly | EnumDevicesFlags.ForceFeeback))
{
// Pick the first attached joystick we see
device = new Device(di.InstanceGuid);
break;

}

if (device == null) // We couldn't find a joystick
return false;
device.SetDataForaat(DeviceDataFormat.Joystick);
device.SetCooperativeLevel(this, CooperativeLevelFlags.Background |
CooperativeLevelFlags.Exclusive);
device.Properties.AxisModeAbsolute = true;

device.Acquire ();

// Enumerate any axes
foreach(DeviceObjectInstance doi in device.Objects)

{

if ((doi.ObjectId & (int)DeviceObjectTypeFlags.Axis) != 0)
{
// We found an axis, set the range to a max of 10,000
device.Properties.SetRange(ParameterHow.ById,
doi.Objectld, new InputRange(-5000, 5000));

}
}

II Load our feedback file
EffectList effects = null;
effects = device.GetEffects(@"..\..\idling.ffe",
FileEffectsFlags.ModifylfNeeded);
foreach(FileEffect fe in effects)

{

EffectObject myEffect = new EffectObject(fe.EffectGuid, fe.EffectStruct,

device);

myEffeet.Download();

effectList.Add(myEffect);

}
while(running)
{

UpdatelnputState();

Application.DoEvents ();

}
return true;
}

Глава 15. Управление устройствами ввода 305
Как вы видите, здесь имеется несколько изменений. Мы установили
эксклюзивный доступ и переопределили метод перебора returnforce для
устройства обратной связи. Кроме того, мы установили еще раз диапазо­
ны и определили эффекты обратной связи.
Следует отметить, что мы можем создавать эффект обратной связи из
файла. В этом случае каждый эффект может быть представлен в виде
массива отдельных эффектов обратной связи. Код, включенный в CD диск
(и в нашем тексте) будет использовать файл idling.ffe, поставляемый с
DirectX SDK. Также на CD диске вы можете найти копию исходника.
После того как мы загрузили список эффектов из файла, мы про­
сматриваем каждый отдельный эффект обратной связи и создаем объект
эффекта. Далее мы загружаем этот эффект в фактическое устройство
таким образом, чтобы устройство могло использовать его и проверять
его состояние, и наконец добавляем этот эффект к локальному списку

массива.

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

private void PlayEffects ()

{

// See if our effects are playing.
foreach(EffectObject myEffect in effectList)

{

if (ImyEffect.EffectStatus.Playing)

{

// If not, play them
myEffect.Start (1, EffectStartFlags.NoDownload);

}

}

}

Целесообразно также добавить вызов PlayEffects в наш метод Update-

InputState.

ИСПОЛЬЗОВАНИЕ РЕДАКТОРА УСИЛИЯ Force Editor

Утилита Force Editor, которая поставляется с DirectX SDK, может ис­

пользоваться для создания любого эффекта обратной связи по же­

ланию. Помимо этого возможно создавать и редактировать эти эф­

фекты вручную в нашем коде, затем сохранять их в файл и исполь­

зовать в дальнейшем.

306 Часть IV. Звук и устройства ввода

Краткие выводы

В этой главе мы рассмотрели.
Управление с клавиатуры.
Управление с помощью мыши.
Управление с помощью джойстика и игровой клавиатуры.
Устройства обратной связи Force Feedback.
В последующих главах мы рассмотрим возможности Direct3D для
двухмерной графики, а также добавление сетевых возможностей.

ЧАСТЬ V

2D ГРАФИКА

Глава 16. Приложение Direct3D для 2D-графики
Глава 17. Использование DirectDraw для рендеринга

2D-графики

308 Часть V. 2D графика

Глава 16. Приложение Direct3D для

20-графики

В этой главе мы рассмотрим вопросы программирования и рендерин­
га 20-графики с помощью Direct3D. Мы коснемся следующих тем.
• Создание полноэкранного устройства.
• Использование класса Sprite.
• Рендеринг спрайтов.

Создание полноэкранного устройства

отображения

Зачастую рендеринг громоздких трехмерных сцен «сложен» по опре-"
делению. Несмотря на то, что большинство современных компьютерных
игр используют богатую трехмерную графику, существует множество
игровых сюжетов, где нет необходимости использовать «причуды» 3D-
графики. Поэтому имеет смысл создание таких игр в 2D-исполнении.
Учитывая то, что Direct3D может отображать достаточно сложные
трехмерные сцены, надо полагать, что рендеринг 2D-объектов не будет
для нас чем-то чрезмерно громоздким.
Создание полноэкранного устройства не слишком отличается от со­
здания устройств, работающих в оконном режиме, за исключением неко­
торых особенностей.

Создайте форму, которая будет использоваться нами в дальнейшем при

визуализации 20-графики. Как обычно, перед созданием устройства не­
обходимо добавить директиву using, объявить переменную устройства и
установить стиль окон.
Как только проект создан, необходимо объявить две константы, опре­
деляющие полноэкранный размер (в нашем случае 800x600):

public const int ScreenWidth = 800;
public const int ScreenHeight = 600;

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

Листинг 16.1. Инициализация полноэкранного устройства
public void InitializeGraphics ()

{

Глава 16. Приложение Direct3D для 2D-графики 309

// Set our presentation parameters
PresentParameters presentParams = new PresentParameters() ;
presentParams.SwapEffeet = SwapEffeet.Discard;
' // Start up full screen
Format current = Manager.Adapters[0].CurrentDisplayMode.Format;
if (Manager.CheckDeviceType(0, DeviceType.Hardware, current, current,
false))

{

// Perfect, this is valid
presentParams.Windowed = false;
presentParams.BackBufferFormat = current;
presentParams.BackBufferCount = 1;
presentParams.BackBufferWidth = ScreenWidth;
presentParams.BackBufferHeight = ScreenHeight;

}

else

{
presentParams.Windowed = true;

}

// Create our device
device = new Device(0, DeviceType.Hardware, this,
CreateFlags.SoftwareVertexProcessing, presentParams);

}
Начало этого метода должно быть нам знакомо. Поскольку в данном
разделе мы рассматриваем 2D-объекты, нет никаких причин объявлять
буфер глубины в приведенном методе инициализации.
Можно предположить, что текущий формат режима дисплея для за­
данного по умолчанию адаптера является подходящим для создаваемого
полноэкранного устройства. Для того чтобы принять это предположе­
ние, целесообразно вызвать метод проверки CheckDeviceType. Если этот
тип устройства поддерживается, измените параметры описания, чтобы
' определить полноэкранное устройство.

Параметр Windowed устанавливается в значение «false», так как уст­

ройство будет работать в полноэкранном режиме. Для отображения в
полноэкранном режиме мы будем применять вторичный буфер, поэтому
ширина и высота вторичного буфера должны быть установлены в соот­
ветствии с заявленными константами размера экрана.
ОБРАБОТКА СОБЫТИЙ ОТКАЗОВ ПРИ СОЗДАНИИ
УСТРОЙСТВА

Предположим (хотя это маловероятно), что при создании устрой­

ства произойдет отказ и, несмотря на то, что формат устройства

перед созданием был проверен, вторичный буфер не будет создан.

310 Часть V. 2D графика

Формат 800x600, выбранный для нашего примера, является доста­
точно распространенным, и есть все основания полагать, что дан­
ный формат будет поддерживаться. Вопросы определения подхо­
дящего режима дисплея рассматривались в главе 2.
ИСПОЛЬЗОВАНИЕ ПОЛНОЭКРАННОГО УСТРОЙСТВА
Полноэкранный режим не является особенностью отображения 2D-
графики. Используя подход, рассмотренный в листинге 16.1, мож­
но создать практически любое, в том числе и трехмерное, полноэк­
ранное устройство. В предыдущих главах, рассматривая объекты
ЗD-графики, мы опирались в основном на оконный режим по при­
чине большой трудоемкости в отладке кода для полноэкранного
режима.

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

Итак, мы создаем полноэкранное устройство. Вполне естественно, что

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

protected override void OnKeyUp(KeyEventArgs e)

{

if (e.KeyCode == Keys.Escape) // Quit

this. Closed;

base.OnKeyUp (e);

}

Рендеринг спрайтов

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

private Texture spriteTexture;
private Sprite sprite;
private Rectangle textureSize;

Глава 16. Приложение Direct3D для 2D-графики 311
Эти переменные позволяют сохранить спрайт и текстуру, которая бу­
дет использоваться для рендеринга спрайта. Для правильного выполне­
ния данной процедуры необходимо знать размер сохраняемой текстуры
(переменная textureSize).
Таким образом, необходимо инициализировать эти переменные, до­
бавив следующий код в конце метода InitializeGraphics, сразу после со­
здания устройства:

// Create our texture
spriteTexture = TextureLoader.FromFile(device, @"..\..\logo.tga") ;
using (Surface s = spriteTexture.GetSurfaceLevel(0))

{

SurfaceDescription desc = s.Description;
textureSize = new Rectangle(0, 0, desc.Width, desc.Height);

}

sprite = new Sprite(device);

Файл logo.tga находится на CD диске. После создания текстуры необ­
ходимо определить ее размер.
Мы находим поверхность, на которую будет отображаться текстура,
и, используя ее описание, устанавливаем размер текстуры. Затем мы со­
здаем пример класса Sprite.
Класс Sprite позволяет, используя различные текстуры, рисовать лю­
бое количество спрайтов. Для этого, вместо того чтобы копировать наш
класс Sprite, мы создадим новый класс, позволяющий обработать множе­
ственные спрайты. Добавьте класс, приведенный в листинге 16.2.

Листинг 16.2. Добавление класса Sprite

public class GraphicsSprite

{

. // static data for our sprites
private static readonly Vector3 Center = new Vector3(0, 0, 0);
private static readonly Random rnd = new Random();
// Instance data for our sprites
private Vector3 position;
private float xUpdate = 1.4f;
private float yUpdate = 1.4f;
public GraphicsSprite(int posx, int posy)

{

position = new Vector3(posx,posy,1);
xUpdate += (float)rnd.NextDoublef);
yUpdate += (float)rnd.NextDoublef);

}

312 Часть V. 2D графика
public void Draw(Sprite sprite, Texture t, Rectangle r)
(
sprite.Draw(t, r, Center, position, Color.White);

}

}
При желании мы можем вращать спрайты (даже если приложение не
предусматривает эту операцию).
Когда мы рисуем спрайт (sprite.Draw), одним из параметров этой фун­

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

ще сохранить это значение здесь, вместо того чтобы каждый раз при вы­
зове функции создавать новый вектор.
В данной процедуре мы также добавляем движению спрайтов элемент
случайности (параметр Random).
Для каждого спрайта устанавливаются параметры, отвечающие за те­
кущую позицию спрайта и его скорость перемещения.
Различные значения скорости по координатам X и Y позволяют спрайту
перемещаться не только под углом в 45°. Объект имеет заданные началь­
ные значения скорости по осям X и Y, которые затем изменяются случай­
ным образом.
Параметр цвета в данном методе используется для придания оттенка
отображаемой текстуре.
Белый цвет (как в данном примере) позволит отобразить текстуру с
естественным оттенком, а использование красного добавит текстуре крас­
ный оттенок.
Используя общий класс Sprite, можно переписать код и включить про­
рисовку спрайтов.
Перед этим необходимо добавить новую переменную для записи ото­
бражаемых спрайтов:

System.Collections.ArrayList ar = new System.Collections.ArrayList();

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

// Add a few sprites
ar.Add(new
GraphicsSprite(0, 0));

ar.Add(new GraphicsSprite(64,128)) ;
ar.Addfnew GraphicsSprite(128,64)) ;
ar.Addfnew GraphicsSprite(128,128)) ;
ar.Addfnew GraphicsSprite(192,128)) ;
ar.Addfnew GraphicsSprite(128,192));
ar.Addfnew GraphicsSprite(256,256));

Глава 16. Приложение Direct3D для 2D-графики
313
По желанию можно изменять количество и местоположение добавля­
емых спрайтов.
Имея коллекцию спрайтов, мы можем попробовать отобразить их на

экране.

Для этого в процедуре OnPaint добавьте после вызова BeginScene сле­
дующий код рендеринга спрайтов:

// Begin drawing our sprites with alpha blend
sprite.Begin(SpriteFlags.None);
// Draw each sprite in our list.
foreach(GraphicsSprite gs in ar)
gs.Draw(sprite, spriteTexture, textureSize);
// Notify Direct3D we are done drawing sprites

sprite.End() ;

Функция Begin начинает процедуру рендеринга, затем для каждого
спрайта вызывается метод Draw. Метод заканчивается обязательным опе­
ратором End.
Теперь мы можем запустить приложение.
Увы, мы видим, что наши спрайты не перемещаются, несмотря на то,
что мы задали скорость перемещения.
Это очевидно, поскольку в нашей программе не задан метод обновле­
ния спрайтов.
Нечто подобное мы уже проходили в первых главах, когда пытались
задать вращение элементарному треугольнику.
Добавьте в класс GraphicsSprite метод Update, приведенный в листин­
ге 16.3.
Листинг 16.3. Обновление спрайтов.
public void Update(Rectangle textureSize)
{
// Update the current position
position.X += xUpdate;
position.Y += yUpdate;
// See if we've gone beyond the screen
if (position.X > (Forml.ScreenWidth - textureSize.Width))
{
xUpdate *= -1;
}

if (position.Y > (Forml.ScreenHeight - textureSize.Height))

{

yUpdate *= -1;

}

314 Часть V. 2D графика

// See if we're too high or too the left
if (position.X < 0)

{

xUpdate *= -1;
)
if (position.Y < 0)

{

yUpdate *= -1;

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

экрана.

Для вызова этого метода добавьте следующий код в начале процеду­
ры OnPaint:

// Before we render each sprite, make
// sure we update them
foreach(GraphicsSprite gs in ar)

gs.Update(textureSize);

Функция Update обращается к каждому из имеющихся спрайтов. Те­
перь, запустив приложение, мы увидим объекты, перемещающиеся на
экране в различных направлениях.
ИСПОЛНЕНИЕ СПРАЙТОВ С ПАРАМЕТРОМ ПРОЗРАЧНОСТИ
ЦВЕТА «АЛЬФА»

При использовании текстуры, хранящейся на CD диске, можно за­
метить белую прозрачную окантовку текстуры. Эта текстура содер­
жит параметр «альфа» — прозрачность объекта. Использование
данного параметра несложно: вместо

sprite.Begin(SpriteFlags.None);

напишите:

sprite.Begin(SpriteFlags.AlphaBlend);

На рис. 16.1 показан результат визуализации текстуры, использу­
ющей параметр прозрачности «альфа».

Глава 16. Приложение Dircct3D для 20-графики 315

Рис. 16.1. Перемещающиеся спрайты

Анимация спрайтов

В основном, при анимации 2D-cnpaйтов отображаются не просто ста­
тические картинки, а скорее, последовательности изображений. В прин­
ципе, основной механизм анимации спрайтов такой же, как и для стати­
ческих изображений. Потгому в качестве отправной точки мы возьмем
копию программы, написанной для перемещения статических объектов.
Главные различия между данным приложением и предыдущим зак­
лючаются во вспомогательном классе, используемом для рендеринга
спрайтов. Процедура инициализации осталась практически той же са­
мой, только в исходнике кода поменялось имя файла «sprites.tga», чтобы
подчеркнуть то, что он включает в себя множественные спрайты. Так как
вместо одного статичного мы будем отображать на экране большое коли­
чество небольших анимированных объектов, необходимо случайным
образом задать им первоначальное положение. Таким образом, перепи­
шем конструктор для класса Sprite следующим образом:
public GraphicsSprite()

(

position = new Vector3(rnd.Hext(Forml.ScreenWidth-SpriteSize),
rnd.Hext(Forml.ScreenHeight-SpriteSize), 1);
xUpdate += (float) rnd.UextDouble();
yUpdate += (float)rnd.UextDouble(),

column = rnd.Next(NumberSpritesCol);

316 Часть V. 2D графика
row = rnd.Next(NumberSpritesRow);
if ((column % 3) == 0)

xUpdate *=.-l;

if ((row % 2) == 0)
yUpdate *= -1;
}
Позиция спрайта на экране задается следующим образом. Определя­
ется разность между шириной и высотой экрана (ScreenWidth и
ScreenHeight) и размером спрайта по ширине и высоте соответственно, В
результате функции случайных чисел возвращаются целые числа, лежа­
щие в пределах от 0 до этих значений. Однако, мы до сих пор не задали
размер спрайта. Размер рамки используемого в нашем примере спрайта
составляет 50x45. Теперь мы можем установить эти константы:

private const int SpriteSizeWidth = 50;
private const int SpriteSizeHeight = 45;

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

private const int NumberSpritesRow = 6;
private const int NumberSpritesCol = 5;

Также необходимо объявить переменные, которые будут использовать­

ся для определения текущего фрейма:

private int column = 0;
private int row = 0;

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

// Add a few sprites
for (int
i =
0;
i <
100; i++)
ar.Add (new GraphicsSprite() ) ;

Число спрайтов можно при желании изменять.
Теперь, зная размеры спрайта, мы должны изменить метод обновле­
ния Update, см. листинг 16.4.

Глава 16. Приложение Direct3D для 2Б-графики
317
Листинг 16.4. Обновление анимированных спрайтов.
public void Updated()

{

// Update the current position
position.X += xUpdate;
position.Y += yUpdate;
// See if we've gone beyond the screen
if (position.X > (Forml.ScreenWidth - SpriteSizeWidth))

{

xUpdate *= -1;

}

if (position.Y > (Forml.ScreenHeight - SpriteSizeHeight)

{ yUpdate *= -1 :

// See if we're too high or too the left
if (position.X < 0)

{

xUpdate *= -1;

}

if (position.Y < 0)

{

yUpdate *= -1;

)

II Now update the column

column++;

if (column >= NumberSpritesCol)

{

row++;

column = 0;

}

if (row >= NumberSpritesRow)

{

row
= 0;
}

}

Начало этого метода такое же, как и в предыдущем варианте, только
теперь мы используем размер спрайта вместо входящего параметра раз­
мера текстуры.
Далее выполняется последовательный перебор спрайтов по столб­
цам и строкам и возврат в начало после прохождения всего набора спрай­
тов.
Теперь, когда мы изменили метод обновления, можно убрать пара­
метр из обращения к методу Update:

318 Часть V. 2D графика
foreach(GraphicsSprite gs in ar)

gs. Updated;

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

public void Draw(Sprite sprite, Texture t)

{
}

sprite.Draw(t, new Rectangle(column * SpriteSizeWidth, row *
SpriteSizeHeight,
SpriteSizeWidth, SpriteSizeHeight), Center, position, Color.White);

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

foreach(3raphicsSprite gs in ar)
gs.Draw(sprite, spriteTexture);

Запустив приложение, мы увидим на экране движущиеся анимиро-
ванные спрайты, как на рис. 16.2.

Рис. 16.2. Анимированные спрайты

Глава 16. Приложение DirectD для 2D-графики 319

Краткие выводы

В данной главе мы рассмотрели.
• Использование полноэкранного режима.
• Рендеринг спрайтов.
• Рендеринг анимированных спрайтов.
В следующей главе мы рассмотрим использование в этих же целях
DirectDraw вместо Direct3D.

320
Часть V. 2D графика

Глава 17. Использование DirectDraw

для рендеринга 2D-графики

Одним из недостатков использования Direct3D для 2D-приложений
являются аппаратные ограничения. Direct3D более сложен, чем
DirectDraw, и требует большего количества ресурсов. В связи с этим в
некоторых системах целесообразно использовать устройство DirectDraw.
Более того, это может касаться и современных графических плат. При
имеющихся аппаратных ограничениях DirectDraw может решить пробле­
му, связанную с ресурсами системы.
В этой главе мы рассмотрим использование DirectDraw для 2D-rpa-
фики, включая.
Использование полноэкранного режима.

• Рендеринг спрайтов.
• Рендеринг анимированных спрайтов.

Создание полноэкранного устройства

DirectDraw

Прежде, чем создать устройство DirectDraw, необходимо выполнить
следующие действия:
1. Создать новый проект.
2. Добавить ссылки на Microsoft.DirectX.dll и Microsoft.DirectDraw.dll.
3. Включить новую директиву using для Microsoft.DirectX.DirectDraw
в главном файле кода.
4. Установить стиль окна как Opaque (непрозрачный) и AllPaintingln-
WmPaint, подобно тому, как это делалось для ЗD-приложений.
5. Добавить индивидуальную переменную для DirectDraw устройства.
Практически все эти пункты мы выполняли в наших ЗD-приложени-
ях, различия могут быть только в добавляемых ссылках.
Следует отметить, что в DirectDraw для отображения 2D-объектов
вместо текстур используются поверхности (surfaces). По сути, поверх­
ность — это сохраненные данные полигонального изображения. При ото­
бражении отдельного спрайта в полноэкранном устройстве нам понадо­
бятся три поверхности, которые мы добавляем к приложению:

private Surface primary = null;
private Surface backBuffer = null;
private Surface sprite = null;

Очевидно, что поверхность sprite является объектом рендеринга со­
храненного изображения. Мы могли бы отображать нашу поверхность,

Глава 17. Использование DirectDraw для рендеринга 20-графики 321
привязываясь непосредственно к экрану, но это может привести к разры­
ву изображений при отображении нескольких сцен. По этой причине в
DirectDraw необходимо выполнять всю процедуру рендеринга во вторич­
ном буфере с последующим копированием в первичный (если вспомнить,
в Direct3D данные действия выполнялись бы автоматически).
Прежде чем начать, требуется написать процедуру обработки нажа­
тия клавиши выхода «Escape». Добавим обработчик этого события в наше
полноэкранное приложение:

protected override void OnKeyUp(KeyEventArgs e)

{

if (e.KeyCode == Keys.Escape) // Quit
this.Closed ;
base.OnKeyUp (e);

}

Теперь, как обычно записываем метод инициализации, см. лис­
тинг 17.1.

Листинг 17.1. Инициализация DirectDraw устройства.
public void InitializeGraphics()

{

SurfaceDescription description = new SurfaceDescription();
device = new Device() ;
// Set the cooperative level.
device.SetCooperativeLevel(this,
CooperativeLevelFlags.FullscreenExclusive);
// Set the display mode width and height, and 16 bit color depth.
device.SetDisplayMode(ScreenWidth, ScreenHeight, 16, 0, false);
// Make this a complex flippable primary surface with one backbuffer
description.SurfaceCaps.PrimarySurface =
description.SurfaceCaps.Flip =
description.SurfaceCaps.Complex = true;
description.BackBufferCount = 1;
// Create the primary surface
primary = new Surface(description, device);
SurfaceCaps caps = new SurfaceCaps!);
caps.BackBuffer = true;
// Get the backbuffer from the primary surface
backBuffer = primary.GetAttachedSurface(caps) ;
// Create the sprite bitmap surface,
sprite = new Surfaced". .\. .\logo.bmp",
new SurfaceDescriptionO, device);
// Set the colorkey to the bitmap surface.
11 Зак. 604

322 Часть V. 2D графика
// which is what the CoiorKey struct is initialized to.
ColorKey ck = new CoiorKey();
sprite. SetColorKey (ColorKeyFlags.SourceDraw, ck);

}

Как вы можете видеть, этот метод несколько более сложен, чем вариант
для Direct3D. После создания устройства DirectDraw мы вызываем проце­
дуру установки уровней доступа к различным ресурсам платы SetCoopera-
tiveLevel. Поскольку для DirectDraw мы используем полноэкранное при­
ложение, нет никакой необходимости в совместном использовании ресур­
сов (устанавливаем эксклюзивный доступ FullScreenExclusive).
Далее устанавливается режим отображения, первые два параметра —
ширина и высота экранного окна. Третий параметр определяет насыщен­
ность цвета, в нашем случае используется 16-разрядный формат. Исполь--
зование 32-разрядного параметра цвета позволяет формировать более
богатые цвета, но и требует при этом большего количества ресурсов. Чет­
вертый параметр — частота обновления монитора, для установки по умол­
чанию используется значение «О». Последний параметр применяется ред­
ко, он определяет использование стандартного режима VGA.
После создания устройства и определения режимов отображения фор­
мируются поверхности. Вначале создается первичная поверхность, точ­
нее, ее описание. В нашем случае описание первичной поверхности вклю­
чает в себя опции PrimarySurface, Flip и Complex. Поверхность со свой­
ством Complex может иметь другие присоединенные поверхности, и в
нашем случае прикрепленная поверхность будет являться содержимым
вторичного буфера.
Теперь, имея соответствующее описание, создается первичная повер­
хность. Вызывая метод GetAttachedSurface, мы можем определить или
задать поверхность вторичного буфера на базе первичной поверхности.
И последним действием в этой процедуре является создание поверх­
ности спрайта. Код, записанный на CD диске, использует для этой цели
файл dx5 logo.bmp. Поскольку поверхность создается из файла, нам не
понадобится дополнительная информация об этой поверхности (поле
описания поверхности останется пустым).

ПАРАМЕТР ПРОЗРАЧНОСТИ В DIRECTDRAW

DirectDraw не поддерживает параметр прозрачности цвета «альфа».

В варианте нашего приложения для Direct3D мы просто использо­

вали соответствующую технику для придания фону нашего спрайта

свойства прозрачности. В DirectDraw для этого используется так на­

зываемый ключевой цвет (color key), который делает один из цве­

тов прозрачным. Правда такая схема имеет и недостатки, одним из

Глава 17. Использование DirectDraw для рендеринга 20-графики 323

которых является невозможность использования этого цвета в изоб­
ражении спрайта.

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

public const int ScreenWidth = 800;
public const int ScreenHeight = 600;
private static readonly Rectangle SpriteSize =
new Rectangle(0,0,256,256);

Ширина и высота экрана встречались и раньше. Поскольку размер
изображения, загружаемого из файла и используемого в качестве спрай­
та, известен, проще его сохранить сейчас, чем определять в дальнейшем.
Размер изображения можно также определить, используя описание по­
верхности (параметры Width и Height).
Теперь мы должны добавить вызов процедуры инициализации из на­
шего основного метода:

static void Main()

{

using (Forml frm = new Forml())
(
// Show our form and initialize our graphics engine

frm.Show();

frm.InitiaiizeGraphics();

Application.Run(frm);

Для обработки данных спрайта в нашем приложении нам понадобит­
ся общий класс:

public class GraphicsSprite
(
// static data for our sprites
private static readonly Random rnd = new Random!);
// Instance data for our sprites
private int xPosition = 0;
private int yPosition = 0;
private float xUpdate = 1.4f;

324 Часть V. 2D графика
private float yUpdate = 1.4 f;
///
/// Constructor for our sprite
///

/// Initial x position
/// Initial у position
public GraphicsSprite(int posx, int posy)

{

xPosition = posx;
yPosition = posy;
xUpdate += (float)rnd.NextDouble ();
yUpdate += (float)rnd.NextDouble();

}
}
В этом случае класс сохраняет текущую позицию левого верхнего угла
спрайта. Обратите внимание на то, что вместо используемого в Direct3D
параметра Vector3 здесь сохраняются два отдельных целочисленных зна­
чения. Целочисленные значения здесь вполне корректны и предпочтитель­
ны, поскольку DirectDraw использует экранные координаты устройства.
Третий параметр (параметр глубины) опускается, поскольку в прило­
жении DirectDraw он не используется.
Указанный класс будет сохранять скорость для каждого направления
перемещаемых по экрану спрайтов, используя начальное значение и слу­
чайное приращение скорости спрайта.
Теперь мы должны переписать наш класс Sprite, добавив процедуры
обновления и рисования, см. листинг 17.2.
Листинг 17.2. Обновление и рисование спрайтов.
public void Draw(Surface backBuffer, Surface spriteSurface,
Rectangle spriteSize)
{
backBuffer.DrawFast(xPosition, yPosition, spriteSurface, spriteSize,
DrawFastFlags.DoNotWait | DrawFastFlags.SourceColorKey);
}
public void Update(Rectangle spriteSize)
{
// Update the current position
xPosition += (int)xUpdate;
yPosition += (int)yUpdate;
// See if we've gone beyond the screen
if (xPosition > (Forml.ScreenWidth - spriteSize.Width))
{
xUpdate *= -1;

Глава 17. Использование DirectDraw для рендеринга 2D-графики 325
if (yPosition > (Forml.ScreenHeight - spriteSize.Height))
{
yUpdate *= -1;
}

// See if we're too high or too the left
if (xPosition < 0) ^

{

xUpdate *= -1;

}
if (yPosition < 0)
{
yUpdate *= -1;
}
}
Вызов процедуры рисования вызывает поверхность из вторичного
буфера, куда будет отображаться спрайт, а также поверхность спрайта и
ее размер. Процедура DrawFast просто рисует спрайт в указанном поло­
жении, используя весь спрайт в качестве исходного материала. Исполь­
зуемые флажки сообщают DirectDraw, что он «не должен ожидать» окон­
чания процедуры рисования, и что для включения параметра прозрачно­
сти необходимо использовать цветовой ключ (который был установлен
при создании спрайта).

РАЗЛИЧИЯ МЕЖДУ ВЫЗОВАМИ DRAW И DRAWFAST

При использовании аппаратной акселерации (что имеет место в

большинстве современных графических плат) между методами Draw

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

реализации метод DrawFast приблизительно на 10 % быстрее, чем

метод Draw, правда, ценой надежности и устойчивости. Метод Draw

является более гибким и позволяет реализовать различные опера­

ции по отношению к отображаемым спрайтам. Для простых же опе­

раций рисования целесообразно использовать метод DrawFast.

Приведенный в листинге 17.2 метод Update для DirectDraw идентичен
аналогичному методу для Direct3D. Позиция и скорость перемещения
спрайта связаны между собой, а направление перемещения изменяется
на обратное в случае приближения спрайта к краю экрана. Теперь, пол­
ностью описав класс Sprite, мы должны обработать все имеющиеся в
нашем приложении спрайты. Будем использовать тот же самый метод,
который использовался для Direct3D. Добавьте следующую переменную:

326 Часть V. 2D графика
System.Collections.ArrayList ar = new System.Collections.ArrayList();

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

// Add a few sprites
ar.Add(new
GraphicsSprite(0,0) );

ar.Add(new
GraphicsSprite (64,128));

ar.Addfnew
GraphicsSprite(128, 64));

ar.Add(new GraphicsSprite(128,128)) ;
ar.Addfnew GraphicsSprite(192,128)) ;
ar.Add(new GraphicsSprite(128,192));
ar.Addfnew GraphicsSprite(256,256)) ;

Осталось лишь добавить процедуру визуализации. Механизм ренде­
ринга остался прежним, поэтому мы можем добавить следующую пере­
грузку в класс windows form:

protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)

{
Microsoft.DirectX.DirectXException.IgnoreExceptions();
foreach(GraphicsSprite gs in ar)

gs.Update(SpriteSize);

backBuffer.ColorFill(O);
foreach(GraphicsSprite gs in ar)
gs.Draw(backBuffer, sprite, SpriteSize);
primary.Flip(backBuffer, FlipFlags.DoNotWait);
this.Invalidated ;
}
Первое, что бросается в глаза в этом методе, — выключение парамет­
ра обработки исключительных ситуаций в Управляемом DirectX. Этот
момент мы обсудим позже, сейчас же следует отметить, что необходимо
пользоваться этим с достаточной осторожностью.
Теперь, когда мы, используя сохраненный размер, изменили каждый
спрайт, очищаем вторичный буфер (в нашем случае для этого служит за­
полнение буфера цветом). Для ЗО-приложения аналогичную функцию
выполнял метод Clear.
Затем каждый спрайт коллекции отображается во вторичный буфер,
после чего мы можем обновить экран. Для этого вызывается метод Flip,
копирующий данные из вторичного буфера в первичный.
При запуске приложения мы должны увидеть результат, схожий с вы­
полнением приложения Direct3D.

Глава 17. Использование DirectDraw для рендеринга 20-графики 327

ИСПОЛЬЗУЕМЫЕ ИСКЛЮЧЕНИЯ

В данном приложении могут произойти два вида исключительных
ситуаций. Первая (WasStillDrawingException) случится при попытке
копирования первичной поверхности или рисунка во вторичный бу­
фер в момент времени, когда система еще не завершила предыду­
щую операцию draw. В Direct3D этот сценарий будет попросту про­
игнорирован, если вы используете флажок SwapEffect.Discard.
Вторая возможная ситуация — InvalidRectangleException. В Direct3D,
если спрайты вышли за пределы экрана, это не так принципиально,
поскольку устройство работает в мировых координатах, которые
являются, по сути, бесконечными. В DirectDraw это является важ­
ным, так как мы не сможем выполнять процедуру рендеринга спрай­
та, вышедшего за пределы экрана.
Анимация спрайтов

Возьмем за исходный вариант код из предыдущей главы и перепишем

его. Класс Sprite подвергнется некоторым изменениям, но некоторые кон­

станты мы можем оставить прежними:

private const int NumberSpritesRow = 6;
private const int NumberSpritesCol = 5;
private const int SpriteSizeWidth = 50;
private const int SpriteSizeHeight = 45;

Исходный текст программы, включенной в CD диск, использует файл

sprites.bmp.

ИСПОЛЬЗОВАНИЕ НЕКВАДРАТНЫХ ПОВЕРХНОСТЕЙ

В Direct3D текстуры не должны быть обязательно прямоугольными,
но обязаны иметь в качестве длины стороны число, являющееся сте­
пенью двойки. Большинство современных плат способны поддер­
живать нестандартные текстуры, не удовлетворяющие данному ог­
раничению.
В предыдущей главе для анимации мы использовали спрайт, «рас­
ширенный» до прямоугольника с соответствующей длиной сторон,
для того чтобы такая текстура поддерживалась большинством плат.
DirectDraw не использует для создаваемых поверхностей подобные
правила, поэтому в нашем примере спрайт имеет размеры, соот­
ветствующие изображению.

328 Часть V. 2D графика
Мы должны сохранить также положение объекта анимации, которое
является комбинацией строки и столбца. Добавьте следующие перемен­
ные к классу Sprite:

private int column = 0;

private int row = 0;

Теперь мы попробуем переписать конструктор для размещения на эк­
ране случайного изображения спрайта беспорядочным образом:

public GraphicsSprite()

{

xPosition = rnd.Next(Forml.ScreenWidth-SpriteSizeWidth);
yPosition = rnd.Next(Forml.ScreenHeight-SpriteSizeHeight);
xUpdate += (float)rnd.NextDouble ();
yUpdate += (float)rnd.NextDouble();
column = rnd.Next(NumberSpritesCol);
row = rnd.Next(NumberSpritesRow);
if ((column \ 3) == 0)
xUpdate *= -1;
if ((row% 2) == 0)
yUpdate *= -1;

}
Так же понадобиться переписать метод Draw:

public void Draw(Surface backBuffer, Surface spriteSurface)

{

backBuffer.DrawFast(xPosition, yPosition, spriteSurface,
new Rectangle(column * SpriteSizeWidth, row * SpriteSizeHeight,
SpriteSizeWidth, SpriteSizeHeight), DrawFastFlags.DoNotWait |

DrawFastFlags.SourceColorKey);

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

листинг 17.3.

Листинг 17.3. Обновление анимированных спрайтов
public void Updated

{

// Update the current position
xPosition+= (int)xUpdate;
yPosition += (int)yUpdate;

Глава 17. Использование DirectDraw для рендеринга 20-графики
329
// See if we've gone beyond the screen
if (xPosition > (Forml.ScreenWidth - SpriteSizeWidth))

{

xUpdate *= -1;

}

if (yPosition > (Forml.ScreenHeight - SpriteSizeHeight))

{

yUpdate *= -1;

}

// See if we're too high or too the left
if (xPosition < 0)

{

xUpdate *= -1;

}

if (yPosition < 0)

{

yUpdate *= -1;

}

// Now update the column
column++;
if (column >= NumberSpritesCol)

{

row++;
column = 0;
}

if (row >= NumberSpritesRow)

{

row
= 0; }
После процедуры обновления основная программа должна выдать
несколько ошибок при трансляции. Чтобы избежать этого, перепишите
код создания спрайта:

// Add a few sprites
for(int i = 0; i < 100; i++)
ar. Add (new GraphicsSprite() ) ;

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

protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)

{

DirectXException.IgnoreExceptions ();

foreach(GraphicsSprite gs in ar)

330
Часть V. 2D графика

gs. Updated;

backBuffer.ColorFill(O);

foreach(GraphicsSprite gs in ar)
gs.Draw(backBuffer, sprite);
primary.Flip(backBuffer, FlipFlags.DoNotWait);

this. Invalidated;

}

' I 'ni^Fii • лйилпл!» жгт т mi тип г тттч"Ч «пптг¥т»ттт»¥ иачтут
Таким образом, мы видим, что различия между Direct3D и DirectDraw
не столь значительные, как можно было предположить вначале.

Краткие выводы

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

ЧАСТЬ VI

ДОБАВЛЕНИЕ СЕТЕВЫХ

ВОЗМОЖНОСТЕЙ

Глава 18. Организация сети с равноправными узлами
с помощью DirectPlay
Глава 19. Создание сессии Client/Server
Глава 20. Особенности более совершенного использования

сетей

Глава 21. Методы достижения максимального
быстродействия

332
Часть VI. Добавление сетевых возможностей

Глава 18. Организация сети

с равноправными узлами с помощью

DirectPlay

В этой главе мы рассмотрим работу DirectPlay для сетей с архитекту­
рой "peer-to-peen", включая.
Адреса DirectPlay.
• Равноправные объекты.
• Модель события DirectPlay.
Пересылка данных другим участникам сети.

Адреса DirectPlay

Весьма заманчивым может показаться участие в игре одновремен­
но нескольких игроков. На сегодняшний день имеется целый класс
весьма популярных игр, которые вообще не имеют варианта для од­
ного игрока.
Управляемый DirectX включает DirectPlay API, который может ис­
пользоваться для осуществления сетевых возможностей. Прежде чем
начать писать код, необходимо проверить добавление соответствую­
щих директив и ссылок для DirectPlay, в частности, ссылки на
Microsoft.DirectX.DirectPlay. Мы полагаем, что все это уже сделано, и
не будем останавливаться на этом еще раз.
Если у вас имеется компьютер, подсоединенный к локальной сети или
сети Internet, это означает, что он уже имеет свой адрес протокола TCP/
IP, который отличает его от других машин в сети.
Мы должны, используя DirectPlay, присвоить каждому компьютеру
свой адрес. Процедура создания индивидуального адреса в DirectPlay
выглядит достаточно просто:

Address address = new Address();
address. ServiceProvider = Address.ServiceProviderTcpIp;

Здесь мы указываем, что хотим использовать для DirectPlay протокол
TCP/IP, который является на сегодняшний день наиболее распространен­
ным. Ниже приводятся еще несколько протоколов и соединений, доступ­
ных для DirectPlay.

Протокол TCP/IP.

Протокол IPX.
• Технология BlueTooth.
• Соединения с использованием последовательных портов.
Соединения модемов напрямую.

Глава 18. Организация сети с равноправными узлами с помощью DirectPlay 333

В дальнейшем, при написании приложений DirectPlay мы будем иметь

дело только с TCP/IP протоколом. Но это вовсе не означает, что мы не

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

быть применим и к другим перечисленным выше протоколам и соедине­

ниям. -"^

ИСПОЛЬЗОВАНИЕ «URL» СТРОКИ В КАЧЕСТВЕ АДРЕСА

Адреса могут быть также определены в форме указателя URL, как и
все Web-адреса, например, http://www.mycompany.com. Первая
секция URL указывает на тип протокола (в данном случае протокол
http). Web-страницы, которые мы обычно видим, имеют формат язы­
ка HTML. Ниже приводится пример использования указателя URL
для задания адреса в DirectPlay:

x-directplay:/provider=%7BEBFE7BA0-628D-HD2-

AE0F-006097B014H%7D;hostname=

www.mygameserver.com;port=9798

Обратите внимание на тип этого URL— x-directplay.
Остальная часть адреса определяет идентификатор провайдера,
имя хоста и порт.

ИСПОЛЬЗОВАНИЕ TCP/IP АДРЕСА

Имеется четыре конструктора для адресного объекта, большинство
из которых имеет дело с TCP/IP протоколом. Используемый нами
ранее и не имеющий параметров конструктор не устанавливает про­
токолы автоматически. Другие три конструктора задействуют про­
токол TCP/IP автоматически, рассмотрим их подробнее:

public Address ( System.String hostname , System.Int32 port )
public Address ( System.Net.IPAddress address )
public Address ( System.Net.IPEndPoint address )

Каждый из этих конструкторов выполняет одну и ту же операцию,
только с различными наборами данных. Первый создает адрес
TCP/IP, устанавливает имя хоста и соответствующий порт. Имя
хоста может быть именем компьютера, адресом Internet (например,
www.mycompany.com) или IP-адресом (например, 192.168.2.1). Два
других варианта могут принимать существующие адреса TCP/IP и
конвертировать их в соответствующий адрес DirectPlay.
До сих пор мы не использовали такие термины, как «имя хоста» и
«порт». Попробуем с помощью адресного объекта написать проце-

334
Часть VI. Добавление сетевых возможностей

дуру добавления этих компонентов к нашему адресу. Каждый ком­
понент имеет название (значение в формате string) и ассоцииро­

ванные данные (либо строчные, либо в виде массива). Да и сам класс

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

Address address = new Address));
address.ServiceProvider = Address.ServiceProviderTcpIp;
address.AddComponent(Address.KeyHostname, "www.mygameserver.com");

address.AddComponent(Address.KeyPort, 9798);

В действительности, конструкторы класса Address, имеющие вход­
ные параметры, выполняют эти действия достаточно точно.
Помимо этого существует несколько заданных по умолчанию клю­
чевых имен, которые могут использоваться в различных случаях (на­
пример, KeyPhoneNumber для прямых соединений модем-модем),
кроме того, пользователь может создавать и свои имена.
Компонент «hostname» особенно важен, когда мы связываемся с
другим компьютером. При этом DirectPlay достаточно гибок, что­
бы распознать имя хоста на вашей машине, и в этом случае нет
необходимости использовать указанные ключи для локальных ад­

ресов.

Создание Р2Р-соединения

Теперь мы можем перейти к созданию сети. Следует отметить, что
DirectPlay поддерживает системы и с архитектурой «peer-to-peen> (рав­
ный с равным), и с архитектурой «клиент-сервер». В этой главе мы обсу­
дим соединения с архитектурой «peer-to-peer», которые в дальнейшем
будем называть пиринговыми или Р2Р-соединениями.
Архитектура Р2Р подразумевает, что каждый участник соединения
связан непосредственно с каждым другим участником соединения. Для
небольшого числа узлов этот метод работает достаточно надежно. Име­
ется множество популярных на сегодняшний день примеров примене­
ния Р2Р-сетей. Многие из систем совместного использования файлов
(Kazaa, Napster и т. д.) представляют собой именно Р2Р-сети.
Прежде чем начать работу в DirectPlay с Р2Р-соединением, необходи­
мо уточнить несколько вопросов: например, выбрать тип соединения и
определить, будет'ли наша машина поддерживать работу сети или при­
соединится к уже существующему сеансу.
Основным классом, который мы будем использовать для нашего со­
единения, будет класс Peer. Для начала объявим переменные соединения
и адреса для этого класса:

Глава 18. Организация сети с равноправными узлами с помощью DirectPlay 335
private Peer connection = null;

private Address deviceAddress = null;

Далее создадим в верхнем правом углу наше формы две кнопки. Пер­
вая кнопка «Host» будет использоваться для организации собственной
сессии, а вторая «Connect» — для подключения к существующему сеан­
су. Добавьте там же третью кнопку «Send Data», которая будет управлять
передачей данных в сети (до соединения эта кнопка должна быть забло­
кирована). Затем в нижней части экрана создадим экран индикации со­
стояния сети и приступим к работе с сетью.
Вначале мы запишем функцию инициализации объекта Peer и устано­
вим любое заданное по умолчанию состояние, см. листинг 18.1.

Листинг 18.1. Инициализация объекта Peer.
private void InitializeDirectPlay(bool host)

{

// Create our peer object
connection = new Peer() ;
// Check to see if we can create a TCP/IP connection
if (!IsServiceProviderValid(Address.ServiceProviderTcpIp))

{

// Nope, can't, quit this application
MessageBox.Show("Could not create a TCP/IP service provider.", "Exiting",
MessageBoxButtons.OK, MessageBoxIcon.Information) ;

this. Close();

}

// Create a new address for our local machine
deviceAddress = new Address();
deviceAddress.ServiceProvider = Address.ServiceProviderTcpIp;

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

имеет в качестве параметров флажки инициализации, приведенные в таб­

лице 18.1.

Таблица. 18.1. Флажки объекта

Флажок Описание

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

336
Часть VI. Добавление сетевых возможностей

Флажок

DisableLinkTuning

HintLanSession

None

Описание

Отключает возможность настройки скорости передачи данных в DirectPlay, автоматически устанавливается максимальная скорость
Открывает расширенное окно для сетевых игр
Позволяет установить все опции по умолчанию
Эти опции могут быть весьма полезны, однако сейчас они нам не по­
надобятся, поэтому мы будем использовать для этого приложения конст­
руктор, устанавливающий свойства по умолчанию. Так как для работы
приложения нам потребуется служба поддержки протокола TCP/IP, мы
должны проверить ее наличие в нашей системе. Для этого можно ис­
пользовать метод IsServiceProviderValid:

private bool IsServiceProviderValid(Guid provider)

I

// Ask DirectPlay for the service provider list
ServiceProviderlnformation[] providers =
connection.GetServiceProviders(true);
// For each service provider in the returned list...
foreach (ServiceProviderlnformation info in providers)

f

// Compare the current provider against the passed provider
if (info.Guid == provider)
return true;

}

// Not found
return false;

}
Эта процедура определяет все имеющиеся в нашей системе службы
поддержки протоколов и возвращает информацию обо всех обнаружен­
ных в системе службах, в том числе и тех, которые на данный момент
недоступны (при значении входного параметра функции равного «true»).
Если в возвращаемом массиве имеется идентификатор GUID, это гово­
рит о том, что служба поддержки обнаружена, и мы можем приступить к
созданию адреса. В случае если протокол TCP/IP не поддерживается,
приложение завершит работу. Мы также должны предусмотреть возмож­

ность освобождения объекта Peer после завершения соединения, для этого

имеется перегрузка по умолчанию Dispose:
if (connection != null)

connection.Dispose();

Теперь мы должны записать код для каждого сценария.

Глава 18. Организация сети с равноправными узлами с помощью DirectPlay 337

Начало сеанса

Итак, в нашей форме имеются две кнопки, соответственно, для сеан­
са Host и для сеанса Connect. Мы должны исключить возможность нажа­
тия одновременно двух кнопок или нажатия одной из них во время сеан­
са. Соответствующие обработчики событий приведены ниже:

private void buttonl_Click(object sender, System.EventArgs e)

{

buttonl.Enabled = false;
button2.Enabled = false;
InitializeDirectPlay(true);

}

private void button2_Click(object sender, System.EventArgs e)

{
buttonl.Enabled = false;
button2.Enabled = false;
InitializeDirectPlay(false);

}
Как вы можете видеть, разница между ними состоит только в конеч­
ном параметре, передающемся в метод InitializeDirectPlay (значение па­
раметра «true» для установки компьютера главным, другое значение —
«false» — для присоединяемой машины). Мы могли бы упростить дан­
ную процедуру, сделав ее общей для обеих кнопок:

private void button_Click(object sender, System.EventArgs e)

{
buttonl.Enabled = false;
button2.Enabled = false;
InitializeDirectPlay((sender == buttonl));

}
Результат выполнения этой процедуры такой же, но при этом мы из­
бегаем дублирования кода. Если нажатой окажется первая кнопка, метод
InitializeDirectPlay будет вызываться с входным параметром, имеющим
значением «true», в противном случае, со значением «false».
Теперь необходимо написать метод, распознающий и сообщающий
приложению о выбранном сеансе подключения. DirectPlay включает
структуру описания приложения, которая содержит всю необходимую
информацию. Нижеприведенный код для этой структуры необходимо
добавить в конец метода InitializeDirectPlay:

// Set up an application description
ApplicationDescription desc = new ApplicationDescription();
desc.SessionName = "MDXBookPeerSession";

1
2
Зак 604

338 Часть VI. Добавление сетевых возможностей
desc.GuidApplication = new Guid(41039, 1702,1503,178, 101,

32, 13, 121, 230, 109, 59);

Наиболее важный параметр этой структуры — GuidApplication. Иден­
тификатор GUID однозначно определяет наше приложение, и таким об­
разом, все примеры данного приложения должны его использовать. Дру­
гой параметр — имя сеанса (SessionName) — необходим при выполне­
нии нескольких сеансов связи. В таблице 18.2 приведены остальные па­
раметры структуры ApplicationDescription.
Таблица 18.2. Параметры структуры ApplicationDescription

Параметр

GuidApplication

Guidlnstance

MaxPlayers

CurrentPlayers

Описание

Уникальный идентификатор приложения
Уникальный идентификатор соединения, который генерируется DirectPlay. Идентифицирует отдельные
экземпляры приложения

Максимальное число пользователей в данном соединении. Нулевое значение (по умолчанию) устанавливает неограниченное число игроков
Число подсоединенных на данный момент пользователей
Flags Определяют поведение соединения, могут использоваться по отдельности или в различных комбинациях:
• ClientServer • FastSigned • FullSigned • MigrateHost
• NoDpnServer
• NoEnumerations

• RequirePassword
SessionName Имя соединения, определенное пользователем
Password Пароль для установления соединения. Это значение должно иметь пустой указатель (null) в случае, если флажок RequirePassword не был установлен
Теперь, имея структуру описания, мы можем приступить к созданию
соединения. Добавьте следующий код в конец метода инициализации:
if (host)

{

try

{

// Host a new session

Глава 18. Организация сети с равноправными узлами с помощью DirectPlay 339

connection.Host(desc, deviceAddress);
// We can assume after the host call succeeds we are hosting
AddText("Currently Hosting a session.");

EnableSendDataButton(true);

}
catch
{

AddText("Hosting this session has failed.");

}
}
Как вы можете видеть, вызов режима Host оказался в достаточной мере
«простым», входными параметрами этой функции являются описание
соединения и локальный адрес. Здесь мы использовали самый простой
из восьми существующих вариантов загрузки. Остальные также исполь­
зуют в качестве входных параметров указанное описание и один или бо­
лее адресных объектов.
В качестве параметра может использоваться объект, содержащий ин­
формацию об игроке (мы кратко опишем это чуть позже), или флажок,

определяющий поведение соединения, например, позволяющий DirectPlay

открыть диалоговое окно для получения недостающей информации об

адресах.

ПАРОЛИ НЕ ЗАШИФРОВАНЫ

Будьте внимательны при передаче паролей. Если вы хотите защитить

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

Итак, далее мы помещаем вызов процедуры Host в блок кода, позво­
ляющий отследить событие, когда метод по каким-либо причинам не
выполняется. Мы могли бы отслеживать только те исключительные си­
туации, которые входят в класс DirectPlayExcetion, но для нашего про­
стого примера мы попросту рассмотрим все подобные случаи. Но снача­
ла создадим процедуры, позволяющие модифицировать пользовательс­
кий интерфейс:

private void AddText(string text)

f

labell.Text += (text + "\r\n");

}

private void EnableSendDataButton(bool enable)

{

button3.Enabled = enable;

340
Часть VI. Добавление сетевых возможностей
Нет необходимости останавливаться на этих методах подробно, по­
скольку они весьма очевидны. Запуск приложения и нажатие кнопки
«Host» приведет к установке Р2Р-соединения, отобразит на экране за­
пись о текущем состоянии и сделает доступным использование третьей
кнопки «Send Data». Теперь нам необходим еще один узел для установки
сеанса соединения. Добавим следующую процедуру в конец метода ини­

циализации:

else

{

try

{

connection.FindHosts(desc, null, deviceAddress, null,
0, 0, 0, FindHostsFlags.OkToQueryForAddressing);
AddText("Looking for sessions.");

}

catch

{
AddText("Enumeration of sessions has failed.");

}

)

Мы снова включаем процедуру в блок try/catch, чтобы отследить воз­
можные ошибки, а также обновляем наше сообщение пользователю. Од­
нако, здесь вместо метода Connect мы вызываем метод FindHosts. В неко­
торых случаях возможно непосредственное присоединение к имеюще­
муся сеансу, но в большинстве случаев вначале необходимо найти суще­
ствующие хосты.
Аналогично методу Host, метод FindHosts принимает описание соеди­
нения и локальный адрес устройства. Вторым параметром является ад­
рес главного компьютера (пока мы его не знаем, поэтому используем пу­
стой указатель). Четвертый параметр этого метода — любые данные о
приложении, которые мы хотим передать на сервер.
Следующие три параметра определяют режим работы хостов: коли­
чество попыток передачи пакетов, ожидание перед следующей переда­
чей данных и время таймаута. Задавая нулевые значения этих парамет­
ров, мы определяем установку для них режима по умолчанию. После­
дний параметр может иметь одно или больше значений из списка
FindHostsFlags, который приведен в таблице 18.3.
Таблица 18.3. Значения и флажки структуры FindHostFlags
Параметр Описание
None Устанавливает все значения по умолчанию

Глава 18. Организация сети с равноправными узлами с помощью DirectPlay 341

Параметр

NoBroadcastFallback

OkToQueryForAddressing

Sync

Описание

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

Запустив теперь приложение, обратите внимание, что нажатие на кноп­
ку «Connect» вызовет диалоговое окно, запрашивающее адрес удален­
ной машины. Вы можете оставить это поле пустым, чтобы отследить со­
стояние всей сети. Вы можете также определить имя или IP-адрес иско­
мой удаленной машины. Следует отметить, что метод FindHosts не воз­
вращает никаких сведений относительно найденных хостов.

Использование модели событий

Большинство действий в DirectPlay выполняются асинхронно. Резуль­
тат выполнения процедуры возвращается немедленно, и сразу после это­
го DirectPlay начинает отработку поставленных задач. На данном этапе
нам понадобится обработчик ситуации, когда DirectPlay закончил выпол­
нение операции или выдал сообщение о состоянии приложения.
В нашем предыдущем вызове метода FindHosts выполнялся поиск всех
возможных соединений. Допустим, хост был найден. Поскольку нам не­
обходимо об этом знать, мы должны зафиксировать данное событие
(FindHostResponsee). Добавьте следующую строку сразу после создания
объекта Peer в методе InitializeDirectPlay:
connection.FindHostResponse += new

FindHostResponseEventHandler(OnFindHost);

Мы также должны создать обработчик этого события, см. листинг 18.2.

Листинг 18.2. Обработчик события обнаружения «Found Host».
private void OnFindHost(object sender, FindHostResponseEventArgs e)

{

lock(this)

{

342
Часть VI. Добавление сетевых возможностей
//Do nothing if we're connected already
if (connected)

return;

connected = true;
string foundSession = string.Format
("Found session ((О}), trying to connect.",
e.Message.ApplicationDescription.SessionName);
this.Beginlnvoke(new AddTextCallback(AddText),
new object[] { foundSession });
// Connect to the first one

((Peer)sender).Connect(e.Message.ApplicationDescription,

e.Message.AddressSender,

e.Message.AddressDevice, null, ConnectFlags.OkToQueryForAddressing);

}
}

Как вы можете видеть, данный обработчик возвращает объект
FindHostsReponseEventArgs, в котором содержится информация о най­
денном хосте. Вполне возможно, что могут быть одновременно найдены
два хоста или соединения. Наличие двух процессов, оперирующих од­
ним набором данных, может привести к возникновению больших про­
блем, и нам важно избежать данной ситуации. Мы будем использовать
для блокировки одного из потоков ключевое слово языка С# lock (кото­
рое по сути является аналогом вызова комбинации Monitor.Enter
Monitor.Exit в блоке try/finally). Таким образом, при использовании пер­
вого потока второй поток блокируется.
В итоге мы сможем присоединиться только к одному хосту, поэтому
мы должны объявить логическую переменную, определяющую наличие
уже установленного соединения. Если соединение существует, мы мо­
жем вернуться из процедуры, в противном случае переменной присваи­
вается значение «false», чтобы поиск соединения продолжался дальше.
Теперь нам необходимо сообщить пользователю, что сеанс обнару­
жен, и мы готовы начать соединение. Для этого в программе использует­
ся метод Beginlnvoke, вызывающий так называемый делегат с набором
параметров, определенным управляющим узлом. Данный метод работа­
ет асинхронно (классический вариант для DirectPlay). Вызвав Beginlnvoke,
мы можем продолжать работу нашего приложения, а делегат будет вы­
полнятся параллельно.
Имеется также метод Invoke, который принимает те же самые пара­
метры, но выполняется синхронно. Определение для делегата имеет вид:

private delegate void AddTextCallback(string text);

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

Глава 18. Организация сети с равноправными узлами с помощью DirectPlay 343
отображении диалогового окна, как можно быстрее получить необходи­
мые нам данные и завершить процедуру.
Наконец, мы готовы начать соединение (вернемся к рассмотрению
листинга 18.2). Вызов подключения Connect имеет четыре модели заг­
рузки, и, как обычно, мы используем самую простую из них. Обратите
внимание, что для передачи в процедуру Connect мы используем пара­
метры описания, принятые от обработчика FindHostsEventArgs.
Последние два пересылаемых нами параметра определены нашим
приложением. Первый из них — любые определяемые пользователем
данные, которые мы хотим передать в вызов Connect. Второй позволяет
DirectPlay сделать запрос на получение адресной информации, хотя в
этом нет особой необходимости, поскольку мы уже имеем ее. Для того
чтобы обеспечить синхронное выполнение, необходимо задействовать
флажок Sync, напомним, что по умолчанию установлен обратный вари­
ант.
Другие модели метода Connect содержат один или несколько парамет­
ров, которые мы не используем в нашем примере. Одним из выходных
параметров может являться асинхронный обработчик вызова (в DirectPlay
все асинхронные обращения могут возвращать подобный параметр), ко­
торый при необходимости можно использовать, чтобы отменить опера­
цию с помощью функции CancelAsyncOperation. Но здесь нам это не по­
надобится. Другие параметры являются определяемыми пользователем
контекстными переменными, которые могут использоваться для записи
специфических данных.

АДРЕСНАЯ ИНФОРМАЦИЯ

При попытке присоединиться к полноэкранному сетевому прило­

жению желательно, чтобы любая информация о возможных сете­

вых соединениях появлялась внутри пользовательского интерфей­

са игры, а не в отдельном диалоговом окне.

При разработке сетевых уровней для полноэкранного приложения

вам вряд ли захочется или, более того, понадобится пересылать

флажки OkToQueryForAddressing в методы Connect, Host или

FindHost, поскольку при этом DirectPlay отобразит свое собствен­

ное диал