3d ландшафт, directx, исходник


Простая трехмерная графика для игр DirectX Basic 3D graphics for DirectX games

Здесь мы покажем, как использовать программирование в DirectX для реализации базовых принципов трехмерной графики. We show how to use DirectX programming to implement the fundamental concepts of 3D graphics.

Цель: Узнайте, как программировать приложения трехмерной графики. Objective: Learn to program a 3D graphics app.

предварительные требования Prerequisites

Предполагается, что вы знакомы с C++. We assume that you are familiar with C++. Также вы должны быть знакомы с основными принципами программирования графики. You also need basic experience with graphics programming concepts.

Общее время: 30 минут. Total time to complete: 30 minutes.

Дополнительные ресурсы Where to go from here

Здесь мы говорим о разработке трехмерной графики с DirectX и C++\Cx. Here, we talk about how to develop 3D graphics with DirectX and C++\Cx. В этом учебнике, который состоит из пяти частей, представлен обзор API Direct3D, а также концепции и код, используемые во многих других примерах с DirectX. This five-part tutorial introduces you to the Direct3D API and the concepts and code that are also used in many of the other DirectX samples. В учебнике последовательно описываются различные аспекты от настройки DirectX для приложения UWP на языке C++ до создания текстуры примитивов и добавления эффектов. These parts build upon each other, from configuring DirectX for your UWP C++ app to texturing primitives and adding effects.

Примечание этот учебник использует правостороннюю систему координат с векторами столбца. Note This tutorial uses a right-handed coordinate system with column vectors. Во многих примерах и приложениях DirectX применяется левая система координат с векторами строк. Many DirectX samples and apps use a left-handed coordinate system with row vectors. Чтобы получить более полное графическое математическое решение, поддерживающее левую систему координат с векторами строк, попробуйте воспользоваться DirectXMath. For a more complete graphics math solution and one that supports a left-handed coordinate system with row vectors, consider using DirectXMath. Дополнительные сведения см. в разделе Использование DirectXMath с Direct3D. For more info, see Using DirectXMath with Direct3D.

Здесь показаны следующие действия: We show you how to:

  • инициализация интерфейсов Direct3D с использованием среды выполнения Windows; Initialize Direct3D interfaces by using the Windows Runtime
  • применение операций вершинного шейдера; Apply per-vertex shader operations
  • настройка геометрии; Set up the geometry
  • растеризация сцены (сжатие трехмерной сцены в двухмерную проекцию); Rasterize the scene (flattening the 3D scene to a 2D projection)
  • удаление скрытых поверхностей; Cull the hidden surfaces

Примечание Note

Затем мы создадим устройство Direct3D, цепочку буферов и представление однобуферной обработки и выведем сформированное изображение на экран. Next, we create a Direct3D device, swap chain, and render-target view, and present the rendered image to the display.

3d ландшафт, directx, исходник

Издательство: КУДИЦ-Образ, 2006 г.
Страниц 368, мягкая обложка
ISBN 5-9579-0090-7, 1-58450-204-5

ИНФОРМАЦИЯ ОТ ИЗДАТЕЛЯ:

Хотите ли вы создать свою игру в жанре стратегии в реальном времени или симулятор земной поверхности – данная книга будет вам верным помощником. А может быть, вы хотите превзойти в терраморфинге создателей «Периметра»? Тогда эта книга может стать для вас отправной точкой в нелегком пути. Шаг за шагом вы будете изучать построение ландшафтного движка с использованием DirectX 9 и С++.

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

К книге бесплатно прилагается CD-диск. На нем вы найдете все файлы, необходимые для завершения создания движка, плюс примеры графики, 3D-моделей и Microsoft Direct 9 SDK.

Основы трехмерной графики
DirectX 9.0 и D3DX: Первые шаги
Основные 3D-объекты
Язык описания шейдеров HLSL
Обзор движка Gaia

Введение в системы ландшафтного синтеза
Управление миром
Основы ландшафтной геометрии
Ландшафтная система ROAM
Методы мозаичной геометрии
Методы текстуризации


Дальнейшее развитие движка
Страна высокого неба
Рендеринг сцен на открытом пространстве
3D-садовник
Океанские воды
Служебные классы Gaia
Секреты плавающей запятой
Руководство программиста
Рекомендуемая литература
Обзор компакт-диска

3d ландшафт, directx, исходник

Контакты: о проблемах с регистрацией, почтой и по другим вопросам пишите сюда — alarforum@yandex.ru, проверяйте папку спам! Обязательно пройдите активизацию e-mail.

Форум программистов > разработка игр, графический дизайн и моделирование > Gamedev — cоздание игр: Unity, OpenGL, DirectX
Direct3D: создание карт и ландшафтов
Регистрация
Поиск по форуму
Расширенный поиск
К странице.

Здесь нужно купить рекламу за 25 тыс руб в месяц! ) пишите сюда — alarforum@yandex.ru

1. Предположим, есть набор изображений, объединенных в один цельный BMP, каждый из которых является изображением какого-то типа поверхности.
Как считать из BMP отдельный кусок с заданными координатами?

2. Как в Direct3D составить двухмерное изображение, составленное из отдельных bmp? (т.е что то типа карты) Как создать плоскость карты и наложить на отдельную ее часть с заданными координатами текстуру из bmp? Какой должна быть матрица мира, вида и проекции для 2d в 3d? Каким должно быть освещение?

3. Как создать 3D ландшафт? Это делается в 3ds max? Каким образом?

4. Если есть реальный код или ссылки на диски к книгам, посвященным DirectX то было бы здорово. Книги без дисков с примерами не помогают. Я читал несколько книг, но авторы не пишут полный код в книгах. Примеры же из DirectX SDK содержат много «левого» для новичка кода, что затрудняет понимание.

Трехмерный ландшафт

Трехмерный ландшафт

Пример создания трехмерного ландшафта. Версия под Windows работает c DirectX, а DOS версия работает используя стандарт VESA. Пример показывает как работать с видео напрямую.

Использует свои процедуры отрисовки графических примитивов (Точек и треугольников). Легко адаптируется под любую ОС.

Совсем перспективная проекция

Обратная сторона «Луны»

(*) У DirectX версии в исходных текстах есть ошибка — при инициализации DirectX’а не обнуляется какая-то структура, из-за этого иногда программа может не работать :).

Разработка трехмерных игр для Windows 8 с помощью C++ и Microsoft DirectX


Разработка игр — постоянно актуальная тема: всем нравится играть в игры, их охотно покупают, поэтому их выгодно продавать. Но при разработке хороших игр следует обращать немало внимания на производительность. Никому не понравится игра, «тормозящая» или работающая рывками даже на не самых мощных устройствах.
В этой статье я покажу, как разработать простую футбольную 3D игру с использованием Microsoft DirectX и C++, хотя главным образом я занимаюсь разработкой на C#. В прошлом я довольно много работал с C++, но теперь этот язык для меня уже не столь прост. Кроме того, DirectX для меня является новинкой, поэтому эту статью можно считать точкой зрения новичка на разработку игр. Прошу опытных разработчиков простить меня за возможные ошибки.

Мы будем использовать пакет Microsoft Visual Studio 3D Starter Kit — естественный начальный ресурс для всех желающих разрабатывать игры для Windows 8.1.

Microsoft Visual Studio 3D Starter Kit

После загрузки пакета Starter Kit можно распаковать его в папку и открыть файл StarterKit.sln. В этом решении есть уже готовый проект C++ для Windows 8.1. При его запуске появится изображение, похожее на рис. 1.

Рисунок 1. Начальное состояние Microsoft Visual Studio 3D Starter Kit

Эта программа в составе Starter Kit демонстрирует несколько полезных элементов.

  • Анимировано пять объектов: четыре фигуры вращаются вокруг чайника, а чайник, в свою очередь, «танцует».
  • Каждый предмет сделан из отдельного материала; некоторые имеют сплошной цвет, а поверхность куба представляет собой растровый рисунок.
  • Источник света находится в верхнем левом углу сцены.
  • В правом нижнем углу экрана расположен счетчик кадровой скорости (количество кадров в секунду).
  • Сверху находится индикатор очков.
  • Если щелкнуть какой-либо предмет, он выделяется и увеличивается количество очков.
  • Если щелкнуть экран игры правой кнопкой мыши или провести по экрану от нижнего края к середине, появятся две кнопки для последовательного переключения цвета чайника.

Основной цикл игры находится в файле StarterKitMain.cpp, где отрисовывается страница и счетчик кадровой скорости. Game.cpp содержит игровой цикл и проверку нажатий. В этом файле в методе Update вычисляется анимация, а в методе Render происходит отрисовка всех объектов. Счетчик кадровой скорости отрисовывается в SampleFpsTextRenderer.cpp. Объекты игры находятся в папке Assets. Teapot.fbx — это чайник, а файл GameLevel.fbx содержит четыре фигуры, которые вращаются вокруг танцующего чайника.
Теперь, ознакомившись с образцом приложения в пакете Starter Kit, можно перейти к созданию собственной игры.

Добавление ресурсов в игру

Мы разрабатываем игру в футбол, поэтому самым первым нашим ресурсом должен быть футбольный мяч, который мы добавим в Gamelevel.fbx. Сначала нужно удалить из этого файла четыре фигуры, выделив каждую из них и нажав кнопку Delete. В обозревателе решений удалите и файл CubeUVImage.png, поскольку он нам не нужен: это текстура для куба, который мы только что удалили.
Теперь добавляем сферу в модель. Откройте инструменты (если их не видно, щелкните View > Toolbox) и дважды щелкните сферу, чтобы добавить ее в модель. Нам также требуется растянутая текстура, такая как на рис. 2.

Рисунок 2. Текстура футбольного мяча, приспособленная к сфере

Если вы не хотите создавать собственные модели в Visual Studio, можно найти готовые модели в Интернете. Visual Studio поддерживает любые модели в формате FBX, DAE и OBJ: достаточно добавить их в состав ресурсов решения. Например, можно использовать файл .obj, подобный показанному на рис. 3 (бесплатная модель с сайта TurboSquid).

Рисунок 3. Трехмерная OBJ-модель мяча

Анимация модели

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

Движение мяча

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

Добавление физики мяча

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

Добавление футбольного поля

При этом изменении преобразование применяется только к мячу. Поле отрисовывается без преобразования. Если запустить код сейчас, вы увидите, что мяч отскакивает от поля, но «проваливается» в него в нижней части. Для исправления этой ошибки нужно перенести поле на -0,5 по оси Y. Выберите поле и измените его перенос по оси Y на -0,5. Теперь при запуске приложения мяч будет отскакивать от поля, как на рис. 4.

Рисунок 4. Мяч отскакивает от поля


Задание положения камеры и мяча

Мяч расположен в центре поля, но нам он там не нужен. В этой игре мяч должен находиться на 11-метровой отметке. Следует переместить мяч по оси X, изменив перемещение мяча в методе Render в Game.cpp:

Мяч перемещается на 63 единицы по оси X, то есть устанавливается на 11-метровую отметку. После этого изменения вы перестанете видеть мяч, поскольку он вне поля зрения камеры: камера установлена в центре поля и направлена на середину. Нужно изменить положение камеры, чтобы она была направлена на линию ворот. Это нужно сделать в CreateWindowSizeDependentResources в файле Game.cpp:

Теперь камера находится между отметкой середины поля и 11-метровой отметкой и направлена в сторону линии ворот. Новое представление показано на рис. 5.

Рисунок 5. Измененное положение мяча и новое положение камеры

Добавление штанги ворот

Это изменение применяет преобразование к воротам и отрисовывает их. Это преобразование является сочетанием трех преобразований: масштабированием (увеличение исходного размера в 2 раза), поворотом на 90 градусов и перемещением на 85,5 единиц по оси X и на -0,5 единиц по оси Y из-за глубины поля. После этого ворота устанавливаются лицом к полю на линии ворот. Обратите внимание, что важен порядок преобразований: если применить вращение после перемещения, то ворота будут отрисованы совсем в другом месте, и вы их не увидите.

Удар по мячу

Все элементы установлены на свои места, но мяч все еще подпрыгивает. Пора по нему ударить. Для этого нужно снова применить физические навыки. Удар по мячу выглядит примерно так, как показано на рис. 6.

Рисунок 6. Схема удара по мячу

Удар по мячу осуществляется с начальной скоростью v под углом α (если не помните школьные уроки физики, поиграйте немного в Angry Birds, чтобы увидеть этот принцип в действии). Движение мяча можно разложить на два разных движения: по горизонтали — это движение с постоянной скоростью (исходим из того, что отсутствует сопротивление воздуха и воздействие ветра), а также вертикальное движение — такое же, как мы использовали раньше. Уравнение движения по горизонтали:
sX = s + v*cos(α)*t
Уравнение движения по вертикали:
sY = s + v*sin(α)*t — 1/2*g*t 2
Таким образом, у нас два перемещения: одно по оси X, другое по оси Y. Если удар нанесен под углом 45 градусов, то cos(α) = sin(α) = sqrt(2)/2, поэтому v*cos(α) = v*sin(a)*t. Нужно, чтобы мяч попал в ворота, поэтому дальность удара должна превышать 86 единиц (расстояние до линии ворот равно 85,5). Нужно, чтобы полет мяча занимал 2 секунды. При подстановке этих значений в первое уравнение получим:
86 = 63 + v* cos(α) * 2 >= v* cos(α) = 23/2 = 11,5
Если заменить значения в уравнении, то уравнение перемещения по оси Y будет таким:
sY = 0 + 11,5*t-5*t 2
А по оси X — таким:
sX = 63 + 11,5*t
Уравнение для оси Y дает нам время, когда мяч снова ударится о землю. Для этого нужно решить квадратное уравнение (да, я понимаю, что вы надеялись навсегда распрощаться с ними после школьного курса алгебры, но тем не менее вот оно):
(-b ± sqrt(b 0 — 4*a*c))/2*a >= (-11,5 ± sqrt(11,52 — 4 * -5 * 0)/2 * -5 >= 0 или 23/10 >= 2,3 с
Этими уравнениями можно заменить перемещение для мяча. Сначала в Game.h создайте переменные для сохранения перемещения по трем осям:
float m_translationX, m_translationY, m_translationZ;
Затем в методе Update в Game.cpp добавьте уравнения:

Метод Render использует эти новые перемещения:
rotation *= XMMatrixTranslation(m_translationX, m_translationY, 0);
Если запустить программу сейчас, вы увидите, как мяч влетает в середину ворот. Если нужно, чтобы мяч двигался в других направлениях, нужно добавить горизонтальный угол удара. Для этого мы используем перемещение по оси Z.
Расстояние от 11-метровой отметки до ворот составляет 22,5 единицы, а расстояние между штангами ворот — 14 единиц. Это дает нам угол α = atan(7/22.5), то есть 17 градусов. Можно вычислить и перемещение по оси Z, но можно сделать и проще: мяч должен переместиться до линии в тот же момент, когда он достигнет штанги. Это означает, что мяч должен переместиться на 7/22,5 единицы по оси Z и на 1 единицу по оси X. Уравнение для оси Z будет таким:
sz = 11,5 * t/3,2 ≥ sz = 3,6 * t

Это перемещение до штанги ворот. У любого перемещения с меньшей скоростью угол будет меньше. Чтобы мяч достиг ворот, скорость должна составлять от -3,6 (левая штанга) до 3,6 (правая штанга). Если учесть, что мяч должен полностью попасть в ворота, максимальное расстояние составляет 6/22,5, а скорость — от 3 до -3. Имея эти цифры, можно задать угол удара в методе Update:

Результат должен быть примерно таким, как на рис. 7.

Рисунок 7. Удар под углом

Добавление вратаря

Новое положение вратаря используется в методе Render файла Game.cpp, где вычисляется перемещение вратаря:
auto goalkeeperTransform = XMMatrixTranslation(85.65f, 1.40f, m_goalkeeperPosition);
Применив эти изменения, можно запустить игру: вы увидите, что вратарь движется вправо или влево при нажатии соответствующих клавиш со стрелками (см. рис. 8).

Рисунок 8. Игра с вратарем в нужном положении

До сих пор мяч двигался постоянно, но это нам не нужно. Мяч должен начинать движение непосредственно после удара и останавливаться при достижении ворот. Вратарь также не должен двигаться до удара по мячу.
Необходимо объявить частное поле m_isAnimating в файле Game.h, чтобы игра «знала», когда мяч движется:

Объявляем два частных поля в файле Game.h: m_isGoal и m_IsCaught. Эти поля говорят нам о том, что произошло: пользователь забил гол или вратарь поймал мяч. Если оба поля имеют значение false, мяч еще летит. Когда мяч достигает вратаря, программа вычисляет границы мяча и вратаря и определяет, налагаются ли границы мяча на границы вратаря. Если посмотрите в код, то увидите, что я добавил 7.0 f к каждой границе. Я сделал это, поскольку границы могут быть положительными или отрицательными, а это усложнит вычисление наложения. Добавив 7.0 f, я добился того, что все значения стали положительными, чтобы упростить вычисление. Если мяч пойман, его положение устанавливается по центру вратаря. m_isGoal и m_IsCaught сбрасываются при ударе.

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

Созданный ландшафт не будет отображаться в directX (С#)


Я искал рельеф с этим уравнением:

H (x, y) = (abs (sin (x * y)) + abs (sin (0,2 * x) + sin (0,4 * y)) + abs (cos (0,12 * x) + cos (0,47 * y))) * e ^ (0,005 * (x + y))

Теперь это дает мне сочетание особенностей и приятного склона. Это отлично работает, когда я рисую его с помощью scilab.

Я попытался импортировать это в приложение С#.

Рельеф создается в этом коде:

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

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

Теперь третий файл вызывает создание и отображение мира:

функции surf и box-somthing еще ничего не делают.

Все, что я получаю сейчас, это просто черное окно (часть device.clear(. )) — я попытался настроить камеру.. нет успеха

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

Создание 3D-ландшафтов в реальном времени с использованием C++ и DirectX

Хотите ли вы создать свою игру в жанре стратегии в реальном времени или симулятор земной поверхности — данная книга будет вам верным помощником. А может быть, вы хотите превзойти в терраморфинге создателей «Периметра»? Тогда эта книга может стать для вас отправной точкой в нелегком пути.

Шаг за шагом вы будете изучать построение ландшафтного движка с использованием DirectX 9 и C++. Вы узнаете, как применять пиксельные и вершинные шейдеры, а также о методиках текстурирования ландшафта, об имитации реалистичных гор, долин, неба, водных поверхностей. Создай свой собственный мир! К данной книге бесплатно прилагается CD-диск.

Книга 3D-ландшафты в реальном времени на С++ и DirectX 9 (+CD)

Хотите ли вы создать свою игру в жанре стратегии в реальном времени или симулятор земной поверхности — данная книга будет вам верным помощником. А может быть, вы хотите превзойти в терраморфинге создателей «Периметра»?Тогда эта книга может стать для вас отправной точкой в нелегком пути. Шаг за шагом вы будете изучать построение ландшафтного движка с использованием DirectX 9 и C++. Вы узнаете, как применять пиксельные и вершинные шейдеры, а также о методиках текстурирования ландшафта, об имитации реалистичных гор, долин, неба, водных поверхностей. Создай свой собственный мир!

3d ландшафт, directx, исходник

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

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

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

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


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

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

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

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

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

Добавление источников света. Как светильники в комнате, источники света Direct3D определяют не только освещенность сцены но и используемые цвета, а также особенности отображения света различными объектами.

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

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

LPDIRECT3DRM pD3D;
HRESULT result = Direct3DRMCreate(&pD3D);
if(result != D3DRM_OK)
<
//Обработка неудачного вызова
>

LPDIRECT3DRM — это указатель на главный Direct3D-объект, создаваемый в режиме последствия. В данном примере указатель получает имя pD3D. Адрес этого указателя передается функцией Direct3DRMCreate() в качестве единственного параметра. При успешном вызове функция Direct3DRMCreate() помещает адрес главного 3D-объекта в указатель pD3D. Чтобы гарантировать корректность указателя, нужно проверить возвращаемое функцией Direct3DRMCreate() значение — при успешном завершении работы функции оно должно быть равно D3DRM_OK.

Несмотря на то что размеры виртуального мира могут быть огромными, видимая часть этого виртуального мира будет ограничена для пользователя экраном или даже окном. Объект усечения, представляющий собой специальный Direct3D-объект связанный с окном, управляет представлением трехмерной сцены на экране. Так, например, в многооконной среде объект усечения следит за тем, чтобы данные, отображаемые в Direct3D-окне не воздействовали на другие области экрана, в частности окна других программ, частично или полностью закрывающих окно Direct3D-приложения. Создать объект усечения можно вызвав функцию DirectDrawCreateClipper():

LPDIRECTDRAWCLIPPER pClipper;
HRESUL result = DirectDrawCreateClipper(0, &pClipper, 0);
if(result != DD_OK)
<
//Обработка неудачной попытки.
>

LPDIRECTDRAWCLIPPER-это указатель на объект DIRECTDRAWCLIPPER. В данном случае указатель получает имя pClipper. Адрес указателя передается функции DirectDrawClipper() в качестве ее второго параметра. (Первый и третий параметры могут быть равны нулю) При успешном вызове функция помещает адрес объекта усечения в указатель pClipper. Чтобы гарантировать корректность содержимого указателя, нужно проверить значение, возвращаемое функцией, при успешном завершении функция возвращает значение равное DD_OK.

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

result = pClipper->SetHWnd(0, hWnd);
if(result != DD_OK)
<
//Обработка неудачной попытки.
>

В качестве первого параметра функции SetHWnd() передается нулевое значение, второй параметр представляет собой дескриптор окна. При успешном вызове эта функция возвращает значение DD_OK.

Объект усечения управляет отображением сцен на экране; однако непосредственное отображение выполняется Direct3D-устройством. Поэтому вам придется создать Direct3D-устройство. Сделать это можно вызвав функцию CreateDeviceFromClipper() главного 3D объекта.

RECT rect;
::GetClientRect(hWnd, &rect);
LPDIRECT3DRMDEVICE pDevice;
HRESULT result = pD3D->CreateDeviceFromClipper(pClipper, NULL, rect.right,
rect.bottom, &pDevice);
if(result != D3DRM_OK)
<
//Обработка неудачной попытки.
>

В данном примере перед тем, как вызвать функцию CreateDeviceFromClipper(), вызывается функция GetClientRect(). Это делается для того, чтобы выяснить размеры рабочей области окна, которые потребуются программе при создании устройства. LPDIRECT3DRMDEVICE- это указатель на объект DIRECT3DRMDTVICE. В данном случае этот указатель получает имя pDevice. Адрес указателя передается функции CreateDeviceFromClipper() в качестве пятого параметра. Назначение параметров функции CreateDeviceFromClipper() следующие.


Указатель на объект усечения.

GU >Ширина окна, для которого создается устройство.

Высота окна, для которого создается устройство.

Адрес указателя LPDIRECT3DRMDEVICE.

При успешном вызове функция CreateDeviceFromClipper() помещает адрес объекта устройства в указатель pDevice .При успешном вызове функция возвращает значение равное D3DRM_OK.

Для создания Direct3D устройства вы можете либо оставить предлагаемую по умолчанию модель равномерного закрашивания многоугольников, либо выбрать закрашивание по методу Гуро (Gouraud); оно дает более реалистичные результаты. При использовании равномерного закрашивания световые эффекты реализуются таким образом что на экране могут быть видны отдельные многоугольники ограничивающие трехмерную поверхность.

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

Как вы уже знаете сцена Direct3D состоит из множества объектов, каждый из которых размещается в своем кадре. Именно объект кадра определяет позицию и ориентацию включенного в сцену объекта. Все кадры, составляющие сцену, являются дочерними по отношению к корневому кадру. Ясно, что, прежде чем создавать дочерние кадры, нужно создать корневой кадр. Делается что с помощью вызова функции CreateFrame() главного Direct3D-объекта.

LPDIRECT3DRMFRAME pParentFrame;
HRESULT result = pD3D->CreateFrame(0, &pParentFrame);
if(result != D3DRM_OK)
<
//Обработка неудачной попытки.
>

LPDIRECT3DRMFRAME — это указатель на объект DIRECT3DRMFRAME. В данном примере указатель получает имя pParenFrame. Его адрем передается функции CreateFrame(); в качестве второго параметра. при успешном вызове функция помещает адрес объекта кадра в указатель pParentFrame и возвращает значение равное D3DRM_OK.

К этому моменту инициализация Direct3D в нашей программе закончена и программа готова к работе. Все что осталось сделать, — создать трехмерную сцену для отображения на экране (не думайте что это просто!). Включение в Direct3D сцену объект представляется сеткой, которая, в свою очередь, представляет собой группу соединенных вместе многоугольников задающих поверхность трехмерного объекта. Direct3D предлягает несколько способов построения сетки, представленного интерфейсом Direct3DRMMeshBuilder. Объект построителя сетки создается с помощью функции CreateMeshBuilder() главного Direct3D- объекта.

LPDIRECT3DRMMESHBUILDER pMeshBuilder;
HRESULT result = pD3D->CreateMeshBuilder(&pMeshBuilder);
if(result != D3DRM_OK)
<
//Обработка неудачной попытки.
>

LPDIRECT3DRMMESHBUILDER представляет собой указатель наобъект DIRECT3DRMMESHBUILDER. В данном случае указатель получает имя pMeshBuilder. Адрес этого указателя передается функции. При успешном вызове функции она помещает адрес объекта построителя сетки в указатель pMeshBuilder. Далее она должна вернуть занчение равнок D3DRM_OK.

Создав построитель сетки вы можете создать саму сетку. Для этого нужно вызвать функцию Load() объекта построителя сетки.

HRESULR result = pMeshBuilder->Load(fileName, NULL, D3DRMLOAD_FROMFILE, NULL, NULL);
if(result != D3DRM_OK)
<
//Обработка неудачной попытки.
>

Посколько в данном примере используется флаг D3DRMLOAD_FROMFILE, функция Load() ищет файл с именем fileName. Этот файл долже быть представлен в формете Х-файла, означающим тип файла создаваемого из объектов 3D Studio путем их преобразования из файлов *.3ds в файлы *.x утилитой CONV3DS которую вы можете найти на сервере http://www.rpc.agava.ru/ в разделе интсрументы. Если загрузка прошла успешно возвращается значение равное D3DRM_OK.

Создание кадров для сеток

Вы, наверное, еще помните, что все включенные в Direct3D-сцену объекты связываются с кадрами, определяющих ориентацию и позицию объекта. Это касается и сеток. Создав сетку, вы не сможете добавить её в свой трехмерный мир до тех пор, пока не поставите ей в соответствие некоторый кадр. Эта проблема решается с помощью ещё одног вызова функции CreateFrame():

LPDIRECT3DRMFRAME pFrame;
HRESULT result = pD3D->CreateFrame(pParentFrame, &pFrame);
if(result != D3DRM_OK)
<
//Обработка неудачной попытки.
>

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


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

Создание кадра порта просмотра

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

LPDIRECT3DRMFRAME pEye;
HRESULT result = pD3D->CreateFrame(pParentFrame, &pEye);
if(result != D3DRM_OK)
<
//Обработка неудачной попытки.
>

Здесь новый кадр указатель на который получает имя pEye , также создается как дочерний по отношению к кадру, определяемому указателем pParentFrame. После создания объекта кадра вызывается функция SetPosition(), с помощью которой устанавливается позиция внутри родительского кадра.

pEye->SetPosition(pParentFrame, D3DVALUE(0), D3DVALUE(0), D3DVALUE(-40.0));

Как видите, функции SetPosition() передается четыре параметра.

Указатель на родительское окно

Значение X-составляющей новой позиции.

Значение Y-составляющей новой позиции.

Значение Z-составляющей новой позиции.

Кадр можно сравнить с глазом. Перед позиционированием все объекты, включаемые в трехмерную сцену, сначала размещаются в самом центре трехмерного мира, т.е. в позиции 0,0,0 . Поэтому когда вы помещаете глаз в трехмерную сцену, он сначала оказывается внутри трехмерного объекта (представляемого объектом строителем сетки), который был расположен в той же позиции. Чтобы увидеть объект, нужно посмотреть на него со стороны, т.е. изменить точку зрения или проще отойти назад. Поэтому при вызове функции SetPosition() значение Z установлено равным -40. Отрицательные значения означают перемещение назад от сцены, а положительные вперед. Например, в нашем случае значение Z, равное -40, даёт возможность видеть объект, а при положительном эе значении объект бы расположился бы «за спиной» и остался бы невидимым.

Создание порта просмотра

Создав кадр порта вы получаете возможность создать и порт просмотра. Сделать это можно вызвав функцию CreateViewport() главного Direct3D объекта.

LPDIRECT3DVIEWPORT pViewport;
result = pD3D->CreateViewport (pDevice, pEye, 0,0,&pViewport);
if(result != D3DRM_OK)
<
//Обработка неудачной попытки.
>

LPDIRECT3DVIEWPORT- это указатель на объект DIRECT3DRMVIEWPORT. В данном случае указатель получает имя pViewport. Адрес этого указателя передаётся функции CreateViewport() в качестве одного из семи параметров

Указатель на объект устройства.

Указатель с деньгами.

X-составляющая позиция порта просмотра.


Y-составляющая позиции порта просмотра.

Адрес указателя на порт просмотра.

При успешном вызове функция помещает адрес объекта порта в указатель pViewport и возвращает значение равное D3DRM_OK.

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

Создание объекта источника

Первым шагом является создание объекта освещения. Делается это с помощью функции CreateLightRGB() главного Direct3D объекта.

LPDIRECT3DRMLIGHT pLight;
HRESULT result = pD3D->CreateLightRGB(D3DRMLIGHT_DIRECTIONAL, D3DVALUE(1.0), D3DVALUE(1.0),
D3DVALUE(1.0), &pLight);
if(result != D3DRM_OK)
<
//Обработка неудачной попытки.
>

LPDIRECT3DRMLIGHT — это указатель на объект DIRECT3DRMLIGHT. В данном примере указатель получает имя pLight. Параметры:

Флаг задающий тип создаваемого источника света.

Интенсивность красного компонента света

Интенсивность зеленного компонента света

Интенсивность синего компонента света.

Адрес указателя на объект

При успешном вызове функция CreateLightRGB() помещает адрес объекта источника в указатель pLight и возвращает значение равное D3DRM_OK.

Создание дочернего кадра освещения

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

LPDIRECT3DRMFRAME pLightFrame;
result = pD3D->CreateFrame(pParentFrame, &pLightFrame);
if(result != D3DRM_OK)
<
//Обработка неудачной попытки.
>


Чтобы включить в кадр освещение, необходимо вызвать функцию AddLight() кадра.

Наконец вы позиционируете источник света посредством вызова функции SetOrientation(), принадлежащей кадру.

pLightFrame->SetOrientation(pParenFrame, D3DVALUE(0.0), D3DVALUE(-1.0), D3DVALUE(1.0)
D3DVALUE(0.0), D3DVALUE(1.0), D3DVALUE(0.0));

Ниже приведен список параметров функции SetOrientation().

Указатель на родительский кадр.

X-составляющая вектора направления.

Y-составляющая вектора направления.

X-составляющая вектора высоты

Y-состовляющая вектора высоты

Z-состовляющая вектора высоты

Вектор направления представляет собой линию, указывающую распространение света. В функции SetOrientation() вектор направления указывает направление освещения, а вектор высоты задает высоту источника.

Материал взят из книги «Секреты программирования в windows 98» автора Велнум Клейтон.

Введение в программирование трехмерных игр с DirectX 9.0 — Луна Ф.

Название: Введение в программирование трехмерных игр с DirectX 9..

Автор: Луна Ф.

Книга «Введение в программирование трехмерных игр с DirectX 9.0» представляет собой введение в программирование интерактивной трехмерной компьютерной графики с использованием DirectX 9.0, в котором основное внимание уделяется разработке игр. Книга начинается с исследования необходимых математических инструментов и базовых концепций трехмерной графики. Другие темы охватывают как выполнение в Direct3D базовых операций, таких как рисование графических примитивов, освещение, наложение текстур, альфа-смешивание и работу с трафаретами, так и использование Direct3D для реализации техник, необходимых в играх. Главы посвященные вершинным и пиксельным шейдерам включают описание каркасов эффектов и нового высокоуровневого языка программирования шейдеров (HLSL).

Эта книга представляет собой введение в программирование интерактивной трехмерной компьютерной графики с использованием DirectX 9.0, в котором основное ударение делается на разработку игр. Прочитав ее, вы изучите основы Direct3D, после чего сможете перейти к изучению и применению более сложных технологий. Раз вы держите в руках эту книгу, у вас есть начальное представление о том, что представляет собой DirectX. С точки зрения разработчика DirectX — это набор API (интерфейсов программирования приложений) для разработки мультимедийных приложений на платформе Windows. В этой книге мы сосредоточимся на ограниченном подмножестве DirectX, называемом Direct3D. Как видно из названия, Direct3D — это API, используемый для разработки приложений с трехмерной графикой.
Книга разделена на четыре части. В первой части исследуются математические инструменты, применяемые в остальных частях книги. Во второй части объясняются базовые технологии трехмерной графики, такие как освещение, текстурирование, альфа-смешивание и работа с трафаретами. Третья часть посвящена использованию Direct3D для реализации различных более интересных техник и приложений, таких как выбор объектов, визуализация ландшафтов, системы частиц, настраиваемая виртуальная камера, а также загрузка и визуализация трехмерных моделей (X-файлов). Темой четвертой части являются вершинные и пиксельные шейдеры, включая каркасы эффектов и новый (появившийся в DirectX 9.0) высокоуровневый язык шейдеров. Настоящее и будущее трехмерных игр неразрывно связано с использованием шейдеров, и, посвящая им целую часть, мы хотели получить книгу, соответствующую современному состоянию дел в программировании графики.

Оглавление
Благодарности
Введение
Предпосылки
Необходимые средства разработки
Рекомендуемое оборудование
Для кого предназначена эта книга
Установка DirectX 9.0
Настройка среды разработки
Использование библиотеки D3DX
Использование документации и примеров из DirectX SDK
Соглашения об оформлении кода
Обработка ошибок
Ясность
Примеры программ и дополнительная поддержка
Часть I. Математическая подготовка
Векторы в трехмерном пространстве
Равенство векторов
Вычисление модуля вектора
Нормализация вектора
Сложение векторов
Вычитание векторов
Умножение вектора на скаляр
Скалярное произведение векторов
Векторное произведение
Матрицы
Равенство, умножение матрицы на скаляр и сложение матриц
Умножение матриц
Единичная матрица
Инвертирование матриц
Транспонирование матриц
Матрицы в библиотеке D3DX
Основные преобразования
Матрица перемещения
Матрицы вращения
Матрица масштабирования
Комбинирование преобразований
Некоторые функции для преобразования векторов
Плоскости
D3DXPLANE
Взаимное расположение точки и плоскости
Создание плоскостей
Нормализация плоскости
Преобразование плоскости
Точка плоскости, ближайшая к заданной
Лучи
Лучи
Пересечение луча и плоскости
Итоги
Часть II. Основы Direct3D
Глава 1. Инициализация Direct3D

1.1. Обзор Direct3D
1.1.1. Устройство REF
1.1.2. D3DDEVTYPE
1.2. COM
1.3. Предварительная подготовка
1.3.1. Поверхности
1.3.2. Множественная выборка
1.3.3. Формат пикселей
1.3.4. Пул памяти
1.3.5. Цепочка обмена и переключение страниц
1.3.6. Буфер глубины
1.3.7. Обработка вершин
1.3.8. Возможности устройств
1.4. Инициализация Direct3D
1.4.1. Запрос интерфейса IDirect3D9
1.4.2. Проверка поддержки аппаратной обработки вершин
1.4.3. Заполнение структуры D3DPRESENT_PARAMETERS
1.4.4. Создание интерфейса IDirect3DDevice9
1.5. Пример приложения: инициализация Direct3D
1.5.1. Файлы d3dUtility.h/cpp
1.5.2. Каркас примера
1.5.3. Приложение D3D Init
1.6. Итоги
Глава 2. Конвейер визуализации
2.1. Представление моделей
2.1.1. Форматы вершин
2.1.2. Треугольники
2.1.3. Индексы
2.2. Виртуальная камера
2.3. Конвейер визуализации
2.3.1. Локальное пространство
2.3.2. Мировое пространство
2.3.3. Пространство вида
2.3.4. Удаление невидимых поверхностей
2.3.5. Освещение
2.3.6. Отсечение
2.3.7. Проекция
2.3.8. Преобразование порта просмотра
2.3.9. Растеризация
2.4. Итоги
Глава 3. Рисование в Direct3D
3.1. Буферы вершин и индексов
3.1.1. Создание буферов вершин и индексов
3.1.2. Доступ к памяти буфера
3.1.3. Получение информации о буфере
3.2. Режимы визуализации
3.3. Подготовка к рисованию
3.4. Рисование с буферами вершин и индексов
3.4.1. IDirect3DDevice9::DrawPrimitive
3.4.2. IDirect3DDevice9::DrawIndexedPrimitive
3.4.3. Начало и завершение сцены
3.5. Геометрические объекты D3DX
3.6. Примеры приложений: треугольники, кубы, чайники, D3DXCreate*
3.7. Итоги
Глава 4. Цвет
4.1. Представление цвета
4.2. Цвета вершин
4.3. Затенение
4.4. Пример приложения: цветные треугольники
4.5. Итоги
Глава 5. Освещение
5.1. Компоненты света
5.2. Материалы
5.3. Нормали вершин
5.4. Источники света
5.5. Пример приложения: освещенная пирамида
5.6. Дополнительные примеры
5.7. Итоги
Глава 6. Текстурирование
6.1. Координаты текстур
6.2. Создание текстур и разрешение текстурирования
6.3. Фильтры
6.4. Детализируемые текстуры
6.4.1. Фильтр детализации текстур
6.4.2. Использование детализируемых текстур в Direct3D
6.5. Режимы адресации
6.6. Пример приложения: текстурированный квадрат
6.7. Итоги
Глава 7. Смешивание
7.1. Формулы смешивания
7.2. Коэффициеты смешивания
7.3. Прозрачность
7.3.1. Альфа-канал
7.3.2. Указание источника альфа-компоненты
7.4. Создание альфа-канала с помощью утилиты DirectX Texture Tool
7.5. Пример приложения: прозрачный чайник
7.6. Итоги
Глава 8. Трафареты
8.1. Использование буфера трафарета
8.1.1. Создание буфера трафарета
8.1.2. Проверка трафарета
8.1.3. Управление проверкой трафарета
8.1.3.1. Эталонное значение трафарета
8.1.3.2. Маска трафарета
8.1.3.3. Значение трафарета
8.1.3.4. Операция сравнения
8.1.4. Обновление буфера трафарета
8.1.5. Маска записи трафарета
8.2. Пример приложения: зеркала
8.2.1. Математика отражений
8.2.2. Обзор реализации отражений
8.2.3. Код и комментарии
8.2.3.1. Часть I
8.2.3.2. Часть II
8.2.3.3. Часть III
8.2.3.4. Часть IV
8.2.3.5. Часть V
8.3. Пример приложения: плоская тень
8.3.1. Тени от параллельного источника света
8.3.2. Тени от точечного источника света
8.3.3. Матрица тени
8.3.4. Использование буфера трафарета для предотвращения двойного смешивания
8.3.5. Код и комментарии
8.4. Итоги
Часть III. Применение Direct3D
Глава 9. Шрифты

9.1. ID3DXFont
9.1.1. Создание ID3DXFont
9.1.2. Рисование текста
9.1.3. Вычисление частоты кадров
9.2. CD3DFont
9.2.1. Создание экземпляра CD3DFont
9.2.2. Рисование текста
9.2.3. Очистка
9.3. D3DXCreateText
9.4. Итоги
Глава 10. Сетки: часть I
10.1. Геометрия сетки
10.2. Подгруппы и буфер атрибутов
10.3. Рисование
10.4. Оптимизация
10.5. Таблица атрибутов
10.6. Данные о смежности
10.7. Клонирование
10.8. Создание сетки (D3DXCreateMeshFVF)
10.9. Пример приложения: создание и визуализация сетки
10.10. Итоги
Глава 11. Сетки: часть II
11.1. ID3DXBuffer
11.2. X-файлы
11.2.1. Загрузка X-файлов
11.2.2. Материалы в X-файле
11.2.3. Пример приложения: загрузка X-файла
11.2.4. Генерация нормалей вершин
11.3. Прогрессивные сетки
11.3.1. Создание прогессивной сетки
11.3.2. Веса атрибутов вершин
11.3.3. Методы ID3DXPMesh
11.3.4. Пример приложения: прогрессивная сетка
11.4. Ограничивающие объемы
11.4.1. Новые константы
11.4.2. Типы ограничивающих объемов
11.4.3. Пример приложения: ограничивающие объемы
11.5. Итоги
Глава 12. Построение гибкого класса камеры
12.1. Проектирование класса камеры
12.2. Детали реализации
12.2.1. Вычисление матрицы вида
12.2.1.1. Часть 1: Перемещение
12.2.1.2. Часть 2: Вращение
12.2.1.3. Комбинирование обеих частей
12.2.2. Вращение относительно произвольной оси
12.2.3. Наклон, рыскание и вращение
12.2.4. Ходьба, сдвиг и полет
12.3. Пример приложения: камера
12.4. Итоги
Глава 13. Основы визуализации ландшафтов
13.1. Карты высот
13.1.1. Создание карты высот
13.1.2. Загрузка файла RAW
13.1.2. Досуп к карте высот и ее модификация
13.2. Создание геометрии ландшафта
13.2.1. Вычисление вершин
13.2.2. Вычисление индексов — определение треугольников
13.3. Текстурирование
13.3.1. Процедурный подход
13.4. Освещение
13.4.1. Обзор
13.4.2. Вычисление затенения квадрата
13.4.3. Затенение ландшафта
13.5. «Ходьба» по ландшафту
13.6. Пример приложения: ландшафт
13.7. Возможные усовершенствования
13.8. Итоги
Глава 14. Системы частиц
14.1. Частицы и точечные спрайты
14.1.1. Формат структуры
14.1.2. Режимы визуализации точечных спрайтов
14.1.3. Частицы и их атрибуты
14.2. Компоненты системы частиц
14.2.1. Рисование системы частиц
14.2.2. Хаотичность
14.3. Примеры систем частиц: снег, фейерверк, след снаряда
14.3.1. Пример приложения: снег
14.3.2. Пример приложения: фейерверк
14.3.3. Пример приложения: след снаряда
14.4. Итоги
Глава 15. Выбор объектов
15.1. Преобразование из экранного пространства в окно проекции
15.2. Вычисление луча выбора
15.3. Преобразование лучей
15.4. Пересечение луча и объекта
15.5. Пример приложения: выбор объекта
15.6. Итоги
Часть IV. Шейдеры и эффекты
Глава 16. Введение в высокоуровневый язык шейдеров

16.1. Пишем шейдер на HLSL
16.1.1. Глобальные переменные
16.1.2. Входная и выходная структуры
16.1.3. Точка входа
16.2. Компиляция шейдеров на HLSL
16.2.1. Глобальные переменные
16.2.1.1. Получение дескриптора константы
16.2.1.2. Установка констант
16.2.1.3. Установка значений по умолчанию для констант
16.2.2. Компиляция HLSL-шейдера
16.3. Типы переменных
16.3.1. Скалярные типы
16.3.2. Векторные типы
16.3.3. Матричные типы
16.3.4. Массивы
16.3.5. Структуры
16.3.6. Ключевое слово typedef
16.3.7. Префиксы переменных
16.4. Ключевые слова, инструкции и приведение типов
16.4.1. Ключевые слова
16.4.2. Поток выполнения программы
16.4.3. Приведение типов
16.5. Операторы
16.6. Определяемые пользователем функции
16.7. Встроенные функции
16.8. Итоги
Глава 17. Знакомство с вершинными шейдерами
17.1. Объявление вершин
17.1.1. Описание объявления вершин
17.1.2. Создание объявления вершин
17.1.3. Разрешение использования объявлений вершин
17.2. Использование данных вершин
17.3. Этапы работы с вершинным шейдером
17.3.1. Написание и компиляция вершинного шейдера
17.3.2. Создание вершинного шейдера
17.3.3. Установка вершинного шейдера
17.3.4. Уничтожение вершинного шейдера
17.4. Пример приложения: рассеянный свет
17.5. Пример приложения: мультипликационная визуализация
17.5.1. Мультипликационное затенение
17.5.2. Код вершинного шейдера для мультипликационного затенения
17.5.3. Обводка силуэта
17.5.3.1. Представление краев
17.5.3.2. Проверка для краев силуэта
17.5.3.3. Генерация краев
17.5.4. Код вершинного шейдера обводки силуэта
17.6. Итоги
Глава 18. Знакомство с вершинными шейдерами
18.1. Основы мультитекстурирования
18.1.1. Разрешение работы с несколькими текстурами
18.1.2. Координаты для нескольких текстур
18.2. Входные и выходные данные пиксельного шейдера
18.3. Этапы работы с пиксельным шейдером
18.3.1. Написание и пиксельного вершинного шейдера
18.3.2. Создание пиксельного шейдера
18.3.3. Установка пиксельного шейдера
18.3.4. Уничтожение пиксельного шейдера
18.4. Объекты выборки в HLSL
18.5. Пример приложения: мультитекстурирование в пиксельном шейдере
18.6. Итоги
Глава 19. Каркас эффектов
19.1. Техники и проходы
19.2. Встроенные объекты HLSL
19.2.1. Объекты текстуры
19.2.2. Объекты выборки и режимы выборки
19.2.3. Объекты вершинных и пиксельных шейдеров
19.2.4. Строки
19.2.5. Аннотации
19.3. Состояния устройства в файле эффекта
19.4. Создание эффекта
19.5. Установка констант
19.6. Использование эффекта
19.6.1. Получение дескриптора эффекта
19.6.2. Активация эффекта
19.6.3. Начало эффекта
19.6.4. Установка текущего прохода визуализации
19.6.5. Завершение эффекта
19.6.6. Пример
19.7. Пример приложения: освещение и текстурирование в файле эффектов
19.8. Пример приложения: туман
19.9. Пример приложения: мультипликационный эффект
19.10. EffectEdit
19.11. Итоги
Приложение. Введение в программирование для Windows
Обзор
Ресурсы
События, сообщения, очередь сообщений и цикл обработки сообщений
GUI
Windows-приложение Hello World
Исследование программы Hello World
Включение файлов, глобальные переменные и прототипы
WinMain
WNDCLASS и регистрация
Создание и отображение окна
Цикл сообщений
Оконная процедура
Функция MessageBox
Улучшенный цикл сообщений
Итоги
Список литературы
Алфавитный указатель

Бесплатно скачать электронную книгу в удобном формате, смотреть и читать:
Скачать книгу Введение в программирование трехмерных игр с DirectX 9.0 — Луна Ф. — fileskachat.com, быстрое и бесплатное скачивание.

Скачать chm
Ниже можно купить эту книгу по лучшей цене со скидкой с доставкой по всей России. Купить эту книгу

Илон Маск рекомендует:  Настройки для разработки приложения на Firefox OS
Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL
07.08.2008, 18:21 #1