Единое окно доступа к образовательным ресурсам

Введение в XNA

Голосов: 5

Книга адресована студентам и начинающим разработчикам, которые хотят использовать в своих проектах высокопроизводительную графику. Книга рассчитана на читателей, уже знакомых с основами C# и платформы .NET. Первая глава знакомит читателя с XNA Framework. Вторая глава посвящена визуализации базовых примитивов XNA Framework. В третьей главе рассматриваются более сложные вопросы визуализации: использование полноэкранного режима, плавная анимация примитивов и имитация прозрачности. В четвертой главе весь ранее изученный материал сводится воедино на примере создания полноценного хранителя экрана с дистрибутивом, при необходимости автоматически инсталлирующим на компьютер пользователя XNA Framework. В пятой, заключительной главе затрагивается тема программируемого графического конвейера, но уже на значительно более глубоком уровне; рассматриваются язык HLSL, основы ассемблеро-подобного языка Vertex Shader 1.1 и интегрированная среда разработки FX Composer 2.0, значительно облегчающая разработку и отладку шейдеров. Данная книга входит в состав <a target=_blank href="http://www.microsoft.com/Rus/Msdnaa/Curricula/">"Библиотеки учебных курсов"</a>, формирование которой ведется в рамках программы академического сотрудничества <a target=_blank href="http://www.microsoft.com/rus/msdnaa/">MSDN Academic Alliance (MSDN AA)</a>.

Приведенный ниже текст получен путем автоматического извлечения из оригинального PDF-документа и предназначен для предварительного просмотра.
Изображения (картинки, формулы, графики) отсутствуют.
                                                                          реализовывалась посредством библиотеки
                                                                      D3DX, являющейся частью DirectX. XNA
                                                                      Framework    выполняет     математические
                                                                      расчеты собственными средствами, что в
                                                                      некоторых случаях несколько повышает
                                                                      производительностью благодаря отсутствию
                                                                      накладных расходов взаимодействия с COM.
Microsoft.Xna.Framework.Graphics                  Graphics            Работа с графикой
Microsoft.Xna.Framework.Graphics.PackedVector     Graphics            Работа    с    упакованными    векторами.
                                                                      Примером упакованного вектора является 32-
                                                                      х битное число, содержащее информацию о
                                                                      яркости    красной,   синей  и    зеленой
                                                                      компонентах цвета.
Microsoft.Xna.Framework.Audio                     Audio               Работа со звуком
Microsoft.Xna.Framework.Input                     Input               Работа с устройствами ввода (клавиатура,
                                                                      мышь, джойстики).
Microsoft.Xna.Framework.Storage                   Storage             Работа с файловой системой текущей
                                                                      платформы: загрузка и сохранение настроек
                                                                      приложения, “сохраненных игр” (Save
                                                                      Games) и т.д.


Ничего страшного, если у вас на первых порах будет рябить в глазах от обилия компонентов. По мере
изучения XNA Framework всѐ встанет на свои места. В первой главе мы познакомимся с некоторыми
классами пространства имен Microsoft.Xna.Framework.Graphics, и научимся использовать их для
визуализации относительно простых двухмерных изображений.

1.1. Создание простейшего приложения, использующего XNA
Framework.
Как известно, лучший способ получить представление о новой технологии – написать с еѐ помощью
простейшее приложение. Так мы и поступим. Наше первое приложение, использующее XNA Framework,
будет просто закрашивать форму синим цветом (рисунок 1.3). Для создания GUI5-интерфейса мы
воспользуемся библиотекой Windows Forms, являющуюся стандартом для платформы .NET.




Рисунок 1.3. Наша первое приложение(Ex01), использующее XNA.



5
    Graphic User Interface – графический пользовательский интерфейс


Для начала запустите Microsoft Visual Studio 2005 и создайте новый проект GUI–приложения для
платформы Windows (File | New | Project...). В раскрывшемся окне выберите Visual C#
| Windows | Windows Application,         введите название приложения, снимите флажок
Create directory for Solution и нажмите Ok6. Переименуйте файл формы из Form1.cs в
           7
MainForm.cs .
Следующий шаг – подключение сборки Microsoft.Xna.Framework.dll, содержащий компоненты слоя Core
Framework, включая необходимый нам компонент Graphics.Для подключения сборки щѐлкните правой
кнопкой мыши на узле Reference в окне Solution Explorer и выберите в контекстном меню пункт Add
Reference... (рисунок 1.4). В открывшемся окне выберете сборку Microsoft.Xna.Framework и нажмите
кнопку Ok (рисунок 1.5).




Рисунок 1.4. Вкладка Solution Explorer




6
    В простых приложениях я предпочитаю следовать принципу “один проект – одно решение”.
7
    Во всех примерах книги главная форма приложения будет называться MainForm.cs.


Рисунок 1.5. Окно Add Reference

Теперь мы можем приступать к собственно написанию программы. Откройте окно редактирования
исходного кода, щелкнув правой кнопкой мыши по форме и выбрав пункт View Code контекстного меню
(либо нажав на кнопке View Code в верхней части окна Solution Explorer). Так как мы будем активно
использовать классы из пространства имен Microsoft.Xna.Framework.Graphics, было бы логично
добавить в начало программы следующую строку:
using Microsoft.Xna.Framework.Graphics;
В XNA Framework все низкоуровневые графические операции выполняются с использованием класса
GraphicsDevice, инкапсулирующим графическое устройство (трѐхмерный ускоритель). Конструктор
класса GraphicsDevice объявлен следующим образом:
public   GraphicsDevice(GraphicsAdapter adapter,  DeviceType  deviceType,   IntPtr
renderWindowHandle, CreateOptions creationOptions, params PresentationParameters[]
presentationParameters);
где
 adapter – экземпляр класса GraphicsAdapter, соответствующей используемой видеокарте (многие
  современные компьютеры содержат две и более видеокарты). Для указания видеокарты по умолчанию
  достаточно передать в качестве данного параметра значение статического свойства
  GraphicsAdapter.DefaultAdapter.
 deviceType – тип устройства, задаваемый с использованием перечислимого типа DeviceType (таблица
  1.4). На практике обычно используется значение DeviceType.Hardware.
 renderWindowHandle – дескриптор окна или элемента управления, который будет использоваться для
  вывода информации.
 creationOptions – набор битовых флагов перечислимого типа CreateOptions, задающих режим
  работы устройства (таблица 1.5). В нашем случае мы будем использовать режимы
  CreateOptions.SoftwareVertexProcessing и CreateOptions.SingleThreaded.
 PresentationParameters – набор структур PresentationParameters, описывающих представление
  данных   на   экране   монитора.    Каждому    монитору   соответствует  своя   структура
  PresentationParameters. Так как наши приложение будет осуществлять вывод только на один


     монитор, мы ограничимся одной структурой PresentationParameters. В таблице 1.6 приведено
     описание некоторых свойств структуры PresentationParameters.
Если попытка создания устройства заканчивается неудачей, конструктор генерирует исключение. Подобная
ситуация возникает, к примеру, при попытке создания устройства с использованием флага
CreateOptions.HardwareVertexProcessing на видеокарте, не имеющей аппаратных вершинных
процессоров. Примерами таких видеокарт являются Intel GMA 900 и Intel GMA950, интегрированные в
чипсеты i915G и i945G соответственно. Так как флаг HardwareVertexProcessing влияют исключительно
на выполнение вершинных шейдеров, в то время как примеры этой главы не используют эту
функциональность, применение данного флага некоим образом не повлияет на производительность наших
приложений и лишь неоправданно увеличит требования к видеокарте. Поэтому в примерах первой главы
книги мы ограничимся использованием лишь флага SoftwareVertexProcessing.
                                                       Таблица 1.4. Значения перечислимого типа DeviceType

Значение                                                Описание
Hardware                                                Аппаратное устройство
Reference                                               Устройство эмулируется средствами DirectX SDK. Обычно
                                                        используется для эмуляции функциональности, не
                                                        поддерживаемой текущей видеокартой (например,
                                                        эмуляция пиксельных шейдеров8 на GeForce2). Правда,
                                                        такую эмуляцию реально использовать лишь в отладочных
                                                        целях, так как производительность приложений в этом
                                                        режиме редко превышает один кадр в секунду.
NullReference                                           Нуль-устройство, игнорирующее все поступающие
                                                        команды (наподобие устройства NUL в MS-DOS и
                                                        Windows).    Может    использоваться   для   оценки
                                                        производительности приложения на бесконечно быстрой
                                                        видеокарте.




                                                     Таблица 1.5. Значения перечислимого типа CreateFlags

Значение                                                Описание
HardwareVertexProcessing                                Аппаратная обработка вершин средствами GPU9
SoftwareVertexProcessing                                Программная обработка вершин средствами CPU.
MixedVertexProcessing                                   Смешанная обработка вершин. Позволяет приложению
                                                        самостоятельно переключаться между программной и
                                                        аппаратной обработкой вершин. Полезна, к примеру, при
                                                        использовании вершинных шейдеров версии 2.0 на
                                                        GeForce3, который аппаратно поддерживает только
                                                        вершинные шейдеры версии 1.1. В этом случае вершинные
                                                        шейдеры версии 1.1 можно выполнять аппаратно, а версии
                                                        2.0 – в режиме программной эмуляции.
NoWindowChanges                                         Устройство не будет автоматически восстанавливаться
                                                        после потери фокуса окном и т.д. Все эти действия
                                                        ложатся на плечи программиста. Данное значение
                                                        применяется очень редко.
SingleThreaded                                          Увеличивает производительность за счет отключения
                                                        критических   секций,    позволяющих    одновременно
                                                        обращаться к устройству из нескольких потоков.
                                                        Рекомендуется всегда по возможности использовать этот
                                                        флаг.
SinglePrecision                                         Переключает математический сопроцессор в режим
                                                        пониженной точности. Все вычисления с плавающей
                                                        точкой, включая использующие тип double, будут
                                                        выполнять с точностью 7 знаков. Более подробная


8
    Основы вершинные и пиксельных шейдеров будут рассмотрены в разделе 2.3.
9
    Graphic Processor Unit – графический процессор, установленный на видеокарте.


                                                    информация об этом режиме приведена во врезке.


                                        Таблица 1.6. Некоторые свойства структуры PresentationParameters

Поле                                                Описание
bool IsFullScreen                                   При выводе на поверхность компонента или формы этому
                                                    свойству необходимо присвоить значение false. Если же
                                                    приложение является полноэкранным, то используется
                                                    значение true.
int BackBufferCount                                 Задаѐт    количество      вспомогательных      буферов,
                                                    используемых для борьбы с эффектом мерцания при смене
                                                    кадров. При использовании одного вторичного буфера
                                                    изображение сначала рисуется во вспомогательном
                                                    буфере, после чего уже готовое изображение копируется в
                                                    экранный буфер. Этот процесс называется двойной
                                                    буферизацией.     Буферизация,     использующая     два
                                                    вспомогательных буфера, называется тройной. Более
                                                    подробно    различные     типы     буферизации    будут
                                                    рассмотрены в соответствующих разделах книги. А пока
                                                    мы будем использовать          двойную буферизацию,
                                                    присваивая полю BackBufferCount значение 1.
int BackBufferWidth                                 Ширина вспомогательных буферов в пикселях. Если этот
                                                    параметр равен 0, то конструктор метода Device
                                                    рассчитывает его автоматически, полагая равным ширине
                                                    клиентской области окна10.
int BackBufferHeight                                Высота вспомогательных буферов в пикселях. Если этот
                                                    параметр равен 0, то конструктор метода Device
                                                    рассчитывает его автоматически, полагая равным высоте
                                                    клиентской области окна.
Direct3D.SwapEffect SwapEffect                      Указывает, каким образом осуществляется переключение
                                                    буферов при двойной и тройной буферизации.
                                                    Подавляющее большинство программ присваивают этому
                                                    полю значение SwapEffect.Discard – в этом случае
                                                    видеокарта сама выбирает режим переключения буфера,
                                                    наиболее подходящий в конкретной ситуации.


Точность вычислений с плавающей точкой процессоров архитектуры x86
Блок вычислений с плавающей точкой (FPU) процессоров x8611 содержит восемь 80-ти битных регистров
общего назначения, используемых для хранения операндов и результатов вычислений. Иными словами,
независимо от используемых типов данных сопроцессор всегда оперирует с 80-ти битным форматом с
плавающей точкой, известным как extended double. Если операнды имеют меньшую разрядность
(например, используется тип float), то они автоматически конвертируются в 80-ти битный формат, а
результат перед копированием в память переводится обратно в 32-х битный формат float.
Так как подобная точность вычислений оказывается излишней, в одном из управляющих регистров
процессора (CW) имеются два бита (PC), управляющие точностью вычислений. В зависимости от значения
битов, задающихся при запуске приложения, вычисления выдуться с 7-ю, 16-ю или 19-ю значащими
цифрами. Ещѐ раз хочу подчеркнуть важную деталь. Формат чисел в регистрах всегда остаѐтся 80-ти
битным, просто с понижением точности младшие разряды числа с плавающей точкой могут содержать
недостоверную информацию.
Два бита PC регистра CW устанавливаются при запуске потока (thread) и, как правило, не меняются в
процессе выполнения приложения. В то же время, параметр CreateOptions.SinglePrecision
приказывает конструктору класса GraphicsDevice изменить служебный регистр CW таким образом, чтобы
установить внутри сопроцессора точность вычислений 7 знаков. В результате, после вызова данного метода
вычисления, включая использующие типы double, будут выполняться с 7-ю значащими знаками. Правда
существуют и исключения: так, к примеру, биты PC регистра CW оказывают влияние на точность сложения,


10
   Часть окна, используемая приложением для вывода информации. В клиентскую область окна не входят
заголовок окна, рамки по краям окна и т.д.
11
   До появления i486DX этот блок располагался в отдельной микросхеме, называемой математическим
сопроцессором (8087, 80287, 80387).


вычитания, умножения, деления и вычисления квадратного корня, но совершенно не затрагивают точность
команд вычисления синуса и косинуса.
В общем, здесь очень много различных тонкостей, но разбираться в них, в общем-то, не нужно. Достаточно
запомнить, что флаг CreateOptions.SinglePrecision таит много подводных камней, поэтому применять
его стоит только при реальной необходимости поднять производительно математической подсистемы
любой ценой. В остальных случаях вы лишь повысите вероятность возникновения различных трудно
обнаруживаемых ошибок. Ведь никто не сможет гарантировать, что одна из используемых вами библиотек
не начнѐт вести себя как-то странно, столкнувшись с аномально низкой точностью вычислений,
использующих типы double. Например, пониженная точность может очень негативно сказаться на качестве
генератора псевдослучайных чисел.

И так, для создания графического устройства мы должны объявить в тексте класса формы поле класса
GraphicsDevice:
GraphicsDevice device=null;
Затем в обработчик события Load формы необходимо вставить код создания нового экземпляра класса
                                                    12
GraphicsDevice c заданными параметрами (листинг 1.1) .

 Листинг 1.1

private void MainForm_Load(object sender, EventArgs e)
{
// Инициализируем все поля структуры presentParams значениями по умолчанию
    PresentationParameters presentParams = new PresentationParameters();
// Мы будем осуществлять вывод на поверхность формы, то есть в оконном режиме
    presentParams.IsFullScreen = false;
// Включаем двойную буферизацию
    presentParams.BackBufferCount = 1;
// Переключение буферов должно осуществляться с максимальной эффективностью
    presentParams.SwapEffect = SwapEffect.Discard;
// Задаѐм ширину и высоту клиентской области окна. Если присвоить этим полям значение 0 (что
// и происходит по умолчанию), то конструктор класса GraphivsDevice автоматически рассчитает
// значение этих полей и занесѐт их в структуру presentParams. Поэтому эти две строки, в
// принципе, можно и опустить.
    presentParams.BackBufferWidth = ClientSize.Width;
    presentParams.BackBufferHeight = ClientSize.Height;

// Создаѐм новое устройство, обладающее следующими характеристиками:
// - Устройство будет использовать видеоадаптер по умолчанию
// - Устройство будет аппаратным
// - Вывод будет осуществляться на поверхность текущей формы
// – Обработка вершин будет осуществляться средствами GPU
// - Представление данных на экране задаѐтся структурой presentParams (см. выше)
// – Доступ к устройству возможен только из одного потока приложения
    device = new GraphicsDevice(GraphicsAdapter.DefaultAdapter, DeviceType.Hardware, Handle,
        CreateOptions.SoftwareVertexProcessing | CreateOptions.SingleThreaded,
presentParams);
}


Создав объект устройства, можно приступать к реализации закраски формы синим цветом. Для этого
воспользуемся методом Clear13 класса GraphicsDevice, который очищает форму путѐм закраски еѐ заданным
цветом:
public void Clear(ClearOptions options, Color color, float depth, int stencil);
где

12
  Во всех примерах книги главная форма приложения называется MainForm.
13
  Практически все классы XNA Framework, включая GraphicsDevice, имеют множество перегрузок
(override) конструкторов и методов (иногда более десятка) “на все случаи жизни”. В этой в этой книге будут
рассматриваться лишь наиболее распространѐнные и общие из них – информацию об остальных
перегруженных методах вы легко сможете найти в справочной системе.


     options – набор битовых флагов, указывающих какие буферы необходимо очистить. Для очистки
      экранного   буфера    используется    флаг    ClearOptions.Target.    Остальные     флаги
      ClearOptions.DepthBuffer и ClearOptions.Stencil, используемые для очистки соответственно
      буфера глубины и буфера шаблона, которые будут рассмотрены в следующих главах.
     color – цвет, которым будет закрашен экран. Задаѐтся с использованием структуры
      Microsoft.Xna.Framework.Graphics.Color, являющейся функциональным аналогом структуры
      System.Drawing.Color. Появление такого брата-близнеца обусловлено необходимостью сделать XNA
      Framework независимым от функциональности платформы Windows.
     depth – значение, которым будет “закрашен” буфер глубины.
     stencil – значение, которым будет заполнен буфер шаблона.
Вызов метода Clear необходимо вставить в обработчик события Paint, вызываемый каждый раз при
необходимости перерисовки содержимого формы:
private void MainForm _Paint(object sender, PaintEventArgs e)
{
    device.Clear(ClearOptions.Target, Microsoft.Xna.Framework.Graphics.Color.CornflowerBlue,
 0.0f, 0);
}
Обратите            внимание          на         использование           полного          имени          структуры
Microsoft.Xna.Framework.Graphics.Color с указанием пространства имен. Если это не сделать,
возникнет конфликт с одноименной структурой из пространства имен System.Drawing.
Класс GraphicsDevice имеет и более простую перегрузку (override) метода, предназначенную для очистки
исключительно экранного буфера:
public void Clear(Color color);
где
     color – цвет, которым заполняется весь экран.
Использование данного варианта перегрузки метода позволяет несколько упростить код приложения:
private void MainForm_Paint(object sender, PaintEventArgs e)
{
    device.Clear(Microsoft.Xna.Framework.Graphics.Color.CornflowerBlue);
}
По окончанию работы приложение должно удалить графическое устройство при помощи метода Dispose.
Для этой цели идеально подходит обработчик события FormClosed (листинг 1.2).

    Листинг 1.2.

private void MainForm_FormClosed(object sender, FormClosedEventArgs e)
{
// Если устройство существует
    if (device != null)
    {
// Удаляем (освобождаем) устройство
        device.Dispose();
// На всякий случай присваиваем ссылке на устройство значение null
        device = null;
    }
}
Если вы забудете удалить объект устройства, .NET самостоятельно попытается вызвать метод Dispose
экземпляра класса GraphicsDevice в процессе сборки мусора (если быть более точным, сборщик мусора
вызывает метод Finalize, который довольно часто реализует вызов метода Dispose). Но здесь имеется
один нюанс. Как известно, сборщик мусора для вызова методов Finalize удаляемых объектов создаѐт
отдельный поток, в то время как на платформе Windows устройство Direct3D имеет право удалить только
поток, создавший это устройство. Соответственно, деструктор объекта GraphicsDevice, вызываемый из
параллельного потока, не сможет корректно удалить устройство Direct3D.
         П р им еч а н ие.
         Даже если вы не укажите при создании устройства флаг CreateOptions.SingleThreaded, сборщик мусора всѐ равно
         не сможет корректно удалить объект.


Вроде бы всѐ. Давайте попробуем запустить полученное приложение на выполнение (клавиша F5). Не
смотря на то, что метод Clear вызывается при каждой перерисовке окна (в этом легко убедится, установив
точку останова на строку с вызовом этого метода при помощи клавиши F9) , на внешнем виде формы это
никак не отражается. Интересно, с чем это может связано?
Всѐ дело в том, что мы используем двойную буферизацию, то есть наше приложение выполняет все
графические построения в невидимом вспомогательном буфере. После окончания визуализации необходимо
скопировать информацию из этого вспомогательного буфера на форму. Эту операцию выполняет метод
Present класса GraphicsDevice:
void Present()
Добавьте вызов этого метода в конец обработчика события Paint и снова запустите программу на
выполнение – на экране появится окно, закрашенное синим цветом, что и требовалось. Исходный код
готового приложения находится на CD с книгой в каталоге Ch01\Ex01.

1.2. Визуализация шахматной доски.
Одна из перегрузок метода GraphicsDevice.Clear позволяет очищать не весь экран целиком, а лишь
заданную прямоугольную область формы:
public void Clear(ClearOptions         options,    Color   color,    float   depth,   int   stencil,
Rectangle[] regions);
где
rect – массив структур Microsoft.Xna.Framework.Rectangle, задающих прямоугольные области
экрана, которые должны быть очищены. Области экрана задаются в оконных координатах формы – начало
координат расположено в левом верхнем углу. Структура Microsoft.Xna.Framework.Rectangle является
близнецом одноименной структуры из пространства имен System.Drawing, и используется во избежание
привязки XNA Framework к платформе Windows.
      П р им еч а н ие
      Структура Rectangle объявлена в пространстве имен Microsoft.Xna.Framework, так как он
      используется многими классами XNA Framework, в том числе и не из пространства имен
      Microsoft.Xna.Framework.Graphics.

К примеру, следующий фрагмент кода нарисует в центре экрана зелѐный прямоугольник на синем фоне
(рисунок 1.6):

Листинг 1.3.

// Закрашиваем экран синим цветом
device.Clear(Microsoft.Xna.Framework.Graphics.Color.CornflowerBlue);


// Создаѐм массив с координатами областей экрана, которые необходимо закрасить. Нам
// нужна всего одна область
Microsoft.Xna.Framework.Rectangle[] rect = new Microsoft.Xna.Framework.Rectangle[1];
// Задаѐм координаты области экрана, расположенной в центре экрана и занимающей 25%
// площади экрана
rect[0] = new Microsoft.Xna.Framework.Rectangle(ClientSize.Width/4,
 ClientSize.Height/4, ClientSize.Width/2, ClientSize.Height/2);
// Закрашиваем эту область зелѐным цветом
device.Clear(ClearOptions.Target, Microsoft.Xna.Framework.Graphics.Color.Green, 0.0f,
 0, rect);


Рисунок 1.6. Зелѐный квадрат на синем фоне, нарисованный с использованием метода Clear.

В принципе при грамотном использовании только одного метода Clear можно получать довольно
интересные изображения. К примеру, никто не мешает нам нарисовать шахматную доску (рисунок 1.7). Для
этого необходимо очистить экран белым цветом, затем создать массив областей экрана, соответствующих
клеткам доски коричневого цвета и ещѐ раз очистить экран, но уже коричневым цветом (листинг 1.4).




Рисунок 1.7. Шахматная доска, нарисованная с использованием метода Clear




 Листинг 1.4.

// Полный код приложения находится в каталоге Examples\Ch01\Ex02
private void MainForm_Paint(object sender, PaintEventArgs e)
{
// Очищаем экран белым цветом
    device.Clear(Microsoft.Xna.Framework.Graphics.Color.WhiteSmoke);
// Создаѐм массив областей закраски, соответствующих коричневым клеткам
    Microsoft.Xna.Framework.Rectangle[] rects = new Microsoft.Xna.Framework.Rectangle[32];

    int k = 0;
// Перебираем коричневые клетки шахматной доски
    for (int j = 0; j < 8; j++)
        for (int i = j % 2; i < 8; i += 2)
        {
// Заносим в массив координаты очередной клетки
            rects[k] = new Microsoft.Xna.Framework.Rectangle(i * ClientSize.Width / 8,
 j * ClientSize.Height / 8, ClientSize.Width / 8, ClientSize.Height / 8);

                k++;


         }

// Закрашиваем все области из массива rects коричневым цветом
    device.Clear(ClearOptions.Target, Microsoft.Xna.Framework.Graphics.Color.Brown, 0.0f, 0,
 rects);
    device.Present();
}



1.2.1. Конфигурирование DirectX для отладки приложения.
Как вы помните, на платформе Windows XNA Framework в некотором роде является высокоуровневой
надстройкой над DirectX. Соответственно, на платформе Windows подавляющее большинство вызовов
методов XNA Framework так или иначе транслируется в вызовы методов DirectX. В большинстве случаев
это обстоятельство можно полностью игнорировать. Тем не менее, при возникновении различных
“аномалий” в приложении обращение к нижележащему уровню может помочь быстро решить проблему.
Конфигурирование DirectX осуществляется при помощи утилиты DirectX, запускаемой командой Start |
All Programs | Microsoft DirectX SDK | DirectX Utilities | DirectX Control Panel.
Внешний вид этой утилиты изображѐн на рисунке 1.8. Как видно, данная утилита представляет собой
обычное диалоговое окно с набором вкладок, отвечающих за настройку различных компонентов DirectX.
Рассмотрим наиболее важные из них.




Рисунок 1.8. Внешний вид утилиты конфигурирования DirectX. Открыта вкладка Direct3D.

Вкладка Direct3D предназначена для настройки компонента Direct3D Graphics. Как правило, эта
вкладка используется для переключения между отладочной и “обычной” версией Direct3D при помощи
переключателей Use Debug Version of Direct3D и Use Retail Version of Direct3D
соответственно        (расположены в группе Debug/Retail D3D Runtime). Отладочная
версия     Direct3D    Graphics    проводит     дополнительную      проверку     правильности



    
Яндекс цитирования Яндекс.Метрика