Здравствуйте, уважаемые подписчики!

Как вы заметили, внешний вид выпусков немного изменился – чтобы отметить новый сезон. Я надеюсь, в лучшую сторону ;-) Но судить конечно вам. Присылайте свои соображения.

Сегодня в рассылке впервые будет затронута тема DirectX (давно пора, надо сказать). И, конечно, вас ждут еще рубрики "Вопрос-Ответ" и "Экзамен".

Автор: Александров Алексей

Демонстрационное приложение (только .exe) (72 kb)

Демонстрационное приложение (исходный код) (44 kb)

Рисунок: демонстрационное приложение 

Компьютерная графика всегда была одним из самых интересных проявлений развития информационных технологий. Давным-давно, во времена текстовых терминалов никто даже и представить себе не мог, что пройдет совсем немного времени и образы фантастических монстров будут создаваться не с помощью папье-маше и пластилина, а прямо на экране компьютера. Это сейчас все привыкли к графическому интерфейсу, и изображением на экране уже никого не удивишь. На самом деле надо поставить памятник человеку, который впервые решил нарисовать картинку из текстовых символов – такого рода искусство было очень распространено в свое время, и его отголоски до сих пор встречаются в различного рода конференциях. История развития компьютерной графики интересна сама по себе и заслуживает отдельной книги, но данный документ имеет чисто технический характер, поэтому мы не будем останавливаться на этапах становления искусства рисования на экране монитора, а обратимся сразу к нашим дням. Стандартом де-факто на компьютерах под управлением операционной системы Windows стали две 3D библиотеки: OpenGL и Direct3D (часть библиотеки DirectX). OpenGL, разработанный фирмой Silicon Graphics, уже стал классикой и характеризуется своей устойчивостью и стабильностью интерфейсов. Напротив, Direct3D, детище Microsoft, постоянно изменяется, совершенствуется и двигается вперед. Последняя версия этого продукта имеет номер 8, и это не конец. В этой статье я бы хотел познакомить читателя с некоторыми аспектами использования этого нового продукта, указать на его отличия от предыдущей версии и продемонстрировать его использование для решения одной из весьма распространенных задач – построения графика функции двух переменных. Исходный код примера вы может получить с этого сайта и свободно использовать в своих приложениях.

DirectX 8.0a SDK можно найти здесь.

Англоязычную версию DirectX 8.0a Runtime for Windows 95, Windows 98, Windows 98 SE, Windows ME можно найти здесь.

Англоязычную версию DirectX 8.0a Runtime for Windows 2000 можно найти здесь.

Локализованные версии DirectX 8.0a Runtime расположены тут.

Перед тем как начать, хотелось бы еще сказать несколько слов по поводу терминологии, используемой в статье. Приведенная информация базируется в основном на документации от Microsoft, которая доступна пока (и похоже, что так будет всегда) исключительно на английском языке. Не то, что бы никто у нас не знает английского языка, но уж человеческая психика так устроена, что одни и те же термины все авторы переводят на русский по своему. Поэтому мной было принято решение: термины, по которым читатель скорее всего захочет узнать больше из официальной документации, оставлять на их родном языке. Так что не удивляйтесь, увидев термин "flip chain" вместо "последовательность отображения" или "цепочка переворота"… В некоторых случаях представлен перевод термина с указанием в скобках оригинального слова или выражения. Например: "матрица проектирования (projection matrix)".

Любой автор статьи рано или поздно сталкивается с нелегким вопросом: какую среду разработки использовать для иллюстрирования излагаемого материала. Даже после выбора Visual C++ в качестве базы остается несколько альтернативных путей: уж больно много расплодилось различных библиотек и frameworks. Можно выделить 4 наиболее заметных (сразу же отмечу их недостатки и достоинства):

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

• MFC приложение. Наиболее распространенный выбор. Сейчас уже трудно найти компьютер, на котором отсутствует mfc42.dll, хотя, распространяя приложение, вы должны предусмотреть все варианты. К недостаткам можно отнести некоторую угловатость и тяжеловесность исходников.

• WTL (Windows Template Library) приложение. Замечательная штука, но почему-то еще не все люди слышали о WTL, и, что еще более печально, не у всех она установлена.

• И, наконец, ATL приложение. Наиболее любимый мною подход, пригодная (вопреки общему мнению) для создания практически любого Windows-приложения. К сожалению, мастер ATL из комплекта Visual C++6 не поддерживает генерацию не-COM приложения.

После долгих размышлений я остановился на последнем варианте. Как говорится, читателю все равно, а мне приятно. Шутка. На самом деле, я действительно считаю, что этот подход позволил мне сделать код максимально понятным, и человек, не измученный нарзаном в виде MFC, разберется там без особых проблем. Если вы ненавидите ATL – не читайте эту статью дальше. Чтобы внести некоторую ясность и определенность, спешу представить вашему вниманию диаграмму классов для демо-приложения. Выполнено в Rational Rose 2000 – нотация Буча.

Рисунок: диаграмма классов

Несколько комментариев по назначению реализованных классов:

• CMainDlg – Главный класс приложения. Унаследован от CDialogImpl и создается в функции WinMain как немодальный диалог. Содержит в себе один экземпляр класса C3DGraphic, один C3DGraphFrame, 4 немодальных диалога редактирования свойств (CMaterialPropsWindow, CLightPropsWindow, CBackColorWindow and CFunctionTypeWindow) и 3 объекта 3D функций (CSplashFunction, CPlaneFunction and CParabaloidFunction).

• CPropertyWindow – Базовый класс для всех окон редактирования свойств. Унаследован от CDialogImpl.

• C3DFunction – Базовый абстрактный класс, определяющий интерфейс получения информации о какой-либо функции 2-х переменных.

• CPropertyWindowNotify – Абстрактный класс-интерфейс, реализуемый клиентами окон свойств. Через этот интерфейс клиенты уведомляются об изменениях, происходящих со свойствами.

• CD3D8Application – Весьма простой класс-обертка для управления жизнью и смертью IDirect3D8 объекта.

• C3DGraphFrame – Окно, в котором будет отображаться результирующая 2D проекция трехмерного изображения. Говоря в терминах MFC, класс вида для трехмерного графика.

• C3DGraphic – Наиболее значимый и нагруженный класс, выполняющий всю основную работу по построению и обработке 3D картинки. Именно он реализует операции управления светом, свойствами материала, рендеринга и тому подобные. Собственно, ради него все и затевалось…

То ли Микеланджело, то ли еще кого-то из великих однажды спросили, как создать скульптуру. Великий, недолго думая, ответил: "Возьмите большой камень и удалите все лишнее." Окинув взглядом все вышеизложенное, можно сделать простой вывод: демо-приложение является ни чем иным, как обычным ATL EXE COM сервером, из исходного кода которого хитрой рукой автора было удалено все относящееся к COM технологии. Построение такого приложение само по себе является интересной задачей, но мы не скульпторы, так что подробности оставим в стороне. Тем более, что тема моей статьи все-таки DirectX, а не ATL. Вот сейчас – как раз об этом…

Если вы когда-либо имели дело с предыдущими версиями DirectX, то Вас ждет очень интересное открытие: DirectDraw больше нет вообще!!! Microsoft в очередной раз решил обобщить все что можно, и теперь все относящееся к рисованию в DirectX представлено под одним общим заголовком DirectX Graphics. Все изменилось кардинальным образом по сравнению с DirectX7. Интерфейс IDirect3DDevice8, например, имеет 94 метода. Для сравнения, IDirect3DDevice7 позволял выполнить лишь 48 операций. Back-буферизация теперь поддерживается автоматически, без каких-либо усилий с Вашей стороны – не надо больше вручную создавать эти загадочные flip chains. Инициализация Direct3D стала простой как i++, и многие низкоуровневые детали теперь стали вообще недоступны программисту. Не всегда это здорово – например, теперь вы не можете рисовать что-либо непосредственно на primary surface. Более того, вы и читать то с нее ничего не можете. Точнее можете, но Microsoft не советует. От себя посоветую никогда не делать что-либо нерекомендованное Microsoft, а любопытных отсылаю к документации по методу IDirect3DDevice8::GetFrontBuffer. Впрочем, к вопросам совместимости Microsoft всегда относилась внимательно, и, установив DirectX8, Вы можете свободно работать и со всеми предыдущими версиями этого продукта.

А что же делать тем людям, которые никогда не имели дела с Direct3D вообще??? Специально для них я бы хотел вкратце обрисовать основное назначение этой библиотеки (предполагается, что Вы все же знакомы с теоретическими аспектами построения 3D моделей):

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

• Поддерживается стандартный конвейер 3D преобразований: матрица окружения (world matrix), матрица моделирования (view matrix) и матрица проектирования (projection matrix).

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

• Очень мощная подсистема освещения: свет и материалы.

• 3D текстурирование. Очень забавная и гибкая вещь, позволяющая делать поистине впечатляющие вещи: можно натянуть любое изображение на любой 3D объект.

• За деталями упомянутого и всего остального – добро пожаловать в DirectX 8.0a SDK.

Работа с любой новой средой разработки или библиотекой начинается, как правило, с одного и того же вопроса: "Боже мой! Ну почему оно не компилируется???!!!". Для успешной компиляции Direct3D8 проекта Вам необходимо включить некоторые заголовочные файлы и скомпоновать Вашу программу с соотвествующими lib-файлами. Наиболее важными являются 2 заголовочных и 2 lib-файла:

• d3d8.h – Файл с определениями основных интерфейсов, констант и тому подобного.

• d3d8.lib – Файл для компоновки Вашей программы с динамической библиотекой Direct3D8.

• d3dx8.h – Вспомогательные интерфейсы и определения, несколько облегчающие жизнь среднестатистическому программисту.

• d3dx8.lib – Библиотека для компоновки программы с d3dx8.dll.

Среди файлов демо-проекта вы увидите 2 файла: D3D8Include.h и D3DX8Include.h. Просто включите их в файл stdafx.h Вашего проекта. Тем самым будут включены все необходимые header-файлы и обеспечена компоновка с соотвествующими lib-файлами.

Ну вот, вроде бы все готово к бою и что же теперь? Первым делом необходимо создать IDirect3D8 объект. Не совсем, правда, грамотно звучит. Правильнее было бы сказать, "необходимо создать некий объект, который выставляет интерфейс IDirect3D8", но, думаю, Вы мне простите подобные вольности. Объект IDirect3D8 обеспечивает создание 3D устройств, получение информации о возможностях устройства, перечисление видеорежимов адаптера и получение подробной информации о них, в общем, кучу всего интересного и нужного. Мой демо-проект для создания этого нужного объекта использует класс-обертку CD3D8Application. Для его использования надо просто унаследовать от него класс приложения и в какой-нибудь функции инициализации (например, в OnInitDialog) вызвать метод CD3D8Application::Direct3DInitOK() для проверки результата создания объекта. Объект IDirect3D8 создается в конструкторе класса CD3D8Application с помощью вызова функции Direct3DCreate8(). Замечательная функция в том плане, что принимает только один параметр, да и тот просто обязан быть D3D_SDK_VERSION. Таким образом, создание требуемого объекта сводится к следующему:

pDirect3DObject = Direct3DCreate8(D3D_SDK_VERSION);

if (!pDirect3DObject) {

 // Do something!!! Error occured!!!

}

После создания объекта IDirect3D8 мы должны создать еще что-то, на чем мы будем рисовать. Это "что-то" называется IDirect3DDevice8 и мы можем его создать с помощью метода IDirect3D8::CreateDevice(). В демо-проекте эта функция вызывается из C3DGraphic::Create() следующим образом:

D3DDISPLAYMODE theDisplayMode;

hr = m_p3DApplication->m_pDirect3DObject->GetAdapterDisplayMode(3DADAPTER_DEFAULT, &theDisplayMode);

if (FAILED(hr)) {

 return hr;

}

D3DPRESENT_PARAMETERS thePresentParams;

ZeroMemory(&thePresentParams, sizeof(thePresentParams));

thePresentParams.Windowed = TRUE;

thePresentParams.SwapEffect = D3DSWAPEFFECT_DISCARD;

thePresentParams.BackBufferFormat = theDisplayMode.Format;

thePresentParams.EnableAutoDepthStencil = TRUE;

thePresentParams.AutoDepthStencilFormat = D3DFMT_D16;

hr = m_p3DApplication->m_pDirect3DObject->CreateDevice(

 D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_hwndRenderTarget,

D3DCREATE_SOFTWARE_VERTEXPROCESSING,

 &thePresentParams, &m_p3DDevice);

if (FAILED(hr)) {

 return hr;

}

Только что мы создали 3D устройство, задав при этом кучу параметров. Несколько комментариев и разъяснений, что есть что:

• 3D устройство было создано для видеоадаптера, используемого по умолчанию. Об этом говорит параметр D3DADAPTER_DEFAULT. Средний житель России имеет от 0 до 1 видеоадаптеров, так что особых проблем с этим параметром возникнуть не должно.

• Созданное устройство имеет один back-буфер, цветовой формат буфера такой же как у экрана.

• Устройство создано для использования в оконном режиме. Весь рендеринг будет направлен на окно m_hwndRenderTarget. Эта переменная соотвествует окну нашего вида C3DGraphFrame. Антиподом оконному режиму служит полноэкранный режим. Для работы с ним надо при создании устройства переменную Windowed установить в FALSE, а не в TRUE.

• Устройство имеет автоматически созданный depth-буфер, который иногда еще называют z-буфером. Формат z-буфера – 16 бит на точку. В наше время трудно (но, правда, можно) найти видеоадаптер, который не поддерживает такой формат z-буфера. Z-буфер используется вычислительным ядром Direct3D для хранения информации о текущей z-координате каждой точки картинной плоскости. В конечном счете это используется для удаления невидимых линий и поверхностей.

• 3D устройство должно использовать все возможности аппаратуры. Если какое-либо требуемое свойство не поддерживается, Direct3D попытается эмулировать его на программном уровне. Вы можете поменять тип устройства с D3DDEVTYPE_HAL на D3DDEVTYPE_REF. В этом случае все вычисления будут проводиться на программном уровне. Такая эмуляция является очень медленной, и не все на свете можно эмулировать.

• Обрабатываться вершины (vertexes) должны на программном уровне. Мы сделали этот выбор, указав значение D3DCREATE_SOFTWARE_VERTEXPROCESSING. Можно указать вместо этого D3DCREATE_MIXED_VERTEXPROCESSING или D3DCREATE_HARDWARE_VERTEXPROCESSING, но эти режимы поддерживаются далеко не всеми видеокартами.

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

Жизнь всегда была сложнее, чем хотелось бы программисту. Например, все было бы гораздо проще, если бы существовала некая функция ХочуЧтобыНарисовалсяГрафикФункции(). Но во-первых, по-русски функции называть нельзя, во-вторых, такой функции просто нет. Все, что умеет IDirect3DDevice8, это нарисовать некоторые примитивы, да и для этого надо проделать кучу подготовительной работы. Как минимум, вы должны разместить координаты примитивов в вертекс-буфер ("vertex buffer"). Полное обсуждение вертекс-буферов находится за пределами этой статьи и могу лишь сказать, что это некая абстракция простого блока памяти, предназначенного для хранения координат и свойств точек трехмерного пространства. Работа с буфером осуществляется через интерфейс IDirect3DVertexBuffer8. Вы может заблокировать вертекс-буфер, получив при этом указатель на область памяти. Разыменовав указатель, можно записать что-нибудь в буфер, не забыв потом его разблокировать. В демо-приложении вы можете увидеть как это делается.

Обычно перед рисованием чего-либо мы хотим очистить кадр, чтобы новый кадр не накладывался на предыдущий. Это делается вызовом метода IDirect3DDevice8::Clear(). Вы найдете это в функции C3DGraphic::ReRender():

hr = m_p3DDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, m_dwBackColor, f, 0);

if (FAILED(hr)) {

 return hr;

}

Мы здесь очищаем весь back-буфер, заполняя его цветом m_dwBackColor. Кроме этого, очищается z-буфер – он заполняется значением 1.0. 1.0 соответствует максимально дальней от наблюдателя плоскости (горизонт, грубо говоря), 0.0 – максимально ближней. Непосредственно рисование на 3D устройстве начинается с

m_p3DDevice->BeginScene();

а заканчивается строкой

m_p3DDevice->EndScene();

Все, что находится между этими вызовами символизирует анимацию очередного кадра. Обратите внимание на то, что мы постоянно употребляем термин "back-буфер". Совершенно верно! Все, что мы сейчас нарисовали, не видно на экране, оно существует пока только в памяти компьютера (не будем уточнять, в какой именно: системной или видео – очень тонкий вопрос). Для того, чтобы эти изменения перенеслись на экран монитора необходимо скопировать изображение из back-буфера на основную поверхность. Это делается вызовом функции IDirect3DDevice8::Present().

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

hr = m_p3DDevice->SetStreamSource(0, m_pDataVB, sizeof(GRAPH3DVERTEXSTRUCT));

if (FAILED(hr)) {

 return hr;

}

hr = m_p3DDevice->SetVertexShader(D3DFVF_GRAPH3DVERTEX);

if (FAILED(hr)) {

 return hr;

}

hr = m_p3DDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, m_dwElementsInVB - 2);

if (FAILED(hr)) {

 return hr;

}

Переменная m_pDataVB является членом класса C3DGraphic, она содержит указатель на интерфейс IDirect3DVertexBuffer8. В нашем случае содержимое вертекс-буфера представляет из себя массив структур GRAPH3DVERTEXSTRUCT:

typedef struct {

 FLOAT x, y, z;

 FLOAT nx, ny, nz;

} GRAPH3DVERTEXSTRUCT;

Здесь x, y и z – координаты точки, nx, ny, nz – компоненты нормали. Вектор нормали используется подсистемой Direct3D, отвечающей за освещение сцены. Чуть позже мы рассмотрим, как можно рассчитать эти компоненты. Перед вызовом функции DrawPrimitive() мы должны указать vertex shader и используемый поток данных. Выбор и установка потока данных производится с помощью функции SetStreamSorce(). Мы передаем ей номер устанавливаемого потока (0, если оспользуется только один поток), указатель на вертекс-буфер, из которого будут браться данные, и размер каждого элемента в потоке (то есть, sizeof(GRAPH3DVERTEXSTRUCT). Vertex shaders – новая возможность Direct3D. Это эдакая абстракция, символизирующая обработку вершин (вертексов). Грубо говоря, vertex shader обеспечивает перевод точки из трехмерного пространства модели в двумерную картинную плоскость. Вы можете написать на особом языке скрипт, обеспечивающий этот перевод, а можете использовать один из поддерживаемых стандартных механизмов, что мы и сделаем. Наш vertex shader D3DFVF_GRAPH3DVERTEX определен как D3DFVF_XYZ | D3DFVF_NORMAL. Это означает, что каждая точка характеризуется 6-ю числами. Первые 3 из них трактуются как координаты вершины, остальные – как компоненты нормали.

После установки необходимых потока данных и вертекс-шейдера мы можем вызвать метод DrawPrimitive(), который отображает данные из вертекс-буфера на плоскость back-буфера. Способ рендеринга данных выбирается первым параметром этого метода – он может быть одним из значений перечисляемого типа D3DPRIMITIVETYPE: D3DPT_POINTLIST, D3DPT_LINELIST, D3DPT_LINESTRIP, D3DPT_TRIANGLELIST, D3DPT_TRIANGLESTRIP или D3DPT_TRIANGLEFAN. Я решил, что наиболее подходящим способом для построения графика функции является использование D3DPT_TRIANGLESTRIP, поскольку этот способ требует относительно немного памяти для хранения данных о поверхности. Триангуляции области построения графика осуществляется как показано на следующем рисунке.

Рисунок: триангуляции

Все это работает следующим образом: вертекс-буфер содержит точки P1, P2, P3, P4 и так далее. Когда я вызываю функцию DrawPrimitive() с параметром D3DPT_TRIANGLESTRIP, Direct3D начинает отображать треугольники 1, 2, 3 и так далее. Треугольник 1 определяется точками P1, P2, P3, треугольник 2 – P2, P3, P4. Таким образом, N точек, находящихся в вертекс-буфере, соответствуют (N-2) треугольникам. Все очень хорошо, но есть и недостатки: все треугольники получаются связаны друг с другом. Вот почему четные ряды триангулируются слева направо, а нечетные – наоборот. Думаю, нет необходимости напоминать, что всякого рода нумерации у меня начинаются с нуля.

Реализация всего этого находится в методе C3DGraphic::RecalculateData(). Эта функция использует вспомогательный класс CGraphGrid, который обеспечивает построение сетки графика функции.

Direct 3D имеет довольно мощные средства для работы с освещением 3D-сцены. Поддерживается несколько различных типов источников света: параллельный (directional), точечный (point-source) и прожектор (spotlight). Параллельный свет не имеет источника – только направление. В качестве аналогии приведу солнце: все его лучи параллельны (простите, физики и астрономы!). Точечный свет и прожектор имеют вполне определенную точку, из которой исходят все лучи. Точечный свет испускается во все стороны, а прожектор имеет строго очерченный конус распространения лучей. Для получения более подробной информации можете обратиться к DirectX 8.0a SDK. Сейчас меня больше интересует другое. Есть одна проблема: все точки (vertexes), которые принимают участие в вычислении освещенности сцены должны включать вектор нормали. Определение нормали на самом деле очень просто, если Вы все еще помните курс школьной геометрии. Как это сделать? Есть, как минимум, 2 пути:

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

Во-вторых, мы можем рассчитать примерные координаты нормали исходя из координат точки, в которой определяется нормаль и координат соседних с ней точек. Пусть это лишь приближенное решение: его вполне достаточно для наших целей. К тому же оно зато абсолютно не зависит от самой функции. Именно этот подход реализован в демо-приложении и Вы можете найти его в функции C3DGraphic::CalcNormal(). Попробую прокомментировать сам алгоритм.

Рисунок: расчет нормали

– Находим 4 вектора к соседним точкам:

V01 = P1 – P0;

V02 = P2 – P0;

V03 = P3 – P0;

V04 = P4 – P0;

– Находим 4 нормали к каждой из треугольных граней. Нормали находятся как векторное произведение соответствующих векторов.

N1 = [V02, V01];

N2 = [V03, V02];

N3 = [V04, V03];

N4 = [V01, V04];

– Искомая нормаль определяется как средний вектор четырех ранее найденных нормалей.

N = (N1 + N2 + N3 + N4) / 4;

Все в этом мире имеет цвет. Цвет определяет восприятие нами окружающего мира. Яблоко – красное, небо – синее и так далее. Для обозначения свойств поверхности объектов Direct3D использует термин "материал". Свойства материала описываются структурой D3DMATERIAL8:

typedef struct _D3DMATERIAL8 {

 D3DCOLORVALUE Diffuse;

 D3DCOLORVALUE Ambient;

 D3DCOLORVALUE Specular;

 D3DCOLORVALUE Emissive;

 float         Power;

} D3DMATERIAL8;

Переменные Diffuse, Ambient и Specular определяют, как данный материал отражает соответствующие компоненты источников света. Кроме того, Вы можете указать мощность, с которой отражается зеркальная (specular) составляющая света – это определяет вид бликов на объектах. Ненулевая излучательная (emissive) компонента заставляет объект светится, но помните, что свет, излученный объектом, никак не отражается прочими объектами сцены. Только источники света имеют право освещать кого-либо.

Для установки свойств материала объекта Вы должны вызвать функцию SetMaterial() перед вызовом DrawPrimitive() или любой другой функции рендеринга. Делается это, например, вот так:

hr = m_p3DDevice->SetMaterial(&m_theGraphMaterial);

ATLASSERT(SUCCEEDED(hr));

if (FAILED(hr)) {

 return hr;

}

За подробностями обращайтесь к исходному коду моего проекта. Экспериментируйте, меняйте параметры, пишите, если что-то непонятно.

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

• Material properties. Это окошко позволяет изменить свойства материала поверхности функции: диффузионную (diffuse), окружающую (ambient), излучательную (emissive) и зеркальную (specular) компоненты, а также мощность отражения (specular power).

• Light properties. Сцена освещена одним параллельным источником света. Вы можете изменить любую из составляющих спектра света. Кроме того, можно скорректировать направление света.

• Background color. Это всего-навсего цвет, используемый для очистки каждого нового кадра. Вы можете выбрать любой цвет фона по Вашему усмотрению.

• Function type. Вы можете выбрать одну из трех функций: Splash-функцию, плоскость или параболоид.

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

ПРИМЕЧАНИЕ

DirectX, Direct3D, Windows, Microsoft являются торговыми марками компании Microsoft. Все права защищены. OpenGL является торговой маркой фирмы Silicon Graphics Inc. Все права защищены.

Автор: Александр Шаргин

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

POINT pt;

GetCursorPos(&pt);

HMENU hMenu;

hMenu = LoadMenu(hInstance, MAKEINTRESOURCE(_MENU1));

TrackPopupMenu(hMenu, 0, pt.x, pt.y, 0, hWnd, NULL);

DestroyMenu(hMenu);

В чём же здесь ошибка? Дело в том, что в Windows существует два совершенно разных вида меню – полоска меню (menu bar), которая традиционно размещается под заголовком окна, и всплывающее меню (popup menu). Работа и с тем, и с другим осуществляется с помощью хэндла типа HMENU. Это вносит некоторую путаницу, так как функции, предназначенные для работы с всплывающим меню, не могут работать с полоской меню, и наоборот.

Дескриптор всплывающего меню возвращают всего две функции – CreatePopupMenu и GetSubMenu. Именно эти функции можно использовать совместно с TrackPopupMenu(Ex). С другой стороны, функция LoadMenu загружает из ресурсов полоску меню, что и приводит к ошибке.

Описание и примеры использования функций CreatePopupMenu и GetSubMenu можно найти в статье "Как отобразить контекстное меню?".

What two rectangular regions does Windows use to derive a scaling factor and an orientation?

1. Viewport and quadrant

2. Window and frame

3. Frame and viewport

4. Quadrant and frame

5. Window and viewport 

Верный ответ – 5. Window and viewport. Именно они используются в Windows для определения координат точек и коэффициента масштабирования. 

Это все на сегодня. Пока! 

(Алекс Jenter jenter@rsdn.ru) (Duisburg, 2001. Публикуемые в рассылке материалы принадлежат сайту RSDN.)