Как и при любом другом кодинге, Delphi намного облегчает программирование в DirectX. При этом размер файла значительно увеличивается, что для маленьких Intro и презентаций очень важно. Поэтому мы не будем идти простым путем, а будем создавать маленькие приложения без использования преимуществ Delphi, зато с использованием всей убогости WinAPI.
Я отказался от визуальности не только из-за большого размера получаемых файлов. Для этого было еще несколько причие:
1. Чтобы показать тебе внутренности любой программы. Так ты сможешь понять процесс выполнения прог и узнать, как работают внутренности твоих любимых окошек.
2. Такой код легко будет перенести на другой язык (С++ или ASM).
3. Так можно показать любителям VC++, что Delphi способен не только на инет и базы данных, но и на крутую графику.
Немного истории
Давным-давно, маленькая и почти никому неизвестная компания Microsoft создала Windows. Все было прекрасно и в нем вроде бы удобно было работать. Но окна абсолютно не были предназначены для игр, а так хотелось получить в свои лапы деньги игрунов. Интерфейс Windows построенный на GDI был тормознутым и ускорить его никак не удавалось.
И вот программеры маленькой компании решили, а почему бы ни создать такую библиотеку, которая могла бы давать определенным приложениям все ресурсы компа и наивысшие привилегии? Сказано - сделано, так и появился DirectX. Но он появился не с нуля, ведь программеры маленькой компании слишком слабенькие, чтобы написать такое самостоятельно :). Зато директор богатый :), который просто купил еще более маленькую компанию уже создавшую нечто подобное.
Но библиотека все равно была слабой, потому что сам Windows очень сильно тормознутый. Но слава Гейтсу, что появились графические ускорители и библиотека пошла в рост, потому что смогла оперативно всосать в себя все необходимое для поддержки таких карт. А самое главное, что DirectX дает программеру базовый и необходимый набор возможностей вне зависимости от того, поддерживает видеокарта ускорение или нет. Если какой-то возможности у ускорителя нет, то DirectX API просто эмулирует ее программно, заставляя поднапрячься центральный проц.
Снова в школу
DirectX - это графическая библиотека состоящая из нескольких DLL файлов:
Ddraw.dll - в этом файле находятся API функции для работы с графикой в 2D режиме.
Dsound.dll - здесь находятся API функции для работы со звуком.
D3d8.dll - это для работы с 3D графикой.
DInput8.dll - это для работы с устройствами ввода.
Ну в общем все в таком духе. Мы начнем изучение с 2D графики и соответственно с Ddraw.dll.
DirectX - это объектная библиотека, построенная по технологии COM. Не пугайся, я постараюсь объяснить все как можно проще, чтобы ты не ощутил всех трудностей COM кодинга. DirectDraw , грубо говоря, состоит из следующих объектов:
DirectDrawSurface - область видеопамяти. К ней можно обращаться напрямую и производить практически любые действия.
DirectDrawPalette - интерфейс для работы с палитрами. Он нужен, если ты настроился на 256 или не дай бог 16 цветную игру.
DirectDrawClipper - этот интерфейс отвечает за обрезания. Он нужен, если ты пишешь оконное приложение. В этом случае тебе понадобится обрезать все, что выходит за пределы окна.
На этом теорию надо прекращать. Постепенно я буду тебя знакомить не только с практикой, но и с теорией программирования графики, а может быть будет и отдельная статья.
Пошкодим
Для начала познакомимся с внутренностями твоих окошек, чтобы наши программы были маленькими и не использовали визуальную библиотеку VCL. Для этого мы напишем шаблон, который будет использоваться во всех последующих примерах.
Запусти уже полюбившийся Delphi. Как всегда, сразу нам доступен новый проект. Так как мы будем делать минимальные демки, то нам абсолютно не нужны никакие формы, поэтому их надо удалить. Щелкни View->Project Manager. Перед тобой появиться окно менеджера проектов. Выдели форму Unit1 и нажми кнопарь Remove.
Теперь выбираем из меню Project пункт View Source. Если все в норме, то в редакторе кода ты увидишь код твоего проекта. Оставляем только первую строчку "program Project1;", а все остальное удаляем и вместо этого пишем:
//Первой строкой идёт имя проекта, которое мы не меняем
uses
windows, messages, sysutils;
{$R *.RES}
var
Instance: HWnd;
WindowClass: TWndClass;
Handle: HWnd;
msg: TMsg;
//Процедура выхода из проги
procedure DoExit;
begin
Halt;
end;
//Функция обработки событий Windows
function WindowProc (Hwn,msg,wpr,lpr: longint): longint; stdcall;
begin
result:=defwindowproc(hwn,msg,wpr,lpr);
if msg=wm_destroy then
DoExit;
if msg=wm_KeyDown then
if wpr=VK_ESCAPE then
DoExit;
end;
//Отсюда начинается выполнение проги
begin
//Получаем описатель модуля
instance :=GetModuleHandle(nil);
//Заполняю структуру WindowClass
WindowClass.style:=CS_HRedraw or CS_VRedraw;
WindowClass.Lpfnwndproc:=@windowproc;
WindowClass.Hinstance:=Instance;
WindowClass.HbrBackground:= color_btnface;
WindowClass.LpszClassName:='DX';
WindowClass.Hcursor:=LoadCursor(0,IDC_ARROW);
//Регистрирую новый класс
RegisterClass (WindowClass);
//Создаю окно
Handle:=CreateWindowEx (0,'DX','',WS_POPUP, 1,1,
GetSystemMetrics (SM_CXSCREEN),
GetSystemMetrics (SM_CYSCREEN),0,0,instance, nil);
UpdateWindow (Handle);
//Здесь можно производить инициализацию.
//Цикл обработки сообщений
while (GetMessage(msg, 0, 0, 0)) do
begin
translatemessage(msg);
dispatchmessage (msg);
end;
end.
Теперь разберем листинг, чтобы можно было понять, как работают программы Windows. После старта, программа начинает выполнение с первого begin (я это место обозначил соответствующим комментарием). Первой строкой кода идет вызов WinAPI функции GetModuleHandle. Она возвращает описатель модуля, который я сохраняю в переменной instance. Этот описатель нам пригодиться немного позже.
Далее я заполняю структуру WindowClass. Эта структура используется при создании нового класса окна. Для минимального приложения нам понадобиться заполнить следующие поля:
style - стиль окна;
Lpfnwndproc - сюда нужно записать указатель на процедуру, которая будет вызываться на все пользовательские или системные события;
Hinstance - описатель. Это тот описатель, который мы получили в первой строчке кода;
HbrBackground - цвет фона. В принципе, он необязателен, но я решил окрасить фон системным цветом кнопок;
LpszClassName - имя создаваемого класса;
Hcursor - курсор. Сюда я загружаю стандартный курсор - стрелку.
Все, структура готова и мы можем зарегистрировать новый класс будущего окна. Для этого я вызываю WinAPI функцию RegisterClass(WindowClass);. После этого в системе есть описание твоего будущего окна. Почему будущего? Да потому что само окно мы еще не создали. Для этого нужно еще вызвать функцию CreateWindowEx. У нее достаточно много параметров и давай посмотрим на них поподробнее:
1. Расширенный стиль окна. Нам он параллелен, поэтому у меня первый параметр равен нулю.
2. Имя класса. Мы зарегистрировали класс 'DX', значит и здесь мы должны указать именно этот класс.
3. Имя окна. При программировании графики имя окна ненужно. Потому что окно будет полноэкранным.
4. Стиль окна. Нас интересует простейшее WS_POPUP окно.
5-8. Следующие четыре параметра - это левая, правая позиция и ширина и высота окна. Если указать все нули, то эти значения будут выбраны по умолчанию.
9. Главное окно по отношению к создаваемому. Наше окно само по себе главное, поэтому я указываю 0.
10. Меню. Для DX меню не будет.
11. Это снова описатель, полученный после вызова GetModuleHandle.
12. Параметры окна. Этот параметр используется при создании многодокументных окон, поэтому я указываю ноль.
И последняя подготовительная функция - UpdateWindow. Это простая прорисовка созданного нами окна.
Теперь разберемся с циклом обработки сообщений. Функция GetMessage ожидает пользовательского или системного сообщения и как только оно наступает, возвращает true (истина). Полученное сообщение преобразуется в необходимый вид с помощью translatemessage и отправляется обработчику сообщений помощью вызова dispatchmessage.
В каждой программе должна быть процедура обработки сообщений. Какая именно? Мы указали ее при создании класса окна в свойстве WindowClass.Lpfnwndproc. Я ее назвал WindowProc - стандартное имя, используемое по умолчанию. Сама же процедура должна выглядеть приблизительно как в листинге 1.
В процедуре-обработчике событий, желательно делать вызов функции defwindowproc. Эта функция ищет в системе обработчик полученного сообщения установленный по умолчанию. Это очень важно, чтобы тебе не пришлось самому писать то, что может сделать за тебя ОС.
После этого я сам начинаю обработку полученного сообщения. Это происходит с помощью сравнивания параметра msg со стандартными событиями. Например, если msg равно wm_destroy, то программа хочет уничтожиться, и я могу по этому событию освободить любую выделенную память.
В моем обработчике есть еще одно сравнение. Если msg равно wm_KeyDown, т.е. нажата какая-то клавиша, то я проверяю, если нажата клавиша ESC(в этом случае wpr = VK_ESCAPE), то завершаю приложение.
Добавляем к нашей проге DirectX
Для начала в раздел var добавь следующие переменные:
Здесь DirectDraw - это файл DirectDraw.pas в котором описаны все функции для работы с графической библиотекой. Если у тебя нет этого файла, то ты сможешь его скачать с моего сайта. Я даже тебе советую сделать это в любом случае, потому что разные версии этого файла работают по разному, и могут возникнуть проблемы с комиляцией.
Инициализация
Теперь перейди туда, где написан комментарий "Здесь можно производить инициализацию", это перед циклом обработки сообщений. Вот здесь мы начнем DX кодинг.
Первое, что нужно сделать - проинициализировать сам DirectDraw:
hRet := DirectDrawCreateEx (nil, FDirectDraw, IDirectDraw7, nil);
if hRet <> DD_OK then Halt;
Почти все DirectDraw функции возвращают значение типа HRESULT. Если оно равно DD_OK, то все прошло ОК. Если результат другой, то можно вылетать из программы, потому что может быть не установлен DirectX или система не может его проинициализировать. Я сделаю проверку корректности только для этой строки кода, потому что здесь это наиболее критично. В остальных случаях я буду надеяться на положительный результат.
У функции DirectDrawCreateEx есть четыре параметра:
1. Используемый для вывода драйвер. Возможные значения: DDCREATE_HARDWAREONLY - использовать только аппаратные возможности; DDCREATE_EMULATIONONLY - использовать только эмуляцию; nil - использовать аппаратные возможности и эмуляцию.
2. Указатель на переменную типа TDirectDraw, которая будет инициализирована.
3. Версия DirectDraw которую мы хотим получить. Сейчас существует уже 8-я версия, но указывать надо именно IDirectDraw7.
4. Зарезервирован до лучших времен, обязательно должен быть nil. Вообще-то у функций DirectDraw очень часто последний параметр зарезервирован, поэтому я буду экономить на этом место. Если я ничего не сказал про последний параметр, значит, он зарезервирован и ставь то, что указал в примере я.
Итак, DirectDraw проинициализировали, можно пойти дальше. Следующим шагом надо установить уровень привилегий нашего приложения. Для этого вызываем SetCooperativeLevel:
FDirectDraw.SetCooperativeLevel(Handle, DDSCL_FULLSCREEN or DDSCL_EXCLUSIVE);
Тут всего два параметра:
1. Указатель на окно.
2. Уровень доступа к ресурсам. Я указал DDSCL_FULLSCREEN (приложение должно быть полноэкранным) и DDSCL_EXCLUSIVE (эксклюзивный уровень доступа). При эксклюзивном доступе приложение получает максимальные привилегии на использование процессорного времени и доступ к видеокарте. Хочу сразу предупредить, что только полноэкранные приложения могут иметь такой уровень доступа.
Так как приложение полноэкранное с эксклюзивными правами, мы можем изменять разрешение экрана. Давай сделаем это:
FDirectDraw.SetDisplayMode (640, 480, 16, 0, 0);
Тут пять параметров: ширина экрана, высота, глубина цвета (количество бит на пиксель), частота развертки и резерв. Частоту развертки я не советую трогать на первых парах и ставить 0, в этом случае будет использоваться значение по умолчанию. Размеры экрана можно использовать только стандартные, так что будь аккуратен, чтобы не повесить систему.
Экран полностью готов к рисованию. Теперь мы должны создать хотя бы одну поверхность (область видеопамяти), в которой мы сможем рисовать. Можно создавать любое количество таких поверхностей, но только одна из них должна быть главная. Все, что отображено на главной поверхности сразу показывается на экране. Это значит, что когда мы рисуем на этой поверхности, мы как бы рисуем прямо на мониторе, а не в промежуточных областях памяти.
Сегодня я создам только одну поверхность. Но прежде чем это делать, надо заполнить структуру типа TDDSurfaceDesc2 (для этого мы создали переменную SurfaceDesc типа TDDSurfaceDesc2). Эта структура должна содержать описание создаваемой поверхности.
Первой строкой я обнуляю содержимое всей структуры. Вторая строка заполняет свойства dwSize, записывая туда размер структуры.
Следующей строкой я заполняю необходимые флаги. В этих флагах указывается, какие еще свойства структуры будут заполнены. Я указал DDSD_CAPS, значит, я обязан заполнить еще и свойство dwCaps, что и делаю в следующей строке. В свойство dwCaps я записываю DDSCAPS_PRIMARYSURFACE, это указывает на то, что создаваемая поверхность будет главной.
Теперь можно и создать саму поверхность с помощью вызова CreateSurface:
Тут всего три параметра: заполненная структура SurfaceDesc, переменная типа IDirectDrawSurface7 (сюда будет записан указатель на созданную поверхность) и резерв.
Выход
По выходу из программы, все созданные объекты и поверхности (у нас это FPrimarySurface и FDirectDraw) должны быть уничтожены. Уничтожать надо в обратном порядке их создания. В нашем случае я сначала создавал FDirectDraw, а потом FPrimarySurface. Значит, сначала уничтожается FPrimarySurface, а потом FDirectDraw. Для уничтожения нужно просто присвоить этим указателям значение nil.
Вот так должна выглядеть теперь твоя процедура выхода из проги:
