DirectX 9 Graphics. Анимированные спрайты

LPDIRECT3DTEXTURE9 texture = NULL;

D3DXIMAGE_INFO info;
result = D3DXGetImageInfoFromFile("image.bmp", &info);

HRESULT WINAPI D3DXCreateTextureFromFileEx(
	LPDIRECT3DDEVICE9 pDevice,
	LPCSTR pSrcFile,
	UINT Width,
	UINT Height,
	UINT MipLevels,
	DWORD Usage,
	D3DFORMAT Format,
	D3DPOOL Pool,
	DWORD Filter,
	DWORD MipFilter,
	D3DCOLOR ColorKey,
	D3DXIMAGE_INFO *pSrcInfo,
	PALETTEENTRY *pPalette,
	LPDIRECT3DTEXTURE9 *ppTexture
	);

LPDIRECT3DTEXTURE9 LoadTexture(char *filename, D3DCOLOR transcolor)
{
	// Указатель на объект текстуры
	LPDIRECT3DTEXTURE9 texture = NULL;
	
	// Структура для хранения информации о файле изображения
	D3DXIMAGE_INFO info;
	
	// Стандартное Windows-значение, возвращаемое функцией
	HRESULT result;
	
	// Получаем ширину (width) и высоту (height) изображения из загружаемого файла
	result = D3DXGetImageInfoFromFile(filename, &info);
	if(result != D3D_OK)
		return NULL;
	
	// Создаём новую текстуру путём загрузки битмапа (=файла растрового изображения)
	D3DCreateTextureFromFileEx(
		d3ddev, // Объект устройства Direct3D
		filename, // Имя файла ращстрового изображения
		info.Width, // Ширина растрового изображения
		info.Height, // Высота растрового изображения
		1, // Число мип-мэп уровней (mip-map levels; 1 - значит без цепочек)
		D3DPOOL_DEFAULT, // Тип поверхности (стандартная)
		D3DFMT_UNKNOWN, // Формат цветности поверхности (D3DFMT_UNKNOWN = формат по умолчанию)
		D3DPOOL_DEFAULT, // Пул памяти для текстуры
		D3DX_DEFAULT, // Фильтр изображения
		D3DX_DEFAULT, // Мип-фильтр изображения
		transcolor, // Ключевой цвет прозрачности
		&info, // Структура с информацией о загруженном файле изобаржения
		NULL, // Цветовая палитра
		&texture // Результирующий объект текстуры
		);
	
	// Проверяем, что изображение загружено успешно
	if(result != D3D_OK)
		return NULL;
	
	return texture;
}

LPD3DXSPRITE sprite_handler;

HRESULT WINAPI D3DXCreateSprite(LPDIRECT3DDEVICE9 pDevice, LPD3DXSPRITE *ppSprite);

result = D3DXCreateSprite(d3ddev, &sprite_handler);

HRESULT Begin(DWORD Flags);

HRESULT SetTransform(const D3DXMATRIX *pTransform);

D3DXMATRIX *WINAPI D3DXMatrixTransformation2D (
	D3DXMATRIX *pOut, // Матрица-результат
	CONST D3DXVECTOR2 *pScalingCenter, // Центр, относительно которого масштабируется текстура
	FLOAT *pScalingRotation, // Указатель на фактор масштабирования при вращении (scaling rotation factor).
							// Если масштабирование не нужно, ставим здесь NULL.
	CONST D3DXVECTOR2 *pScaling, // Указатель на фактор масштабирования (scaling factor).
								// Если масштабирование не нужно, ставим здесь NULL.
	CONST D3DXVECTOR2 *pRotationCenter, // 2D-координаты точки центра вращения.
										// Если вращение не нужно, ставим здесь NULL.
	FLOAT Rotation, // Угол поворота в радианах. Если вращение не нужно, ставим здесь 0.
	CONST D3DXVECTOR2 *pTranslation // Смещение текстуры по обеим осям относительно начала координат.
									// Если смещение не нужно, ставим здесь NULL.
);

D3DXMatrixTransformation2D(&Mat, NULL, 0, NULL, NULL, 0, NULL);
Sprite->SetTransform(&Mat);

HRESULT Draw (
	LPDIRECT3DTEXTURE9 pTexture, // Указатель на текстуру
	CONST Rect *pSrcRect, // Указатель на прямоугольник, на котором будет отрисована текстура. Можно выставить в NULL.
	CONST D3DXVECTOR3 *pCenter, // Точка центра спрайта. Можно выставить в NULL.
	CONST D3DXVECTOR3 *pPosition, // Вектор трансляции спрайта (в случае его перемещения). Можно выставить в NULL.
	D3DCOLOR Color // Можно окрасить текстуру (придать цветовой оттенок) либо изменить значение её альфа-канала.
	);

Sprite->End();

// Файл: WinMain.cpp
// Описание: Шаблон оконного приложения Windows. Простейшее (базовое) приложение Windows,
// выводящее на экран окно.
// www.igrocoder.ru 2015
// При использовании просьба указывать ссылку на источник.

#define STRICT
#define WIN32_LEAN_AND_MEAN	// Уменьшаем кол-во используемых компонентов в программе.

#include <windows.h>
#include "dxfunc.h"
#include "Game.h"

// Прототип функции WinMain
int PASCAL WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmdLine, int nCmdShow); 

// Объявление оконной процедуры
LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

// Реализация главной функции программы
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
	HWND hWnd;			// Дескриптор окна
	MSG msg;			// Структура сообщения
	CoInitialize(NULL);

	WNDCLASSEX wndClass;	// Объявляем экземпляр класса программы на базе WNDCLASSEX

   // Заполняем структуру оконного класса
	wndClass.cbSize=sizeof(wndClass);
	wndClass.style=CS_CLASSDC;	// Поочерёдный доступ к контексту устройства (Device Context)
	wndClass.lpfnWndProc=WindowProc;		// Оконная процедура
	wndClass.cbClsExtra=0;
	wndClass.cbWndExtra=0;
	wndClass.hInstance=hInstance;			// Экземпляр окна
	wndClass.hIcon=LoadIcon(NULL, IDI_APPLICATION);		// Пиктограмма приложения
	wndClass.hIconSm=LoadIcon(NULL, IDI_APPLICATION);	// Малая пиктограмма приложения
	wndClass.hCursor=NULL;		// Курсор при наведении на окно
	wndClass.hbrBackground=NULL;	// Закрашиваем окно чёрным цветом
	wndClass.lpszMenuName=NULL;	// Дескриптор Главного меню окна. Сейчас оно не нужно
	wndClass.lpszClassName="GameClass"; // Обзываем оконный класс.
	
	// Если класс не зарегистрируется, досрочно прерываем выполнение программы
	if(!RegisterClassEx(&wndClass)) return FALSE;

	// Создание окна на основе зарегистрированного класса
	hWnd=CreateWindow(
		"GameClass",		// Класс окна.
		"My game title",		// Текст заголовка (на верхнем тулбаре).
		WS_OVERLAPPEDWINDOW,	// Обычное окно с кнопками в правом верхнем углу.
		0, 0,				// Координаты X и Y
		iWidth,	// Ширина окна
		iHeight,	// Высота окна
		NULL,							// Дескриптор родительского окна
		NULL,							// Дескриптор меню
		hInstance,						// Дескриптор экземпляра приложения
		NULL);							// Дополнительные данные

	if(!hWnd) return(FALSE);

	// Собственно, показываем окно
	ShowWindow(hWnd, SW_NORMAL);
	UpdateWindow(hWnd);

	// Очищаем структуру сообщения
	ZeroMemory(&msg, sizeof(MSG));

	if(GameInit(hWnd) == TRUE)
	{
		while(TRUE)
		{
			if(PeekMessage(&msg, NULL, NULL, NULL, PM_REMOVE))
			{
				// Есть сообщение! Обработаем его как обычно...
				TranslateMessage(&msg);
				DispatchMessage(&msg);
				if(msg.message == WM_QUIT) break;
			}
			else
			{
				// Главный цикл игры (mainloop)
				GameRun(hWnd);
			}
		}
	}

	CoUninitialize ();
	//Удаляем регистрацию класса
	UnregisterClass("GameClass", hInstance);
	
	// Выходим из приложения
	return (msg.wParam);
}

// Оконная процедура
LRESULT CALLBACK WindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch(msg)
	{
	case WM_DESTROY:			// В случае этого сообщения...
		GameEnd(hWnd);
		PostQuitMessage(0);		// Говорим Windows закрыть приложение
		break;

		// В случае любых других сообщений...
	default: return DefWindowProc(hWnd, msg, wParam, lParam);
	}
	return 0;
}

#ifndef _DXFUNC_H_
#define _DXFUNC_H_

#include <d3d9.h>
#include <d3dx9.h>
#include <d3dx9math.h>

// Прототипы функций
HRESULT d3d9Init(IDirect3D9 **d3d,
	IDirect3DDevice9 **d3ddev, HWND hWnd,
	DWORD iWidth, DWORD iHeight,
	BOOL bFullScreen );

LPDIRECT3DSURFACE9 LoadSurface(char *, D3DCOLOR);
LPDIRECT3DTEXTURE9 LoadTexture(char *, D3DCOLOR);

// Объявления переменных
extern LPDIRECT3D9 d3d;
extern LPDIRECT3DDEVICE9 d3ddev;
extern LPDIRECT3DSURFACE9 backbuffer;

#endif

// Файл: dxfunc.cpp
// Реализация DX-функций, объявленных в dxfunc.h
// Сборник DirectX-функций

#include "dxfunc.h"

// Объявления переменных
LPDIRECT3D9 d3d = NULL;
LPDIRECT3DDEVICE9 d3ddev = NULL;
LPDIRECT3DSURFACE9 backbuffer = NULL;

HRESULT d3d9Init(IDirect3D9 **d3d, IDirect3DDevice9 **d3ddev,
	HWND hWnd, DWORD iWidth, DWORD iHeight, BOOL bFullScreen)
{
	// Инициализируем Direct3D
	if ((*d3d = Direct3DCreate9(D3D_SDK_VERSION)) == NULL)
	{
		return E_FAIL;
	}
		
	// Заполняем основные (общие) параметры представления
    D3DPRESENT_PARAMETERS d3dpp;
    ZeroMemory( &d3dpp, sizeof( d3dpp ) );
	
	d3dpp.BackBufferWidth = iWidth;
	d3dpp.BackBufferHeight = iHeight;
	d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
	d3dpp.EnableAutoDepthStencil = TRUE;
	d3dpp.hDeviceWindow = hWnd;
	
	// Запрос на отображение в полноэкранном режиме
	int  iRes;
	if (!bFullScreen)
	{
		iRes=MessageBox(hWnd, "Перейти в полноэкранный режим?", "Screen", MB_YESNO | MB_ICONQUESTION);
	}
	else
	{
		iRes = IDYES;
	}
	
	if(iRes == IDYES)
	{
      //////////////////////////////////////////////////////////
	  // Полноэкранный режим
      //////////////////////////////////////////////////////////
	  // Установка параметров полноэкранного режима
		d3dpp.Windowed			= FALSE;
		d3dpp.BackBufferCount	= 1;
		d3dpp.BackBufferFormat	= D3DFMT_R5G6B5;
		d3dpp.SwapEffect		= D3DSWAPEFFECT_FLIP;
		d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
		// При значении D3DPRESENT_INTERVAL_DEFAULT Direct3D сам выбирает частоту обновления.
		// Обычно она равна частоте смены кадров (FPS).
		d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
	}
	else
	{
		// Доп. параметры для оконного режима
		// Получить формат пикселя
		D3DDISPLAYMODE d3ddm;
		(*d3d)->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm);
		
		// Установка параметров оконного режима
		d3dpp.Windowed         = TRUE;
		d3dpp.BackBufferFormat = d3ddm.Format;
		d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
	}
	
	if(FAILED((*d3d)->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
                                  D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                  &d3dpp, d3ddev)))
	{
		return E_FAIL;
	}

	// Очищаем бэкбуфер в чёрный цвет
	(*d3ddev)->Clear(0, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);

	// Создаём указатель на бэкбуфер
	(*d3ddev)->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
}

LPDIRECT3DSURFACE9 LoadSurface(char *filename, D3DCOLOR transcolor)
{
	LPDIRECT3DSURFACE9 image = NULL;
	D3DXIMAGE_INFO info;
	HRESULT result;

	// Получаем из файла длину и высоту изображения
	D3DXGetImageInfoFromFile(filename, &info);
	if(result != D3D_OK) return NULL;

	// Создаём поверхность
	result = d3ddev->CreateOffscreenPlainSurface(
		info.Width, // Ширина изображения
		info.Height, // Высота изображения
		D3DFMT_X8R8G8B8, // Формат цветности поверхности
		D3DPOOL_DEFAULT, // Используемый пул памяти
		&image, // Указатель на поверхность
		NULL); // Зарезервирован (всегда NULL)
	if(result != D3D_OK) return NULL;
	
	// Загружаем изображение из файла в созданную поверхность
	result = D3DXLoadSurfaceFromFile(
		surface, // Поверхность-получатель
		NULL, // Палитра-получатель
		NULL, // Прямоугольник-получатель
		"test.jpg", // Имя файла растрового изображения
		NULL, // Прямоугольник-источник
		D3DX_DEFAULT, // Метод фильтрации изображения
		0, // Флаг прозрачности (0 - значит без неё)
		NULL); // Инфо о файле растрового изображения (обычно всегда NULL)
	// Проверяем, что файл успешо загружен
	if(result != D3D_OK) return NULL;
	
	return image;
}
	
LPDIRECT3DTEXTURE9 LoadTexture(char *filename, D3DCOLOR transcolor)
{
	// Указатель на текстуру
	LPDIRECT3DTEXTURE9 texture = NULL;
			
	// Структура, куда сохраним инфу о файле растрового изображения (=битмапе)
	D3DXIMAGE_INFO info;
			
	// Стандартное значение, возвразаемое в ОС Windows
	HRESULT result;
			
	// Получаем ширину и высоту изображения из битмапа
	result = D3DXGetImageInfoFromFile(filename, &info);
	if(result != D3D_OK) return NULL;
			
	// Создаём текстуру путём загрузки битмапа
	D3DXCreateTextureFromFileEx(
		d3ddev, // Объект устройства Direct3D
		filename, // Имя файла битмапа
		info.Width, // Ширина битмапа
		info.Height, // Высота битмапа
		1, // Кол-во мипмап-уровней (1 - значит без цепочки)
		D3DPOOL_DEFAULT, // Тип поверхности (стандартная)
		D3DFMT_UNKNOWN, // Формат цветности поверхности (по умолчанию)
		D3DPOOL_DEFAULT, // Пул памяти для текстуры
		D3DX_DEFAULT, // Фильтр изображения
		D3DX_DEFAULT, // Мип-фильтр
		transcolor, // Ключевой цвет для прозрачности
		&info, // Инфо о битмапе (загружено выше из файла битмапа)
		NULL, // Цветовая палитра
		&texture );	// Указатель на конечный объект текстуры

	// Проверяем, что битмап успешно загружен
	if(result != D3D_OK) return NULL;
		
	return texture;
}

// Файл: Game.h
// Объявления функций, специфичных для игры, реализации которых
// размещены в Game.cpp

#ifndef _GAME_H_
#define _GAME_H_

#include "dxfunc.h" // Для инициализации Direct3D + подключения d3d9.h
#include <time.h> // Для инициализации таймера
#include <stdio.h>
#include <stdlib.h>

// Заголовок приложения (выводится на тулбаре окна)
#define APPTITLE "Animated Sprite Test"

// Настройки видеорежима
#define FULLSCREEN 1
#define iWidth 640
#define iHeight 480

// Макрос асинхронного считывания нажатий клавиатуры
#define KEY_DOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1:0)
#define KEY_UP(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1:0)

// Прототипы игровых функций
bool GameInit(HWND); // Инициализирует игру.
void GameRun(HWND);
void GameEnd(HWND);

// Структура для хранения информации о спрайте
typedef struct
{
	int x,y;
	int width, height;
	int movex, movey; 
	int curframe, lastframe;
	int animdelay, animcount;
} SPRITE;

#endif

// Файл: Game.cpp
// Реализация функций, специфичных для игры, объявленных в Game.h

#include "Game.h"

LPDIRECT3DTEXTURE9 test_image[7];
SPRITE TestSprite;
LPDIRECT3DSURFACE9 back;
LPD3DXSPRITE SpriteHandler;
HRESULT result;

// Переменные таймера
long start = GetTickCount();

// Инициализация игры
bool GameInit(HWND hWnd)
{
	char s[20];
	int n;
	
	// Устанавливаем генератор случайных чисел
	// на основе текущего времени
	srand(time(NULL));
	
	MessageBox(hWnd, "Сейчас будем создавать дескриптор спрайта", "Note", MB_OK);

	// Создаём объект дескриптора спрайта
	result = D3DXCreateSprite(d3ddev, &SpriteHandler);
	if(result != D3D_OK)
	{
		MessageBox(hWnd, "Спрайт не создан(", "Note", MB_OK);
		return NULL;
	}
	
	// Загружаем анимацию спрайта
	for(n=0; n<6; n++)
	{
		// Приводим имя файла к нужному виду
		sprintf(s,"test%d.jpg",n+1);
		// Загружаем текстуру с розовым цветом прозрачности
		test_image[n] = LoadTexture(s, D3DCOLOR_XRGB(255, 0, 255));
		if(test_image[n] == NULL) return NULL;
	}
	
	// Загружаем фоновое изображение
	back = LoadSurface("background.bmp", NULL);
	
	// Инициализируем свойства спрайта
	TestSprite.x = 100;
	TestSprite.y = 150;
	TestSprite.width = 96;
	TestSprite.height = 96;
	TestSprite.curframe = 0;
	TestSprite.lastframe = 5;
	TestSprite.animdelay = 2;
	TestSprite.animcount = 0;
	TestSprite.movex = 8;
	TestSprite.movey = 0;

	// Возвращаем ОК
	return 1;
}

// Главный цикл игрового приложения
void GameRun(HWND hWnd)
{
	// Проверяем корректность созданного объекта устройства Direct3D
	if(d3ddev == NULL) return;

	// Очищаем бэкбуфер в синий цвет.
	d3ddev->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,0,0), 1.0f, 0);
	
	// Готов ли следующий кадр?
	// Поддерживает заданную частоту кадров (framerate) в приложении?
	if(GetTickCount() - start >= 30)
	{
		// Сбрасываем таймер в 0
		start = GetTickCount();
		
		// Перемещаем спрайт
		TestSprite.x += TestSprite.movex;
		TestSprite.y += TestSprite.movey;
		
		// При приближении спрайта к краям окна "переносим" его
		// на противоположную сторону
		if(TestSprite.x > iWidth - TestSprite.width)
		{
			TestSprite.x=0;
		}
		
		if(TestSprite.x < 0)
		{
			TestSprite.x = iWidth - TestSprite.width;
		}
				
		// В случае достижения паузы в анимации определённой величины...
		if(++TestSprite.animcount > TestSprite.animdelay)
		{
			// Обнуляем счётчик кадров
			TestSprite.animcount = 0;

			// Анимируем спрайт
			if(++TestSprite.curframe > TestSprite.lastframe)
			{
				TestSprite.curframe = 0;
			}
		}
	}
	
	// Начинаем рендеринг
	if(d3ddev->BeginScene() )
	{
		// Очищаем текущий фон (background)
		d3ddev->StretchRect(back, NULL, backbuffer, NULL, D3DTEXF_NONE);
		
		// Начинаем отрисовку спрайта через его дескриптор
		SpriteHandler->Begin(D3DXSPRITE_ALPHABLEND);
		
		// Создаём вектор для обновления положения спрайта на экране
		D3DXVECTOR3 position((float)TestSprite.x, (float)TestSprite.y, 0);
		
		// Рисуем спрайт
		SpriteHandler->Draw(
			test_image[TestSprite.curframe],
			NULL,
			NULL,
			&position,
			D3DCOLOR_XRGB(255, 255, 255)
			);
		
		// Заканчиваем отрисовку спрайта через его дескриптор
		SpriteHandler->End();
		
		// Завершаем рендеринг
		d3ddev->EndScene();
	}
	
	// Выводим содержимое бэкбуфера на экран
	d3ddev->Present(NULL, NULL, NULL, NULL);
	
	// При нажатии Esc завершаем работу приложения
	if(KEY_DOWN(VK_ESCAPE))
	{
		PostMessage(hWnd, WM_DESTROY, 0, 0);
	}
}

// Освобождаем память, стирая ранее выделененые ресурсы
void GameEnd(HWND hWnd)
{
	int n;
	
	// Удаляем поверхность
	for(n=0; n<6; n++)
	{
		if(test_image[n] != NULL)
		{
			test_image[n]->Release ();
		}
	}
	
	if(back != NULL)
	{
		back->Release();
	}
	
	if(SpriteHandler != NULL)
	{
		SpriteHandler->Release();
	}

	// Освобождаем ресурсы, выделенные ранее под объект устройства Direct3D.
	if(d3ddev != NULL)
		d3ddev->Release();
	
	// Освобождаем ресурсы, выделенные ранее под объект (инстанс) класса IDirect3D9.
	if(d3d != NULL)
		d3d->Release();
}

Error LNK1123: сбой при преобразовании в COFF: файл недопустим или поврежден

...
#include <d3d9.h>
...

$(WindowsSdkDir)include

...
// Создаём объект дескриптора спрайта
	result = D3DXCreateSprite(d3ddev, &SpriteHandler);
	if(result != D3D_OK)
	{
		MessageBox(hWnd, "Спрайт не создан(", "Note", MB_OK);
		return NULL;
	}
...