Двумерная графика с использованием Direct3D

Следующим шагом является получение текущих установок рабочего стола, а именно, какой формат пикселя (сколько битов отведено под каждую составляющую цвета) присутствует в данный момент. Для этого можно воспользоваться, вызвав метод GetAdapterDisplayMode главного объекта Direct3D. Примеры вызовов этого метода для языков C++ и Pascal приведены в следующей таблице:

D3DDISPLAYMODE display;
…
direct3d ->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, display );

var 
display: TD3DDisplayMode;
…
direct3d.GetAdapterDisplayMode( D3DADAPTER_DEFAULT, display );

У метода GetAdapterDisplayMode имеются два аргумента:

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

typedef struct _D3DDISPLAYMODE {
    UINT Width;
    UINT Height;
    UINT RefreshRate;
    D3DFORMAT Format;
} D3DDISPLAYMODE;

TD3DDisplayMode = packed record
    Width: LongWord;
    Height: LongWord;
    RefreshRate: LongWord;
    Format: TD3DFormat;
  end {_D3DDISPLAYMODE};

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

Следующий шаг – заполнение структуры D3DPRESENT_PARAMETERS, которая будет задавать параметры поверхности вывода (рендеринга). Для этого необходимо объявить вспомогательную переменную и заполнить ее поля, например, следующим образом:

D3DPRESENT_PARAMETERS params;
…
ZeroMemory( params, sizeof(params) );
params.Windowed = TRUE;
params.SwapEffect = D3DSWAPEFFECT_DISCARD;
params.BackBufferFormat = display.Format;
…

var
params: TD3DPresentParameters;
…
ZeroMemory( @params, SizeOf(params) );
params.Windowed := True;
params.SwapEffect := D3DSWAPEFFECT_DISCARD;
params.BackBufferFormat := display.Format;
…

Здесь приведены строки для минимального набора обязательных действий. Строка ZeroMemory(…) заполняет указанную в качестве первого параметра структуру нулями. Строка "params.Windowed := …" указывает, что вывод будет производиться в некоторое окно. Строка "params.SwapEffect := …" задает режим работы механизма двойной буферизации. И последняя строка "params.BackBufferFormat := …" указывает какой формат буфера будет использоваться.

Следующий шаг инициализационных действий состоит в создании устройства вывода. Это действие реализуется с помощью вызова метода CreateDevice главного объекта:

direct3d->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, 
hwnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, 
params,  device )

direct3d.CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, 
Handle, D3DCREATE_SOFTWARE_VERTEXPROCESSING, 
@params, device );

В результате вызова метода CreateDevice получаем ссылку на интерфейс IDirect3DDevice9, с помощью которого мы будем производить рендеринг сцены. Поясним значения параметров метода CreateDevice. Первый параметр (D3DADAPTER_DEFAULT) указывает номер адаптера, установленного в системе. Второй аргумент метода (D3DDEVTYPE_HAL) определяет тип устройства; значение D3DDEVTYPE_HAL - позволяет использовать аппаратное ускорение на 100%, D3DDEVTYPE_REF – указывает использовать только программные действия (ресурсы центрального процессора). Третий параметр позволяет задать окно (Handle), куда будет производиться вывод сцены. Четвертый аргумент (D3DCREATE_SOFTWARE_VERTEXPROCESSING) указывает, что обработка вершин сцены будет производиться по фиксированным заданным правилам (этот параметр следует указывать, если видеоадаптер не поддерживает архитектуру шейдеров). Предпоследний – пятый параметр хранит параметры создаваемого устройства вывода. И последний аргумент – это имя переменной, в которую при успешном вызове будет помещен результат работы метода.

Таким образом, схему работы библиотеки Direct3D можно представить так.

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

Первый параметр метода Clear обозначает количество прямоугольников для очистки области вывода (0 обозначает, что очистке подвергается вся область вывода). Второй параметр представляет собой указатель на массив, содержащий набор величин типа TRect. Каждая отдельная структура указывает, какое место в поверхности вывода следует очищать (значение NULL требует очистки всей поверхности отображения). Третий параметр обозначает что именно (какую поверхность) следует очищать. В данном случае очистке подвергается только поверхность вывода. Кроме этого, метод Clear может использоваться для очистки Z -буфера (константа D3DCLEAR_ZBUFFER ) и буфера трафарета (константа D3DCLEAR_STENCIL ). Четвертый параметр указывает, каким цветом следует заполнять поверхность рендеринга. D3DCOLOR_XRGB(Red,Green,Blue) возвращает цвет из трех составляющих – красного, зеленого и синего цветов. Значения параметров должны лежать в диапазоне [0,…,255]. Предпоследний параметр указывает значение, которым будет заполнен буфер глубины (Z-буфер). Значения этого параметра должны лежать в диапазоне [0.0,…,1.0], где 0 – соответствует ближайшей границе, 1 – дальней. Последний параметр метода задает значение для заполнения буфера шаблона ( Stencil буфера).

Следующий шаг процесса рендеринга – это непосредственный вывод содержимого заднего буфера (BackBuffer) в окно визуализации. Этот шаг еще называют переключением буферов, и осуществляется он с помощью метода Present интерфейса IDirect3DDevice9. Программный код с использованием этого метода выглядит следующим образом:

Интерес здесь представляет, как правило, только третий параметр. Если он равен нулю, то идентификатор окна, в который происходит вывод, берется из ранее установленного, при создании устройства. Все остальные параметры выставляют, как правило, в NULL. Таким образом, минимальный набор инструкций для процедуры рендеринга, состоит в вызове двух методов Clear и Present интерфейса IDirect3DDevice9.

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

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

direct3d = Direct3DCreate9( D3D_SDK_VERSION );
direct3d ->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, display );

ZeroMemory( params, sizeof(params) );
params.Windowed = TRUE;
params.SwapEffect = D3DSWAPEFFECT_DISCARD;
params.BackBufferFormat = display.Format;

direct3d->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, 
hwnd, D3DCREATE_HARDWARE_VERTEXPROCESSING, params,  device );

direct3d := Direct3DCreate9( D3D_SDK_VERSION );
direct3d.GetAdapterDisplayMode( D3DADAPTER_DEFAULT, display );

ZeroMemory( @params, SizeOf(params) );
params.Windowed := True;
params.SwapEffect := D3DSWAPEFFECT_DISCARD;
params.BackBufferFormat := display.Format;

direct3d.CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, 
Handle, D3DCREATE_SOFTWARE_VERTEXPROCESSING, @params, device );

Вывод простейших примитивов

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

struct MYVERTEX1
{
    FLOAT x, y, z, rhw;
    DWORD color;
};
MYVERTEX1 data1[100];

struct MYVERTEX2
{
    FLOAT x, y, z;
    FLOAT n1, n2, n3;
};
MYVERTEX2 data2[100];

MyVertex1 = packed record
    x, y, z, rhw: Single;
    color: DWORD;
end;

MyVertex2 = packed record
    x, y, z: Single;
    n1, n2, n3: Single;
end;

var 
      data1: array [0..99] of MyVertex1;
      data2: array [0..99] of MyVertex2;

Тем самым данные о вершинах будут храниться в массиве, и иметь строго определенный формат (тип). В процессе визуализации сцены необходимо указать графической библиотеке, что собой представляет одна вершина примитива. Это реализуется с помощью механизма флагов, называемого FVF ( Flexible Vertex Format – гибкий формат вершин). Существует порядка двух десятков флагов FVF для определения формата вершины. Самые распространенные и наиболее используемые флаги FVF для определения формата вершины представлены в следующей таблице:

Комбинация конкретных флагов дает возможность сообщить системе, с каким форматом (типом) вершин она имеет дело в данный момент времени. Так, например,

(D3DFVF_XYZ OR D3DFVF_NORMAL) – вершина содержит нормали и координаты, (D3DFVF_XYZRHW OR D3DFVF_DIFFUSE) - цветная преобразованная вершина, где OR – операция логического "или". Установка формата вершин осуществляется с помощью вызова метода SetFVF интерфейса IDirect3DDevice9. Программно это реализуется так:

#define MY_FVF (D3DFVF_XYZRHW|D3DFVF_DIFFUSE)
…
device->SetFVF(MY_FVF);

const MY_FVF = D3DFVF_XYZRHW or D3DFVF_DIFFUSE;
…
device.SetFVF(MY_FVF);

Следует особо остановиться на флаге D3DFVF_XYZRHW. Этот флаг позволяет описывать вершины, определенные на плоскости. Он служит для графической системы индикатором того, что построение сцены происходит на плоскости в координатах окна (формы) вывода. При этом формат вершины должен задаваться четверкой чисел x,y,z,w, две последних из которых, как правило, не используются, однако должны присутствовать при описании вершины.

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

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

DrawPrimitiveUP(
	  Тип выводимого примитива,
	  Количество примитивов,
	  Массив данных,
	  Размер "шага в байтах" от одной вершины до другой
)

Первый параметр указывает на тип выводимого примитива и задается одной из следующих констант: D3DPT_POINTLIST, D3DPT_LINELIST, D3DPT_LINESTRIP, D3DPT_TRIANGLELIST, D3DPT_TRIANGLESTRIP, D3DPT_TRIANGLEFAN. Второй аргумент задает количество выводимых примитивов. Третий параметр является указателем на область в памяти, где располагаются данные о вершинах (в нашем случае это заполненный массив). И последний параметр задает, сколько байтов отводится для хранения одной вершины.

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

struct MYVERTEX
{
    FLOAT x, y, z, rhw;
}data[100];

#define MY_FVF (D3DFVF_XYZRHW);

// заполнение массива data "случайными" точками …

// процедура вывода сцены
device->SetFVF(MY_FVF);
device->DrawPrimitiveUP( D3DPT_POINTLIST, 100, data, 
 sizeof(MYVERTEX) );

type
    MyVertex = packed record
        x, y, z, rhw: Single;
    end;

const
      MY_FVF = D3DFVF_XYZRHW;

var 
      data: array [0..99] of MyVertex;

// заполнение массива data "случайными" точками …

// процедура вывода сцены
device.SetFVF(MY_FVF);
device.DrawPrimitiveUP( D3DPT_POINTLIST, 100, data, 
 SizeOf(MyVertex) );

Остановимся теперь на процедуре непосредственного вывода результатов на экран. Процесс непосредственного воспроизведения примитивов рекомендуют обрамлять двумя действиями. Перед отображением необходимо вызвать метод BeginScene, а после воспроизведения – метод EndScene интерфейса IDirect3DDevice9. Первый метод информирует устройство вывода (видеокарту), что следует подготовиться к воспроизведению результатов. Второй метод сообщает устройству о том, что процесс воспроизведения для текущего кадра закончен и теперь можно осуществлять переключение буферов рендеринга. Таким образом, процедура воспроизведения сцены должна выглядеть приблизительно следующим образом:

VOID Render()
{
device->BeginScene();
device->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,0,0),
 1.0f, 0);
device->SetFVF(…);
device->DrawPrimitiveUP(…);
device->EndScene();
device->Present( NULL, NULL, NULL, NULL );
}

procedure Render;
begin
  device.BeginScene;
  device.Clear(0,nil,D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,0,0), 1.0,0);
  device.SetFVF(…);
  device.DrawPrimitiveUP(…);
  device.EndScene;
  device.Present(nil, nil, 0, nil);
end;

Рассмотрим оставшиеся типы примитивов, которые имеются в наличии у библиотеки Direct3D.

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

В предыдущих примерах фигурировали бинарные примитивы (белые фигуры на черном фоне). Чтобы окрасить примитивы нужно задать цвет каждой вершины примитива. Это проделывается в два этапа. Сначала мы должны изменить тип вершины, а затем добавить в комбинацию флагов FVF значение D3DFVF_DIFFUSE.

struct MYVERTEX
{
    FLOAT x, y, z, rhw;
    DWORD color;
}

#define MY_FVF (D3DFVF_XYZRHW|D3DFVF_DIFFUSE)

type
    MyVertex = packed record
        x, y, z, rhw: Single;
        color: DWORD;
    end;

const
      MY_FVF = D3DFVF_XYZRHW or D3DFVF_DIFFUSE;

Далее каждой вершине необходимо присвоить некоторый цвет. Это можно проделать с помощью макроса-функции D3DCOLOR_XRGB(r, g, b), где в качестве параметров передается тройка основных цветов (веса) – красного, зеленого и синего. При этом, код, отвечающий за визуализацию сцены, не претерпит никаких изменений.

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

С одной стороны данная триангуляция имеет 10 треугольников, каждый из которых содержит 3 вершины. Таким образом, для хранения 30 вершин при расходах 20 байт на каждую вершину, необходимо 600 байт машинной памяти. С другой стороны, можно хранить отдельно сами вершины и список номеров (индексов) вершин для каждого треугольника. В этом случае расходы на машинную память будут следующими: 9 вершин по 20 байт на каждую потребует 180 байт, 10 триплетов индексов вершин, например, по 2 байта на индекс потребуют 60 байт. Итого для такой организации хранения данных модели – в нашем случае триангуляции, необходимо 240 байт, что в два с половиной раза меньше чем при организации хранения вершин всех десяти треугольников. Использование дополнительного массива, который будет хранить только лишь номера вершин модели, позволит избежать повторения данных при задании вершин. Так, например, представленная триангуляция может быть описана следующим образом.

10 треугольников = { 1: (0,3,2), 2: (0,1,3), 3: (2,3,4), 4: (3,6,4), 5: (1,5,3), 6: (3,5,6), 7: (1,7,5), 8: (5,7,6), 9: (6,7,8), 10: (4,6,8) } = 2 байта/индекс* 3 индекса* 10 треугольников = 60 байт

Программно этот подход может быть реализован с помощью вызова метода DrawIndexedPrimitiveUP интерфейса IDirect3DDevice9, который имеет 8 параметров. Первый параметр задает тип выводимых примитивов и представляет собой одну константу из уже известного набора. Второй параметр определяет минимальный вершинный индекс и, как правило, он устанавливается в значение ноль. Третий параметр определяет количество вершин в модели. Четвертый параметр задает количество выводимых примитивов. Пятый аргумент метода представляет собой указатель на массив, содержащий набор индексов. Шестой аргумент определяет формат индексных данных и может принимать два значения: D3DFMT_INDEX16 и D3DFMT_INDEX32. Т.е. под один индекс может быть отведено либо 16, либо 32 бита машинной памяти. Предпоследний, седьмой аргумент метода представляет собой указатель на массив, содержащий набор вершин модели. И последний параметр определяет количество байтов, необходимых для хранения одной вершины. Таким образом, обобщив эти строки можно записать формат вызова данного метода:

DrawIndexedPrimitiveUP(
1. тип выводимых примитивов,
2. минимальный индекс вершин,
3. количество вершин,
4. количество выводимых примитивов,
5. указатель на массив индексов,
6. формат индексов,
7. указатель на массив вершин,
8. количество байтов для хранения одной вершины
)

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

struct MYVERTEX
{
    FLOAT x, y, z, rhw;
    DWORD color;
}

#define MY_FVF (D3DFVF_XYZRHW|D3DFVF_DIFFUSE)

WORD indices[] = {0,3,2, 0,1,3, 2,3,4, 3,6,4, 1,5,3, 3,5,6, 
1,7,5, 5,7,6, 6,7,8, 4,6,8};

MYVERTEX points[] = 
{
    { 119, 354, 0, 0, D3DCOLOR_XRGB(255,0,0) },
    {  47, 248, 0, 0, D3DCOLOR_XRGB(0,255,0) },
    …
}
…
device-> DrawIndexedPrimitiveUP(D3DPT_TRIANGLELIST, 0, 9, 10, 
indices, D3DFMT_INDEX16, points, sizeof(MYVERTEX) );

type
    MyVertex = packed record
        x, y, z, rhw: Single;
        color: DWORD;
    end;

const
      MY_FVF = D3DFVF_XYZRHW or D3DFVF_DIFFUSE;
      indices: array [0..29] of Word =
      (0,3,2, 0,1,3, 2,3,4, 3,6,4, 1,5,3, 3,5,6, 
1,7,5, 5,7,6, 6,7,8, 4,6,8);

var points : array [0..8] of MyVertex;
…
  points[0].x := 119;
  points[0].y := 354;
  points[0].color := D3DCOLOR_XRGB(255,0,0);
…

device.DrawIndexedPrimitiveUP(D3DPT_TRIANGLELIST, 0, 9, 10, 
indices, D3DFMT_INDEX16, points, SizeOf(MyVertex));

Результат построения триангуляции "с цветом" показан на следующем рисунке.

Вообще говоря, функции вывода примитивов DrawPrimitiveUP и DrawIndexedPrimitiveUP являются довольно медленными с эффективной точки зрения, т.к. производят довольно много лишних операций. Для хранения вершин мы использовали обычные переменные (в нашем случае массивы), хотя для таких ситуаций предназначен специальный буфер вершин. Чтобы начать работы с этим буфером вершин необходимо проделать следующие шаги:

LPDIRECT3DVERTEXBUFFER9     VBuffer     = NULL;
VOID* pBuff;
…
device->CreateVertexBuffer(sizeof(points), 0, MY_FVF,
                 D3DPOOL_DEFAULT, VBuffer, NULL );
VBuffer->Lock( 0, sizeof(points), (void**)pBuff, 0 );
memcpy( pBuff, points, sizeof(points) );
VBuffer-> Unlock();

var VBuffer: IDirect3DVertexBuffer9;
      pBuff: Pointer;
…
device.CreateVertexBuffer(SizeOf(points), 0, MY_FVF,  
                  D3DPOOL_DEFAULT, VBuffer, nil);
VBuffer.Lock(0, SizeOf(points), pBuff, 0);
Move( points, pBuff^, SizeOf(points) );
VBuffer.Unlock;

device->SetStreamSource( 0, VBuffer, 0, sizeof(MYVERTEX) );
device->SetFVF( MY_FVF );
device->DrawPrimitive( D3DPT_TRIANGLELIST , 0, 1 );

device.SetStreamSource(0, VBuffer, 0, SizeOf(MyVertex));
device.SetFVF(MY_FVF);
device.DrawPrimitive(D3DPT_TRIANGLELIST, 0, 1);

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

Кроме того, сплошная модель вывода подразделяется на два вида закрашивания: плоское заполнение либо закрашивание с интерполяцией. Первое реализуется через вызов метода SetRenderState(D3DRS_SHADEMODE, D3DSHADE_FLAT), второе через SetRenderState(D3DRS_SHADEMODE, D3DSHADE_ GOURAUD).

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