Пообъектная Анимация

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

Любое преобразование объекта можно задать при помощи матриц. Эти преобразования называются афинными. Существуют три основных вида преобразований - перенос, вращение и масштабирование, и все их можно представить при помощи матриц. Комбинируя эти преобразования (это делается путем умножения матриц друг на друга), мы получаем матрицу конечного преобразования для объекта. Таким образом, мы можем комбинировать сколько угодно матриц, в результате мы все равно получим матрицу преобразования (причем это преобразования тоже будет афинным). Но нужно учитывать, что операция умножения матриц не коммулятивна (т.е. если А и В матрицы, то - А*В != В*А ), и при перемножении тех же матриц в другом порядке мы получим другую матрицу, а следовательно и другое конечное преобразование для объекта. Для применения полученного преобразования к объекту нам достаточно просто перемножить координаты каждой вершины (в данном случае их удобно представлять в виде вектора) на матрицу, после этого мы получим новое положение для данной вершины.

Это вроде все пояснения, которые необходимы.

Теперь давайте приступим к практической части данного урока. Для данного урока я создал специальный класс 'csc3Dobj' - данный класс предназначен для работы с трехмерными объектами, их преобразования и отображения. Вот прокол данного класса (класс сам по себе, конечно, выглядит не очень хорошо, но вы можете сами изменить его, так как пожелаете нужным):

class csc3Dobj
{
private:
	LPDIRECT3DDEVICE8 using_d3d_Device;
	LPDIRECT3DVERTEXBUFFER8 p_VertexBuffer;
	LPDIRECT3DINDEXBUFFER8 p_IndexBuffer;

	DWORD dwNumVerticies;
	DWORD dwNumIndecies;
	DWORD dwNumFaces;

	float fBBoxLeft, fBBoxRight, fBBoxTop, fBBoxBottom, fBBoxFar, fBBoxNear;

	D3DXMATRIX objMatr;
	D3DXMATRIX objMatrR, objMatrT, objMatrS;
	D3DXMATRIX objMatrTT;

	WORD sizeOfVertex;
	VOID *t_pVertices, *t_pIndeces;
	DWORD sizeOfAllVerteces;
	DWORD sizeOfAllIndeces;


public:
	VERTEX_3DPNT1 *p_Vertices;
	VERTEX_3DPNT1 *p_ObjVert;
	WORD *p_ObjInd;

public:
	csc3Dobj (void);
	~csc3Dobj (void);
	
	int Create (LPDIRECT3DDEVICE8, DWORD, DWORD);
	int CreateFromFile (LPDIRECT3DDEVICE8, char *);
	int UpdateData (void);
	int UpdateDataV (void);
	int UpdateDataI (void);

	int Render (void);

	int RotateX (float);
	int RotateY (float);
	int RotateZ (float);
	int Move (float, float, float);
	int Scale (float, float, float);
	int Transform (void);
	int TransformObj (void);
};

В данном классе нам интересны следующие моменты:

p_VertexBuffer - вертексный буфер для объекта
p_IndexBuffer - индексный буфер для объекта

objMatr - конечная матрица преобразований
objMatrR , objMatrT , objMatrS - текущие матрицы преобразований (соответственно для вращения, переноса и масштабирования)

p_Vertices - массив вершин объекта, представляет текущее (преобразованное) состояние объекта
p_ObjVert - массив вершин объекта, представляет исходное (не преобразованное) состояние объекта
p_ObjInd - массив индексов объекта

p_Vertices , p_ObjVert и p_ObjInd - открыты для того, что бы вы сами могли задавать объект, так как вам это нужно.

Далее рассмотрим используемые в данном классе функции:

int Create (LPDIRECT3DDEVICE8, DWORD, DWORD); --- используется, если вы сами будете создавать объект --- параметры - используемое 3D устройство, количество вершин, количество индексов

int CreateFromFile (LPDIRECT3DDEVICE8, char *); --- используется для загрузки объекта из .X файла --- параметры - используемое 3D устройство, имя файла для загрузки

int UpdateData (void); --- обновление данных в вертексном и индексном буферах, необходимо вызывать после каждого изменения вершин и индексов объекта.

int UpdateDataV (void); --- обновление информации только в вертексном буфере

int UpdateDataI (void); --- обновление информации только в индексном буфере

int Render (void); --- рендеринг объекта на экран

далее идут функции наиболее нам интересные в данном уроке. Их мы будем рассматривать более подробно.

int RotateX (float); --- вращение вокруг оси X на требуемый угол в радианах

int RotateY (float); --- вращение вокруг оси Y на требуемый угол в радианах

int RotateZ (float); --- вращение вокруг оси Z на требуемый угол в радианах

int Move (float, float, float); --- перемещение по осям координат на требуемое значение (X, Y, Z)

int Scale (float, float, float); --- масштабирование по осям

int Transform (void); --- применение преобразования к преобразованному объекту

int TransformObj (void); --- применение преобразования к исходному объекту (иногда требуется, скажем, повернуть объект, да так, что бы он таким и остался)

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

Scale (1, 2, 1);
RotateX (0.01);
Move (0, 10, 5);
RotateZ (-0.01);
Transform ();

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

struct VERTEX_3DPNT1 { D3DXVECTOR3 position, normal; D3DXVECTOR2 texture; };
#define D3DFVF_3DPNT1 ( D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1)

Теперь возьмемся за внутренности функций преобразования. Для начала рассмотрим функции преобразования матриц:

csc3Dobj::RotateX (float in_x)
{
	D3DXMatrixRotationX (&objMatrTT, in_x);
	objMatrR *= objMatrTT;
	return 0;
};
csc3Dobj::RotateY (float in_y)
{
	D3DXMatrixRotationY (&objMatrTT, in_y);
	objMatrR *= objMatrTT;
	return 0;
};

csc3Dobj::RotateZ (float in_z)
{
	D3DXMatrixRotationZ (&objMatrTT, in_z);
	objMatrR *= objMatrTT;
	return 0;
};

csc3Dobj::Move (float in_x, float in_y, float in_z)
{
	D3DXMatrixTranslation (&objMatrTT, in_x, in_y, in_z);
	objMatrT *= objMatrTT;
	return 0;
};

csc3Dobj::Scale (float in_x, float in_y, float in_z)
{
	D3DXMatrixScaling (&objMatrTT, in_x, in_y, in_z);
	objMatrS *= objMatrTT;
	return 0;
};

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

все они инициализируют матрицу для:
D3DXMatrixRotationX , D3DXMatrixRotationY , D3DXMatrixRotationZ - поворотов
D3DXMatrixTranslation - перемещения
D3DXMatrixScaling - масштабирования

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

И затем, после задания нужного нам преобразования нам необходимо преобразовать каждую вершину объекта. Я делаю это следующим образом:

csc3Dobj::Transform (void)
{
memcpy (p_Vertices, p_ObjVert, sizeOfAllVerteces);

objMatr = objMatrS*objMatrR*objMatrT;

for(DWORD i=0; i<dwNumVerticies; i++)
{
	D3DXVec3TransformCoord (&p_Vertices[i].position,
				&p_Vertices[i].position, &objMatr);
	D3DXVec3TransformNormal (&p_Vertices[i].normal, 
				&p_Vertices[i].normal, &objMatr);
	D3DXVec3Normalize (&p_Vertices[i].normal, &p_Vertices[i].normal);
};
p_VertexBuffer->Lock (0, sizeOfAllVerteces, (BYTE**)&t_pVertices, 0);
memcpy (t_pVertices, p_Vertices, sizeOfAllVerteces);
p_VertexBuffer->Unlock();
return 0;
};

здесь следует отметить следующие моменты:

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

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

csc3Dobj::TransformObj (void)
{
objMatr = objMatrS*objMatrR*objMatrT;

for(DWORD i=0; i<dwNumVerticies; i++)
{
	D3DXVec3TransformCoord (&p_ObjVert[i].position, 
				&p_ObjVert[i].position, &objMatr);
	D3DXVec3TransformNormal (&p_ObjVert[i].normal, 
				&p_ObjVert[i].normal, &objMatr);
	D3DXVec3Normalize (&p_ObjVert[i].normal, &p_ObjVert[i].normal);
};
p_VertexBuffer->Lock (0, sizeOfAllVerteces, (BYTE**)&t_pVertices, 0);
memcpy (t_pVertices, p_ObjVert, sizeOfAllVerteces);
p_VertexBuffer->Unlock();
D3DXMatrixIdentity (&objMatr);
D3DXMatrixIdentity (&objMatrR);
D3DXMatrixIdentity (&objMatrT);
D3DXMatrixIdentity (&objMatrS);
D3DXMatrixIdentity (&objMatrTT);
return 0;
};

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

Создаем трехмерные объекты:

csc3Dobj Donut;
csc3Dobj Plane;
csc3Dobj Donuts[5];

И затем их инициализируем:

Donut.CreateFromFile (p_d3d_Device, "donut.x");
Donuts[0].CreateFromFile (p_d3d_Device, "donut.x");
Donuts[1].CreateFromFile (p_d3d_Device, "donut.x");
Donuts[2].CreateFromFile (p_d3d_Device, "donut.x");
Donuts[3].CreateFromFile (p_d3d_Device, "donut.x");
Donuts[4].CreateFromFile (p_d3d_Device, "donut.x");

Donut.Scale (10, 10, 10);
Donut.RotateX (D3DXToRadian(90));
Donuts[0].Scale (4, 4, 4);
Donuts[1].Scale (4, 4, 4);
Donuts[2].Scale (4, 4, 4);
Donuts[3].Scale (4, 4, 4);
Donuts[4].Scale (4, 4, 4);
Donuts[0].Move (0,  0, 30);
Donuts[1].Move (40,  0,  0);
Donuts[2].Move (0,  25, 0);
Donuts[3].Move (0,  -20, 0);
Donuts[4].Move (0,  0, -15);
Donut.TransformObj();
Donuts[0].TransformObj();
Donuts[1].TransformObj();
Donuts[2].TransformObj();
Donuts[3].TransformObj();
Donuts[4].TransformObj();

Plane.Create (p_d3d_Device, 4, 6);
Plane.p_ObjVert[0].position = D3DXVECTOR3 (-100, -40,  100);
Plane.p_ObjVert[1].position = D3DXVECTOR3 ( 100, -40,  100);
Plane.p_ObjVert[2].position = D3DXVECTOR3 (-100, -40, -100);
Plane.p_ObjVert[3].position = D3DXVECTOR3 ( 100, -40, -100);
Plane.p_ObjVert[0].normal = D3DXVECTOR3 (0.0f, 1.0f, 0.0f);
Plane.p_ObjVert[1].normal = D3DXVECTOR3 (0.0f, 1.0f, 0.0f);
Plane.p_ObjVert[2].normal = D3DXVECTOR3 (0.0f, 1.0f, 0.0f);
Plane.p_ObjVert[3].normal = D3DXVECTOR3 (0.0f, 1.0f, 0.0f);
Plane.p_ObjVert[0].texture = D3DXVECTOR2 (0.0f, 0.0f);
Plane.p_ObjVert[1].texture = D3DXVECTOR2 (6.0f, 0.0f);
Plane.p_ObjVert[2].texture = D3DXVECTOR2 (0.0f, 6.0f);
Plane.p_ObjVert[3].texture = D3DXVECTOR2 (6.0f, 6.0f);
Plane.p_ObjInd[0] = 2;
Plane.p_ObjInd[1] = 0;
Plane.p_ObjInd[2] = 1;
Plane.p_ObjInd[3] = 2;
Plane.p_ObjInd[4] = 1;
Plane.p_ObjInd[5] = 3;
Plane.UpdateData ();

Рендеринг их выглядит так:

p_d3d_Device->SetTexture (0, textures[1]);
Plane.Render ();

p_d3d_Device->SetTexture (0, NULL);
Donut.Render ();

p_d3d_Device->SetMaterial (&materials[1]);
Donuts[0].Render ();
p_d3d_Device->SetMaterial (&materials[2]);
Donuts[1].Render ();
p_d3d_Device->SetMaterial (&materials[3]);
Donuts[2].Render ();
p_d3d_Device->SetMaterial (&materials[4]);
Donuts[3].Render ();
p_d3d_Device->SetMaterial (&materials[5]);
Donuts[4].Render ();

Но перед рендерингом еще их нужно немного 'оживить', все-таки урок посвящен анимации объектов:

void UpdateAnimation (void)
{
	Donuts[0].RotateX (-0.01);
	Donuts[1].RotateZ ( 0.02);
	Donuts[2].RotateZ (-0.03);
	Donuts[3].RotateX ( 0.012);
	Donuts[4].RotateY ( 0.015);
	Donuts[0].Transform ();
	Donuts[1].Transform ();
	Donuts[2].Transform ();
	Donuts[3].Transform ();
	Donuts[4].Transform ();
};

а также нужно еще обработать пользовательский ввод:

if(wParam==VK_LEFT) 
{ 
	angel+=D3DXToRadian(-5); 
	Donut.RotateY (D3DXToRadian(-5)); 
	Donut.Transform(); 
};

if(wParam==VK_RIGHT) 
{ 
	angel+=D3DXToRadian(5); 
	Donut.RotateY (D3DXToRadian(5)); 
	Donut.Transform(); 
};

if(wParam==VK_UP) 
{
	Donut.Move (sin(angel), 0.0f, cos(angel));
	Donut.Transform(); 
};

if(wParam==VK_DOWN) 
{
	Donut.Move (-sin(angel), 0.0f, -cos(angel)); 
	Donut.Transform(); 
};
			
if(wParam==VK_HOME) 
{ 
	Donut.Scale (1, 1.1, 1); 
	Donut.Transform(); 
};

if(wParam==VK_END) 
{ 
	Donut.Scale (1, 0.9, 1); 
	Donut.Transform(); 
};

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

стрелки ВЛЕВО/ВПРАВО - вращение большого бублика вокруг своей оси;
стрелки ВВЕРХ/ВНИЗ - перемещение большого бублика вперед и назад, причем направление зависит от поворота;
кнопки HOME/END - масштабирование объекта по оси Y.

на экране вы должны увидеть нечто следующее:

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