1.14 Полигональные сетки (меши) и материалы

#begin

texture string
ignore_face bool
ignore_fog bool
ignore_ray bool

transparency colour

diffuse colour
ambient colour
specular colour
emissive colour
power float

#end

typedef struct D3DMATERIAL9 {
  D3DCOLORVALUE Diffuse;
  D3DCOLORVALUE Ambient;
  D3DCOLORVALUE Specular;
  D3DCOLORVALUE Emissive;
  float         Power;
} D3DMATERIAL9, *LPD3DMATERIAL9;

//-----------------------------------------------------------------------------
// File: Material.h
// Материал, состоящий из текстуры и описания свойств освещения.
//
// Original SourceCode:
// Programming a Multiplayer First Person Shooter in DirectX
// Copyright (c) 2004 Vaughan Young
//-----------------------------------------------------------------------------
#ifndef MATERIAL_H
#define MATERIAL_H

//-----------------------------------------------------------------------------
// Material Class
//-----------------------------------------------------------------------------
class Material : public Resource< Material >
{
public:
	Material( char *name, char *path = "./" );
	virtual ~Material();

	IDirect3DTexture9 *GetTexture();
	D3DMATERIAL9 *GetLighting();
	unsigned long GetWidth();
	unsigned long GetHeight();
	bool GetIgnoreFace();
	bool GetIgnoreFog();
	bool GetIgnoreRay();

private:
	IDirect3DTexture9 *m_texture; // Direct3D texture.
	D3DMATERIAL9 m_lighting; // Свойства освещения.
	unsigned long m_width; // Ширина текстуры.
	unsigned long m_height; // Высота текстуры.
	bool m_ignoreFace; // Показывает, должны ли игнорироваться грани с данным материалом.
	bool m_ignoreFog; // Показывает, должны ли грани с данным материалом игнорировать туман (fog).
	bool m_ignoreRay; // Показывает, должны ли грани с данным материалом игнорировать пересечение
					// световых лучей (ray intersection).
};

#endif

//-----------------------------------------------------------------------------
// File: Material.cpp
// Реализация класса Material, объявленного в Material.h
// Refer to the Material.h interface for more details.
//
// Original SourceCode:
// Programming a Multiplayer First Person Shooter in DirectX
// Copyright (c) 2004 Vaughan Young
//-----------------------------------------------------------------------------
#include "Engine.h"

//-----------------------------------------------------------------------------
// The material class constructor.
//-----------------------------------------------------------------------------
Material::Material( char *name, char *path ) : Resource< Material >( name, path )
{
	D3DXIMAGE_INFO info;

	// Загружаем скрипт для данного материала.
	Script *script = new Script( name, path );

	// Проверяем, имеет ли текстура материала участки прозрачности.
	if( script->GetColourData( "transparency" )->a == 0.0f )
	{
		// Загружаем текстуру без прозрачности.
		D3DXCreateTextureFromFileEx( g_engine->GetDevice(), script->GetStringData( "texture" ), D3DX_DEFAULT, D3DX_DEFAULT,
			D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_FILTER_TRIANGLE, D3DX_FILTER_TRIANGLE, 0, &info, NULL, &m_texture );
	}
	else
	{
		// Загружаем текстуру с выбранным цветом участков прозрачности (key color).
		D3DCOLORVALUE *colour = script->GetColourData( "transparency" );
		D3DCOLOR transparency = D3DCOLOR_COLORVALUE( colour->r, colour->g, colour->b, colour->a );
		D3DXCreateTextureFromFileEx( g_engine->GetDevice(), script->GetStringData( "texture" ), D3DX_DEFAULT, D3DX_DEFAULT,
			D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_FILTER_TRIANGLE, D3DX_FILTER_TRIANGLE, transparency, &info, NULL, &m_texture );
	}

	// Сохраняем ширину и высоту текстуры.
	m_width = info.Width;
	m_height = info.Height;

	// Устанавливаем свойства освещения материала.
	m_lighting.Diffuse = *script->GetColourData( "diffuse" );
	m_lighting.Ambient = *script->GetColourData( "ambient" );
	m_lighting.Specular = *script->GetColourData( "specular" );
	m_lighting.Emissive = *script->GetColourData( "emissive" );
	m_lighting.Power = *script->GetFloatData( "power" );

	// Устанавливаем флаг игнорирования грани с данным материалом.
	m_ignoreFace = *script->GetBoolData( "ignore_face" );

	// Устанавливаем флаг игнорирования тумана гранью с данным материалом.
	m_ignoreFog = *script->GetBoolData( "ignore_fog" );

	// Устанавливаем флаг игнорирования пересечения световых лучей гранью с данным материалом.
	m_ignoreRay = *script->GetBoolData( "ignore_ray" );

	// Уничтожаем скрипт с материалом.
	SAFE_DELETE( script );
}

//-----------------------------------------------------------------------------
// The material class destructor.
//-----------------------------------------------------------------------------
Material::~Material()
{
	SAFE_RELEASE( m_texture );
}

//-----------------------------------------------------------------------------
// Возвращает текстуру материала.
//-----------------------------------------------------------------------------
IDirect3DTexture9 *Material::GetTexture()
{
	return m_texture;
}

//-----------------------------------------------------------------------------
// Возвращает свойства освещения (lighting properties) материала.
//-----------------------------------------------------------------------------
D3DMATERIAL9 *Material::GetLighting()
{
	return &m_lighting;
}

//-----------------------------------------------------------------------------
// Возвращает ширину (width) текстуры материала.
//-----------------------------------------------------------------------------
unsigned long Material::GetWidth()
{
	return m_width;
}

//-----------------------------------------------------------------------------
// Возвращает высоту (height) текстуры материала.
//-----------------------------------------------------------------------------
unsigned long Material::GetHeight()
{
	return m_height;
}

//-----------------------------------------------------------------------------
// Возвращает значения флага игнорирования граней с данным материалом.
//-----------------------------------------------------------------------------
bool Material::GetIgnoreFace()
{
	return m_ignoreFace;
}

//-----------------------------------------------------------------------------
// Возвращает значения флага игнорирования тумана гранями с данным материалом.
//-----------------------------------------------------------------------------
bool Material::GetIgnoreFog()
{
	return m_ignoreFog;
}

//-----------------------------------------------------------------------------
// Возвращает значения флага игнорирования пересечения световых лучей гранями с данным материалом.
//-----------------------------------------------------------------------------
bool Material::GetIgnoreRay()
{
	return m_ignoreRay;
}

...
	// Проверяем, имеет ли текстура материала участки прозрачности.
	if( script->GetColourData( "transparency" )->a == 0.0f )
	{
		// Загружаем текстуру без прозрачности.
		D3DXCreateTextureFromFileEx( g_engine->GetDevice(), script->GetStringData( "texture" ), D3DX_DEFAULT, D3DX_DEFAULT,
			D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_FILTER_TRIANGLE, D3DX_FILTER_TRIANGLE, 0, &info, NULL, &m_texture );
	}
	else
	{
		// Загружаем текстуру с выбранным цветом участков прозрачности (key color).
		D3DCOLORVALUE *colour = script->GetColourData( "transparency" );
		D3DCOLOR transparency = D3DCOLOR_COLORVALUE( colour->r, colour->g, colour->b, colour->a );
		D3DXCreateTextureFromFileEx( g_engine->GetDevice(), script->GetStringData( "texture" ), D3DX_DEFAULT, D3DX_DEFAULT,
			D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_FILTER_TRIANGLE, D3DX_FILTER_TRIANGLE, transparency, &info, NULL, &m_texture );
	}
...

HRESULT D3DXCreateTextureFromFileEx(
  _In_    LPDIRECT3DDEVICE9  pDevice,	// Указатель на интерфейс объекта устройства Direct3D 
  _In_    LPCTSTR            pSrcFile,	// Полное имя файла (имя + путь до него) загружаемой текстуры
  _In_    UINT               Width,		// Ширина (width)
  _In_    UINT               Height,	// и высота (height) текстуры в пикселах
  _In_    UINT               MipLevels,	// Число mip-уровней. Значение D3DX_DEFAULT создаёт полный набор
  _In_    DWORD              Usage,		// Флаги использования ресурса 
  _In_    D3DFORMAT          Format,	// (Цветовой) формат пикселей текстуры 
  _In_    D3DPOOL            Pool,		// Класс памяти, в котором текстура должна быть сохранена
  _In_    DWORD              Filter,	// Флаги фильтрации текстуры 
  _In_    DWORD              MipFilter,	// Флаги MipMap-фильтрации текстуры
  _In_    D3DCOLOR           ColorKey,	// Ключевой цвет прозрачности текстуры.
										// Значение 0 отключает использование прозрачности
  _Inout_ D3DXIMAGE_INFO     *pSrcInfo,	// Описание данных, содержащихся в исходной (source) текстуре
  _Out_   PALETTEENTRY       *pPalette,	// 256-цветная палитра
  _Out_   LPDIRECT3DTEXTURE9 *ppTexture	// Адрес указателя на участок памяти, куда будет сохранена новая текстура
);

...
	// Сохраняем ширину и высоту текстуры.
	m_width = info.Width;
	m_height = info.Height;

	// Устанавливаем свойства освещения материала.
	m_lighting.Diffuse = *script->GetColourData( "diffuse" );
	m_lighting.Ambient = *script->GetColourData( "ambient" );
	m_lighting.Specular = *script->GetColourData( "specular" );
	m_lighting.Emissive = *script->GetColourData( "emissive" );
	m_lighting.Power = *script->GetFloatData( "power" );

	// Устанавливаем флаг игнорирования грани с данным материалом.
	m_ignoreFace = *script->GetBoolData( "ignore_face" );

	// Устанавливаем флаг игнорирования тумана гранью с данным материалом.
	m_ignoreFog = *script->GetBoolData( "ignore_fog" );

	// Устанавливаем флаг игнорирования пересечения световых лучей гранью с данным материалом.
	m_ignoreRay = *script->GetBoolData( "ignore_ray" );

	// Уничтожаем скрипт с материалом.
	SAFE_DELETE( script );
}
...

...
//-----------------------------------------------------------------------------
// The material class destructor.
//-----------------------------------------------------------------------------
Material::~Material()
{
	SAFE_RELEASE( m_texture );
}
...

...
//-----------------------------
// Engine Includes
//-----------------------------
#include "resource.h"
#include "LinkedList.h"
#include "ResourceManagement.h"
#include "Geometry.h"
#include "Font.h"
#include "Scripting.h"
#include "DeviceEnumeration.h"
#include "Input.h"
#include "Network.h"
#include "SoundSystem.h"
#include "Material.h"
#include "State.h"
...

void (*CreateMaterialResource)( Material **resource, char *name, char *path );

CreateMaterialResource = NULL;

...
//-----------------------------------------------------------------------------
// Engine Setup Structure
//-----------------------------------------------------------------------------
struct EngineSetup
{
	HINSTANCE instance; // Application instance handle.
					// Дескриптор инстанса приложения
	GUID guid; // Application GUID.
	char *name; // Name of the application.
	void (*StateSetup)(); // Функция подготовки стейта.
	float scale; // Масштаб (scale) в метрах/футах.
	unsigned char totalBackBuffers; // Число используемых бэкбуферов.
	void (*HandleNetworkMessage)( ReceivedMessage *msg ); // Обработчик сетевых сообщений]

	// Функция создания материала.
	void (*CreateMaterialResource)( Material **resource, char *name, char *path );

	//-------------------------------------------------------------------------
	// The engine setup structure constructor.
	//-------------------------------------------------------------------------
	EngineSetup()
	{
		GUID defaultGUID = { 0x24215591, 0x24c0, 0x4316, { 0xb5, 0xb2, 0x67, 0x98, 0x2c, 0xb3, 0x82, 0x54 } }; 
		instance = NULL;
		name = "Application";
		HandleNetworkMessage = NULL;
		scale = 1.0f;
		totalBackBuffers = 1;
		StateSetup = NULL;
		CreateMaterialResource = NULL;
	}
};
...

ResourceManager< Material > *m_materialManager;

...
	LinkedList< State > *m_states; // Связный список (Linked list) стейтов.
	State *m_currentState; // Указатель на текущий стейт.
	bool m_stateChanged; // Флаг показывает, изменён ли стейт в текущем кадре.
	ResourceManager< Script > *m_scriptManager; // Менеджер скриптов.
	ResourceManager< Material > *m_materialManager;

	Input *m_input;
	Network *m_network; // Объект класса Network.
	SoundSystem *m_soundSystem; // Объект класса SoundSystem.
};
...

ResourceManager< Material > *GetMaterialManager();

...
class Engine
{
public:
	Engine( EngineSetup *setup = NULL );
	virtual ~Engine();

	void Run();

	HWND GetWindow();
	void SetDeactiveFlag( bool deactive );
	float GetScale();
	IDirect3DDevice9 *GetDevice();
	D3DDISPLAYMODE *GetDisplayMode();
	ID3DXSprite *GetSprite();

	void AddState( State *state, bool change = true );
	void RemoveState ( State *state );
	void ChangeState( unsigned long id );
	State *GetCurrentState();
	ResourceManager< Script > *GetScriptManager();
	ResourceManager< Material > *GetMaterialManager();
	Input *GetInput();
	Network *GetNetwork();
	SoundSystem *GetSoundSystem();
...

m_materialManager = new ResourceManager< Material >( m_setup->CreateMaterialResource );

...
	// Своп-цепочка всегда начинается с первого бэкбуфера.
	m_currentBackBuffer = 0;

	// Создаём интерфейс спрайта.
	D3DXCreateSprite( m_device, &m_sprite );

	m_states = new LinkedList< State >;
	m_currentState = NULL;
	m_scriptManager = new ResourceManager< Script >;
	m_materialManager = new ResourceManager< Material >( m_setup->CreateMaterialResource );

	// Создаём экземпляр класса Input.
	m_input = new Input( m_window );
...

SAFE_DELETE( m_materialManager);

...
Engine::~Engine()
{
	// Ensure the engine is loaded.
	// Проверяем, загружен ли движок.
	if( m_loaded == true )
	{
		// Everything will be destroyed here (such as the DirectX components).
		// Здесь всё уничтожаем.
		if( m_currentState != NULL )
		{
			// Уничтожаем связные списки со стейтами.
			m_currentState->Close();
			SAFE_DELETE( m_states );

			SAFE_DELETE( m_soundSystem );
			SAFE_DELETE( m_network );

			// Уничтожаем объект Input.
			SAFE_DELETE( m_input );

			SAFE_DELETE( m_materialManager);
...

//-------------------------------------------------------
// Возвращает указатель на текущий менеджер) материалов.
//-------------------------------------------------------
ResourceManager< Material > *Engine::GetMaterialManager()
{
	return m_materialManager;
}

//-----------------------------------------------------------------------------
// File: BoundingVolume.h
// Используется для хранения ограничивающих объёмов (куб, сфера)
// Дополнительно ограничивающая сфера (bounding sphere) может выступать в качестве 3D-эллипсоида.
//
// Original SourceCode:
// Programming a Multiplayer First Person Shooter in DirectX
// Copyright (c) 2004 Vaughan Young
//-----------------------------------------------------------------------------
#ifndef BOUNDING_VOLUME_H
#define BOUNDING_VOLUME_H

//-----------------------------------------------------------------------------
// Bounding Box Structure
//-----------------------------------------------------------------------------
struct BoundingBox
{
	D3DXVECTOR3 min; // минимальный выступ (extent) ограничивающего куба.
	D3DXVECTOR3 max; // максимальный выступ (extent) ограничивающего куба.
	float halfSize; // Расстояние от центра обёма до наиболее удалённой (further) точки по всем осям.
};

//-----------------------------------------------------------------------------
// Bounding Sphere Structure
//-----------------------------------------------------------------------------
struct BoundingSphere
{
	D3DXVECTOR3 centre; // Центральная точка ограничивающей сферы.
	float radius; // Радиус ограничивающей сферы.
};

//-----------------------------------------------------------------------------
// Bounding Volume Class
//-----------------------------------------------------------------------------
class BoundingVolume
{
public:
	BoundingVolume();
	virtual ~BoundingVolume();

	void BoundingVolumeFromMesh( ID3DXMesh *mesh, D3DXVECTOR3 ellipsoidRadius = D3DXVECTOR3( 1.0f, 1.0f, 1.0f ) );
	void BoundingVolumeFromVertices( D3DXVECTOR3 *vertices, unsigned long totalVertices, unsigned long vertexStride,
		D3DXVECTOR3 ellipsoidRadius = D3DXVECTOR3( 1.0f, 1.0f, 1.0f ) );
	void CloneBoundingVolume( BoundingBox *box, BoundingSphere *sphere, D3DXVECTOR3 ellipsoidRadius = D3DXVECTOR3( 1.0f, 1.0f, 1.0f ) );
	void RepositionBoundingVolume( D3DXMATRIX *location );

	void SetBoundingBox( D3DXVECTOR3 min, D3DXVECTOR3 max );
	BoundingBox *GetBoundingBox();

	void SetBoundingSphere( D3DXVECTOR3 centre, float radius, D3DXVECTOR3 ellipsoidRadius = D3DXVECTOR3( 1.0f, 1.0f, 1.0f ) );
	BoundingSphere *GetBoundingSphere();

	void SetEllipsoidRadius( D3DXVECTOR3 ellipsoidRadius );
	D3DXVECTOR3 GetEllipsoidRadius();

private:
	BoundingBox *m_box; // Репрезентация ограничивающего объёма в виде куба.
	BoundingSphere *m_sphere; // Репрезентация ограничивающего объёма в виде сферы.

	D3DXVECTOR3 m_originalMin; // Исходный (original) минимальный выступ ограничивающего прямоугольника (куба).
	D3DXVECTOR3 m_originalMax; // Исходный (original) минимальный выступ ограничивающего прямоугольника (куба).
	D3DXVECTOR3 m_originalCentre; // Исходная центральная точка ограничивающей сферы.

	D3DXVECTOR3 m_ellipsoidRadius; // Радиус эллипсоида (т.е. радиус по всем осям).
};

#endif

//-----------------------------------------------------------------------------
// File: BoundingVolume.h
// Реализация функций, объявленных в BoundingVolume.h .
// Refer to the BoundingVolume.h interface for more details.
//
// Original SourceCode:
// Programming a Multiplayer First Person Shooter in DirectX
// Copyright (c) 2004 Vaughan Young
//-----------------------------------------------------------------------------
#include "Engine.h"

//-----------------------------------------------------------------------------
// The bounding volume class constructor.
//-----------------------------------------------------------------------------
BoundingVolume::BoundingVolume()
{
	m_box = new BoundingBox;
	m_sphere = new BoundingSphere;

	m_ellipsoidRadius = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
}

//-----------------------------------------------------------------------------
// The bounding volume class destructor.
//-----------------------------------------------------------------------------
BoundingVolume::~BoundingVolume()
{
	SAFE_DELETE( m_box );
	SAFE_DELETE( m_sphere );
}

//-----------------------------------------------------------------------------
// Строит ограничивающий объём, заключающий внутри себя данный 3D-меш.
//-----------------------------------------------------------------------------
void BoundingVolume::BoundingVolumeFromMesh( ID3DXMesh *mesh, D3DXVECTOR3 ellipsoidRadius )
{
	D3DXVECTOR3 *vertices;
	if( SUCCEEDED( mesh->LockVertexBuffer( D3DLOCK_READONLY, (void**)&vertices ) ) )
	{
		D3DXComputeBoundingBox( vertices, mesh->GetNumVertices(), D3DXGetFVFVertexSize( mesh->GetFVF() ), &m_box->min, &m_box->max );
		D3DXComputeBoundingSphere( vertices, mesh->GetNumVertices(), D3DXGetFVFVertexSize( mesh->GetFVF() ), &m_sphere->centre, &m_sphere->radius );
		mesh->UnlockVertexBuffer();
	}

	m_sphere->centre.x = m_box->min.x + ( ( m_box->max.x - m_box->min.x ) / 2.0f );
	m_sphere->centre.y = m_box->min.y + ( ( m_box->max.y - m_box->min.y ) / 2.0f );
	m_sphere->centre.z = m_box->min.z + ( ( m_box->max.z - m_box->min.z ) / 2.0f );

	m_box->halfSize = (float)max( fabs( m_box->max.x ), max( fabs( m_box->max.y ), fabs( m_box->max.z ) ) );
	m_box->halfSize = (float)max( m_box->halfSize, max( fabs( m_box->min.x ), max( fabs( m_box->min.y ), fabs( m_box->min.z ) ) ) );

	m_originalMin = m_box->min;
	m_originalMax = m_box->max;
	m_originalCentre = m_sphere->centre;

	SetEllipsoidRadius( ellipsoidRadius );
}

//-----------------------------------------------------------------------------
// Строит ограничивающий объём, заключающий внутри себя данный список вершин.
//-----------------------------------------------------------------------------
void BoundingVolume::BoundingVolumeFromVertices( D3DXVECTOR3 *vertices, unsigned long totalVertices, unsigned long vertexStride, D3DXVECTOR3 ellipsoidRadius )
{
	D3DXComputeBoundingBox( vertices, totalVertices, vertexStride, &m_box->min, &m_box->max );
	D3DXComputeBoundingSphere( vertices, totalVertices, vertexStride, &m_sphere->centre, &m_sphere->radius );

	m_sphere->centre.x = m_box->min.x + ( ( m_box->max.x - m_box->min.x ) / 2.0f );
	m_sphere->centre.y = m_box->min.y + ( ( m_box->max.y - m_box->min.y ) / 2.0f );
	m_sphere->centre.z = m_box->min.z + ( ( m_box->max.z - m_box->min.z ) / 2.0f );

	m_box->halfSize = (float)max( fabs( m_box->max.x ), max( fabs( m_box->max.y ), fabs( m_box->max.z ) ) );
	m_box->halfSize = (float)max( m_box->halfSize, max( fabs( m_box->min.x ), max( fabs( m_box->min.y ), fabs( m_box->min.z ) ) ) );

	m_originalMin = m_box->min;
	m_originalMax = m_box->max;
	m_originalCentre = m_sphere->centre;

	SetEllipsoidRadius( ellipsoidRadius );
}

//-----------------------------------------------------------------------------
// Строит ограничивающий объём на основе уже имющегося.
//-----------------------------------------------------------------------------
void BoundingVolume::CloneBoundingVolume( BoundingBox *box, BoundingSphere *sphere, D3DXVECTOR3 ellipsoidRadius )
{
	m_box->min = box->min;
	m_box->max = box->max;
	m_sphere->centre = sphere->centre;
	m_sphere->radius = sphere->radius;

	m_box->halfSize = (float)max( fabs( m_box->max.x ), max( fabs( m_box->max.y ), fabs( m_box->max.z ) ) );
	m_box->halfSize = (float)max( m_box->halfSize, max( fabs( m_box->min.x ), max( fabs( m_box->min.y ), fabs( m_box->min.z ) ) ) );

	m_originalMin = m_box->min;
	m_originalMax = m_box->max;
	m_originalCentre = m_sphere->centre;

	SetEllipsoidRadius( ellipsoidRadius );
}

//-----------------------------------------------------------------------------
// Репозиционирует ограничивающий объём (изменяет его текущее положение в 3D-пространстве) на основе данной матрицы.
//-----------------------------------------------------------------------------
void BoundingVolume::RepositionBoundingVolume( D3DXMATRIX *location )
{
	D3DXVec3TransformCoord( &m_box->min, &m_originalMin, location );
	D3DXVec3TransformCoord( &m_box->max, &m_originalMax, location );
	D3DXVec3TransformCoord( &m_sphere->centre, &m_originalCentre, location );
}

//-----------------------------------------------------------------------------
// Устанавливает свойства ограничивающего прямоугольника.
//-----------------------------------------------------------------------------
void BoundingVolume::SetBoundingBox( D3DXVECTOR3 min, D3DXVECTOR3 max )
{
	m_originalMin = m_box->min = min;
	m_originalMax = m_box->max = max;

	m_box->halfSize = (float)max( fabs( m_box->max.x ), max( fabs( m_box->max.y ), fabs( m_box->max.z ) ) );
	m_box->halfSize = (float)max( m_box->halfSize, max( fabs( m_box->min.x ), max( fabs( m_box->min.y ), fabs( m_box->min.z ) ) ) );
}

//-----------------------------------------------------------------------------
// Возвращает текущий ограничивающий прямоугольник объекта.
//-----------------------------------------------------------------------------
BoundingBox *BoundingVolume::GetBoundingBox()
{
	return m_box;
}

//-----------------------------------------------------------------------------
// Устанавливает свойства ограничивающей сферы.
//-----------------------------------------------------------------------------
void BoundingVolume::SetBoundingSphere( D3DXVECTOR3 centre, float radius, D3DXVECTOR3 ellipsoidRadius )
{
	m_originalCentre = m_sphere->centre = centre;
	m_sphere->radius = radius;

	SetEllipsoidRadius( ellipsoidRadius );
}

//-----------------------------------------------------------------------------
// Возвращает текущую ограничивающую сферу объекта.
//-----------------------------------------------------------------------------
BoundingSphere *BoundingVolume::GetBoundingSphere()
{
	return m_sphere;
}

//-----------------------------------------------------------------------------
// Устанавливает радиусы эллипсоида в процентном соотношениии к радиусу сферы.
//-----------------------------------------------------------------------------
void BoundingVolume::SetEllipsoidRadius( D3DXVECTOR3 ellipsoidRadius )
{
	m_ellipsoidRadius = D3DXVECTOR3( m_sphere->radius * ellipsoidRadius.x, m_sphere->radius * ellipsoidRadius.y, m_sphere->radius * ellipsoidRadius.z );
}

//-----------------------------------------------------------------------------
// Возвращает радиус данного эллипсоида.
//-----------------------------------------------------------------------------
D3DXVECTOR3 BoundingVolume::GetEllipsoidRadius()
{
	return m_ellipsoidRadius;
}

HRESULT D3DXComputeBoundingBox(
  _In_  const D3DXVECTOR3 *pFirstPosition,	// Указатель на первую вершину вершинного буфера меша
  _In_        DWORD       NumVertices,		// Общее число вершин вершинного буфера меша
								// Можно выяснить, вызвав функцию GetNumVertices (экспонирована интерфейсом ID3DXMesh).
  _In_        DWORD       dwStride,	// Размер каждой вершины в байтах. Можно выяснить, вызвав функцию
								// D3DXGetFVFVertexSize, передав в неё указатель на FVF-структуру.
  _Out_       D3DXVECTOR3 *pMin,
  _Out_       D3DXVECTOR3 *pMax
);

LPDIRECT3DVERTEXBUFFER9 VertexBuffer = NULL;
D3DXVECTOR3* Vertices = NULL;
D3DXVECTOR3 LowerLeftСогnег;
D3DXVECTOR3 UpperRightCorner;

DWORD FVFVertexSire = D3DXGetFVFVertexSize(g_pMesh->GetFVF());
g_pMesh->GetVertexBuffer(&VertexBuffer) ;
VertexBuffer->Lock(0 , 0, (VOID**) &Vertices, D3DLOCK_DISCARD) ;

D3DXComputeBoundingBox(Vertices, g_pMesh->GetNumVertices() , FVFVertexSize, &LowerLeftCorner, &UpperRightCorner);

VertexBuffer->Unlock();
VertexBuffer->Release();

HRESULT D3DXComputeBoundingSphere(
  _In_  const D3DXVECTOR3 *pFirstPosition,	// Указатель на первую вершину вершинного буфера меша
  _In_        DWORD       NumVertices,		// Общее число вершин вершинного буфера меша
						// Можно выяснить, вызвав функцию GetNurnVertices (экспонирована интерфейсом ID3DXMesh).
  _In_        DWORD       dwStride,		// Размер каждой вершины в байтах
					// Можно выяснить, вызвав функцию DSDXGetFVFVerteicSize, передав в неё указатели на FVF-структуру.
  _Out_       D3DXVECTOR3 *pCenter,
  _Out_       FLOAT       *pRadius
);

LPDIRECT3DVERTEXBUFFER9 VertexBuffer = NULL;
D3DXVECTOR3* Vertices = NULL;
D3DXVECTOR3 Center;
FLOAT Radius;

DWORD FVFVertexSize = D3DXGetFVFVertexSize (g_pMesh->GetFVF () );
g_pMesh->GetVertexBuffer( SVertexBuffer );
VertexBuffer->Lock(0, 0, (VOID**) &Vertices, D3DLOCK_DISCARD);

D3DXComputeBoundingSphere(Vertices, g_pMesh->GetNumVertices(), FVFVertexSize, &Center, &Radius);

VertexBuffer->Unlock();
VertexBuffer->Release();

#include "Engine.h"

#include "BoundingVolume.h"

...
//-----------------------------
// Engine Includes
//-----------------------------
#include "resource.h"
#include "LinkedList.h"
#include "ResourceManagement.h"
#include "Geometry.h"
#include "Font.h"
#include "Scripting.h"
#include "DeviceEnumeration.h"
#include "Input.h"
#include "Network.h"
#include "SoundSystem.h"
#include "BoundingVolume.h"
#include "Material.h"
#include "State.h"
...

typedef struct D3DXFRAME
{	// Имя фрейма
	LPSTR	Name;

// Матрица, определяющая трансформацию фрейма
	D3DXMATRIX	TransformatiоnMatrix;

// Указатель на контейнер) с ЗD-мешем
	LPD3EXMESHCONTAINER pMeshContainer;

// Указатели на одноуровневый (sibling) и дочерний (child) фреймы
	D3DXFRAME *pFгameSibling;
	D3DXFRAME *pFгаmеFiгstСhild;
} D3DXFRAME,	*LPD3DXFRAME;

typedef struct D3DXMESHCONTAINER {
  LPSTR                Name;		// Имя меша
  D3DXMESHDATA         MeshData;	// Определяет тип меша и хранит его данные
  LPD3DXMATERIAL       pMaterials;	// Массив материалов, используемых мешем (данные освещения) 
  LPD3DXEFFECTINSTANCE pEffects;	// Указатель на эффекты. Пока не будем его использовать
  DWORD                NumMaterials;	// Общее число материалов в массиве
  DWORD                *pAdjacency;		// Информация о регулировке (тонкой настройке) граней меша
  LPD3DXSKININFO       pSkinInfo;	// Указатель на информацию о скине (skin). Используется для мешей
									// со скинами (skinned meshes)
  D3DXMESHCONTAINER    *pNextMeshContainer;	// Указатель на следующий меш в списке
} D3DXMESHCONTAINER, *LPD3DXMESHCONTAINER;

//-----------------------------------------------------------------------------
// File: Mesh.h
// Применяется для загрузки и управления статичных (static) и
// анимированных (animated) 3D-мешей.
//
// Original Sourcecode:
// Programming a Multiplayer First Person Shooter in DirectX
// Copyright (c) 2004 Vaughan Young
//-----------------------------------------------------------------------------
#ifndef MESH_H
#define MESH_H

//-----------------------------------------------------------------------------
// Frame Structure
//-----------------------------------------------------------------------------
struct Frame : public D3DXFRAME
{
	D3DXMATRIX finalTransformationMatrix; // Финальная трансформация фрейма перед тем, как он будет скомбинирован со своим родителем.

	//-------------------------------------------------------------------------
	// Возвращает трансляцию (translation) фрейма.
	//-------------------------------------------------------------------------
	D3DXVECTOR3 GetTranslation()
	{
		return D3DXVECTOR3( finalTransformationMatrix._41, finalTransformationMatrix._42, finalTransformationMatrix._43 );
	}
};

//-----------------------------------------------------------------------------
// Mesh Container Structure
//-----------------------------------------------------------------------------
struct MeshContainer : public D3DXMESHCONTAINER
{
	char **materialNames; // Временный массив имён материала.
	Material **materials; // Массив материалов, используемых меш-контейнером (mesh container).
	ID3DXMesh *originalMesh; // Исходный (original) меш.
	D3DXATTRIBUTERANGE *attributeTable; // Таблица атрибутов меша.
	unsigned long totalAttributeGroups; // Общее количество групп атрибутов.
	D3DXMATRIX **boneMatrixPointers; // Массив указателей на матрицы трансформации костей (bone transformation matrices).
};

//-----------------------------------------------------------------------------
// Allocate Hierarchy Class
//-----------------------------------------------------------------------------
class AllocateHierarchy : public ID3DXAllocateHierarchy
{
	STDMETHOD( CreateFrame )( THIS_ LPCSTR Name, LPD3DXFRAME *ppNewFrame );
	STDMETHOD( CreateMeshContainer )( THIS_ LPCSTR Name, CONST D3DXMESHDATA *pMeshData, CONST D3DXMATERIAL *pMaterials,
		CONST D3DXEFFECTINSTANCE *pEffectInstances, DWORD NumMaterials, CONST DWORD *pAdjacency, LPD3DXSKININFO pSkinInfo,
		LPD3DXMESHCONTAINER *ppNewMeshContainer );
	STDMETHOD( DestroyFrame )( THIS_ LPD3DXFRAME pFrameToFree );
	STDMETHOD( DestroyMeshContainer )( THIS_ LPD3DXMESHCONTAINER pMeshContainerToFree );
};

//-----------------------------------------------------------------------------
// Mesh Class
//-----------------------------------------------------------------------------
class Mesh : public BoundingVolume, public Resource< Mesh >
{
public:
	Mesh( char *name, char *path = "./" );
	virtual ~Mesh();

	void Update();
	void Render();

	void CloneAnimationController( ID3DXAnimationController **animationController );

	MeshContainer *GetStaticMesh();
	Vertex *GetVertices();
	unsigned short *GetIndices();

	LinkedList< Frame > *GetFrameList();
	Frame *GetFrame( char *name );
	Frame *GetReferencePoint( char *name );

private:
	void PrepareFrame( Frame *frame );
	void UpdateFrame( Frame *frame, D3DXMATRIX *parentTransformationMatrix = NULL );
	void RenderFrame( Frame *frame );

private:
	Frame *m_firstFrame; // Первый (топовый) фрейм в иерархии фреймов меша.
	ID3DXAnimationController *m_animationController; // Контроллер анимации.

	D3DXMATRIX *m_boneMatrices; // Массив матриц трансформации костей (bone transformation matrices).
	unsigned long m_totalBoneMatrices; // Число костей в массиве.

	MeshContainer *m_staticMesh; // Статичная (неанимированная) версия меша.
	Vertex *m_vertices; // Массив вершин из статичного меша.
	unsigned short *m_indices; // Массив индексов в массиве вершин.

	LinkedList< Frame > *m_frames; // Связный список (linked list) указателей на все фреймы меша.
	LinkedList< Frame > *m_refPoints; // Связный список (linked list) указателей на все референсные точки (reference points) меша.
};

#endif

...
//-----------------------------------------------------------------------------
// Frame Structure
//-----------------------------------------------------------------------------
struct Frame : public D3DXFRAME
{
	D3DXMATRIX finalTransformationMatrix; // Финальная трансформация фрейма перед тем, как он будет скомбинирован со своим родителем.

	//-------------------------------------------------------------------------
	// Возвращает трансляцию (translation) фрейма.
	//-------------------------------------------------------------------------
	D3DXVECTOR3 GetTranslation()
	{
		return D3DXVECTOR3( finalTransformationMatrix._41, finalTransformationMatrix._42, finalTransformationMatrix._43 );
	}
};
...

...
//-----------------------------------------------------------------------------
// Mesh Container Structure
//-----------------------------------------------------------------------------
struct MeshContainer : public D3DXMESHCONTAINER
{
	char **materialNames; // Временный массив имён материала.
	Material **materials; // Массив материалов, используемых меш-контейнером (mesh container).
	ID3DXMesh *originalMesh; // Исходный (original) меш.
	D3DXATTRIBUTERANGE *attributeTable; // Таблица атрибутов меша.
	unsigned long totalAttributeGroups; // Общее количество групп атрибутов.
	D3DXMATRIX **boneMatrixPointers; // Массив указателей на матрицы трансформации костей (bone transformation matrices).
};
...

typedef struct D3DXMATRIX {
	FLOAT _11,	FLOAT _12,	FLOAT	_13,	FLOAT _14
	FLOAT _21,	FLOAT _22,	FLOAT	_23,	FLOAT _24
	FLOAT _31,	FLOAT _32,	FLOAT	_33,	FLOAT _34
	FLOAT _41,	FLOAT _42,	FLOAT	_43,	FLOAT _44
}D3DXMATRIX;

...
//-----------------------------------------------------------------------------
// Allocate Hierarchy Class
//-----------------------------------------------------------------------------
class AllocateHierarchy : public ID3DXAllocateHierarchy
{
	STDMETHOD( CreateFrame )( THIS_ LPCSTR Name, LPD3DXFRAME *ppNewFrame );
	STDMETHOD( CreateMeshContainer )( THIS_ LPCSTR Name, CONST D3DXMESHDATA *pMeshData, CONST D3DXMATERIAL *pMaterials,
		CONST D3DXEFFECTINSTANCE *pEffectInstances, DWORD NumMaterials, CONST DWORD *pAdjacency, LPD3DXSKININFO pSkinInfo,
		LPD3DXMESHCONTAINER *ppNewMeshContainer );
	STDMETHOD( DestroyFrame )( THIS_ LPD3DXFRAME pFrameToFree );
	STDMETHOD( DestroyMeshContainer )( THIS_ LPD3DXMESHCONTAINER pMeshContainerToFree );
};
...

HRESULT ID3DXAllocateHierarchy::CreateFrame(
  [in]          LPCSTR      Name,
  [out, retval] LPD3DXFRAME *ppNewFrame
);

HRESULT ID3DXAllocateHierarchy::CreateMeshContainer(
  [in]                LPCSTR              Name,
  [in]          const D3DXMESHDATA        *pMeshData,
  [in]          const D3DXMATERIAL        *pMaterials,
  [in]          const D3DXEFFECTINSTANCE  *pEffectInstances,
  [in]                DWORD               NumMaterials,
  [in]          const DWORD               *pAdjacency,
  [in]                LPD3DXSKININFO      pSkinInfo,
  [out, retval]       LPD3DXMESHCONTAINER *ppNewMeshContainer
);

HRESULT ID3DXAllocateHierarchy::DestroyFrame(
  [in] LPD3DXFRAME pFrameToFree
);

HRESULT DestroyMeshContainer(
  [in] LPD3DXMESHCONTAINER ID3DXAllocateHierarchy::pMeshContainerToFree
);

...
//-----------------------------------------------------------------------------
// Mesh Class
//-----------------------------------------------------------------------------
class Mesh : public BoundingVolume, public Resource< Mesh >
{
public:
	Mesh( char *name, char *path = "./" );
	virtual ~Mesh();

	void Update();
	void Render();

	void CloneAnimationController( ID3DXAnimationController **animationController );

	MeshContainer *GetStaticMesh();
	Vertex *GetVertices();
	unsigned short *GetIndices();

	LinkedList< Frame > *GetFrameList();
	Frame *GetFrame( char *name );
	Frame *GetReferencePoint( char *name );

private:
	void PrepareFrame( Frame *frame );
	void UpdateFrame( Frame *frame, D3DXMATRIX *parentTransformationMatrix = NULL );
	void RenderFrame( Frame *frame );

private:
	Frame *m_firstFrame; // Первый (топовый) фрейм в иерархии фреймов меша.
	ID3DXAnimationController *m_animationController; // Контроллер анимации.

	D3DXMATRIX *m_boneMatrices; // Массив матриц трансформации костей (bone transformation matrices).
	unsigned long m_totalBoneMatrices; // Число костей в массиве.

	MeshContainer *m_staticMesh; // Статичная (неанимированная) версия меша.
	Vertex *m_vertices; // Массив вершин из статичного меша.
	unsigned short *m_indices; // Массив индексов в массиве вершин.

	LinkedList< Frame > *m_frames; // Связный список (linked list) указателей на все фреймы меша.
	LinkedList< Frame > *m_refPoints; // Связный список (linked list) указателей на все референсные точки (reference points) меша.
};
...

//-----------------------------------------------------------------------------
// File: Mesh.cpp
// Реализация функций, объявленных в Mesh.h.
//
// Original Sourcecode:
// Programming a Multiplayer First Person Shooter in DirectX
// Copyright (c) 2004 Vaughan Young
//-----------------------------------------------------------------------------
#include "Engine.h"

//-----------------------------------------------------------------------------
// Создаёт новый фрейм.
//-----------------------------------------------------------------------------
HRESULT AllocateHierarchy::CreateFrame( THIS_ LPCSTR Name, LPD3DXFRAME *ppNewFrame )
{
	// Создаём новый фрейм и обнуляем его память.
	Frame *frame = new Frame;
	ZeroMemory( frame, sizeof( Frame ) );

	// Копируем имя фрейма.
	if( Name == NULL )
	{
		// Имя отсутствует, поэтому создаём уникальное имя.
		static unsigned long nameCount = 0;
		char newName[32];
		sprintf( newName, "unknown_frame_%d", nameCount );
		nameCount++;

		frame->Name = new char[strlen( newName ) + 1];
		strcpy( frame->Name, newName );
	}
	else
	{
		frame->Name = new char[strlen( Name ) + 1];
		strcpy( frame->Name, Name );
	}

	*ppNewFrame = frame;

	return S_OK;
}

//-----------------------------------------------------------------------------
// Создаёт новый меш-контейнер.
//-----------------------------------------------------------------------------
HRESULT AllocateHierarchy::CreateMeshContainer( THIS_ LPCSTR Name, CONST D3DXMESHDATA *pMeshData,
	CONST D3DXMATERIAL *pMaterials, CONST D3DXEFFECTINSTANCE *pEffectInstances, DWORD NumMaterials,
	CONST DWORD *pAdjacency, LPD3DXSKININFO pSkinInfo, LPD3DXMESHCONTAINER *ppNewMeshContainer )
{
	// Создаём новый меш-контейнер и обнуляем его память.
	MeshContainer *meshContainer = new MeshContainer;
	ZeroMemory( meshContainer, sizeof( MeshContainer ) );

	// Копируем имя меша.
	if( Name == NULL )
	{
		// Имя отсутствует, поэтому создаём уникальное имя.
		static unsigned long nameCount = 0;
		char newName[32];
		sprintf( newName, "unknown_mesh_%d", nameCount );
		nameCount++;

		meshContainer->Name = new char[strlen( newName ) + 1];
		strcpy( meshContainer->Name, newName );
	}
	else
	{
		meshContainer->Name = new char[strlen( Name ) + 1];
		strcpy( meshContainer->Name, Name );
	}

	// Проверяем, есть ли у меша какие-либо материалы.
	if( ( meshContainer->NumMaterials = NumMaterials ) > 0 )
	{
		// Выделяем память для материалов меша, а также их имён (т.е. имён текстур).
		meshContainer->materials = new Material*[meshContainer->NumMaterials];
		meshContainer->materialNames = new char*[meshContainer->NumMaterials];

		// Сохраняем все имена материалов (текстур).
		for( unsigned long m = 0; m < NumMaterials; m++ )
		{
			if( pMaterials[m].pTextureFilename )
			{
				meshContainer->materialNames[m] = new char[strlen( pMaterials[m].pTextureFilename ) + 1];
				memcpy( meshContainer->materialNames[m], pMaterials[m].pTextureFilename,
					( strlen( pMaterials[m].pTextureFilename ) + 1 ) * sizeof( char ) );
			}
			else
				meshContainer->materialNames[m] = NULL;

			meshContainer->materials[m] = NULL;
		}
	}

	// Сохраняем информацию о текущих настройках меша (mesh's adjacency information).
	meshContainer->pAdjacency = new DWORD[pMeshData->pMesh->GetNumFaces() * 3];
	memcpy( meshContainer->pAdjacency, pAdjacency, sizeof( DWORD ) * pMeshData->pMesh->GetNumFaces() * 3 );

	// Сохраняем данные меша.
	meshContainer->MeshData.pMesh = meshContainer->originalMesh = pMeshData->pMesh;
	meshContainer->MeshData.Type = D3DXMESHTYPE_MESH;
	pMeshData->pMesh->AddRef();
	pMeshData->pMesh->AddRef();

	// Проверяем, является ли меш скинированным (skinned mesh).
	if( pSkinInfo != NULL )
	{
		// Сохраняем информацию о скине и о меше.
		meshContainer->pSkinInfo = pSkinInfo;
		pSkinInfo->AddRef();

		// Клонируем исходный меш для создания скинированного (skinned) меша.
		meshContainer->originalMesh->CloneMeshFVF( D3DXMESH_MANAGED, meshContainer->originalMesh->GetFVF(),
			g_engine->GetDevice(), &meshContainer->MeshData.pMesh );

		// Сохраняем таблицу атрибутов.
		meshContainer->MeshData.pMesh->GetAttributeTable( NULL, &meshContainer->totalAttributeGroups );
		meshContainer->attributeTable = new D3DXATTRIBUTERANGE[meshContainer->totalAttributeGroups];
		meshContainer->MeshData.pMesh->GetAttributeTable( meshContainer->attributeTable, NULL );
	}

	*ppNewMeshContainer = meshContainer;

	return S_OK;
}

//-----------------------------------------------------------------------------
// Уничтожает данный фрейм.
//-----------------------------------------------------------------------------
HRESULT AllocateHierarchy::DestroyFrame( THIS_ LPD3DXFRAME pFrameToFree )
{
	SAFE_DELETE_ARRAY( pFrameToFree->Name );
	SAFE_DELETE( pFrameToFree );

	return S_OK;
}

//-----------------------------------------------------------------------------
// Уничтожает данный меш-контейнер.
//-----------------------------------------------------------------------------
HRESULT AllocateHierarchy::DestroyMeshContainer( THIS_ LPD3DXMESHCONTAINER pMeshContainerToFree )
{
	MeshContainer *meshContainer = (MeshContainer*)pMeshContainerToFree;

	// Удаляет все материалы меша из менеджера материалов.
	for( unsigned long m = 0; m < meshContainer->NumMaterials; m++ )
		if( meshContainer->materials )
			g_engine->GetMaterialManager()->Remove( &meshContainer->materials[m] );

	// Уничтожает меш-контейнер.
	SAFE_DELETE_ARRAY( meshContainer->Name );
	SAFE_DELETE_ARRAY( meshContainer->pAdjacency );
	SAFE_DELETE_ARRAY( meshContainer->pMaterials );
	SAFE_DELETE_ARRAY( meshContainer->materialNames );
	SAFE_DELETE_ARRAY( meshContainer->materials );
	SAFE_DELETE_ARRAY( meshContainer->boneMatrixPointers );
	SAFE_DELETE_ARRAY( meshContainer->attributeTable );
	SAFE_RELEASE( meshContainer->MeshData.pMesh );
	SAFE_RELEASE( meshContainer->pSkinInfo );
	SAFE_RELEASE( meshContainer->originalMesh );
	SAFE_DELETE( meshContainer );

	return S_OK;
}

//-----------------------------------------------------------------------------
// The mesh class constructor.
//-----------------------------------------------------------------------------
Mesh::Mesh( char *name, char *path ) : Resource< Mesh >( name, path )
{
	// Создаём список опорных точек (reference points).
	m_frames = new LinkedList< Frame >;
	m_refPoints = new LinkedList< Frame >;

	// Загружаем иерархию меша.
	AllocateHierarchy ah;
	D3DXLoadMeshHierarchyFromX( GetFilename(), D3DXMESH_MANAGED, g_engine->GetDevice(), &ah, NULL, (D3DXFRAME**)&m_firstFrame, &m_animationController );

	// Изначально отключаем все треки анимации (animation tracks).
	if( m_animationController != NULL )
		for( unsigned long t = 0; t < m_animationController->GetMaxNumTracks(); ++t )
			m_animationController->SetTrackEnable( t, false );

	// Обнуляем (Invalidate) массив матрицы трансформации костей (bone transformation matrices array).
	m_boneMatrices = NULL;
	m_totalBoneMatrices = 0;

	// Подготавливаем иерархию фреймов.
	PrepareFrame( m_firstFrame );

	// Выделяем память для матриц трансформации костей.
	m_boneMatrices = new D3DXMATRIX[m_totalBoneMatrices];

	// Создаём статичную (неанимированную) версию меша.
	m_staticMesh = new MeshContainer;
	ZeroMemory( m_staticMesh, sizeof( MeshContainer ) );

	// Загружаем меш.
	ID3DXBuffer *materialBuffer, *adjacencyBuffer;
	D3DXLoadMeshFromX( GetFilename(), D3DXMESH_MANAGED, g_engine->GetDevice(), &adjacencyBuffer,
		&materialBuffer, NULL, &m_staticMesh->NumMaterials, &m_staticMesh->originalMesh );

	// Оптимизируем меш для лучшей производительности рендеринга.
	m_staticMesh->originalMesh->OptimizeInplace( D3DXMESHOPT_COMPACT | D3DXMESHOPT_ATTRSORT
		| D3DXMESHOPT_VERTEXCACHE, (DWORD*)adjacencyBuffer->GetBufferPointer(), NULL, NULL, NULL );

	// Закончили работать с буфером подстройки (adjacency buffer), поэтому уничтожаем его.
	SAFE_RELEASE( adjacencyBuffer );

	// Проверяем, есть ли у меша материалы.
	if( m_staticMesh->NumMaterials > 0 )
	{
		// Создаём массив материалов.
		m_staticMesh->materials = new Material*[m_staticMesh->NumMaterials];

		// Получаем список материалов из буфера материалов.
		D3DXMATERIAL *materials = (D3DXMATERIAL*)materialBuffer->GetBufferPointer();

		// Загружаем каждый материал в массив через менеджер материалов.
		for( unsigned long m = 0; m < m_staticMesh->NumMaterials; m++ )
		{
			// Убеждаемся, что материал имеет текстуру.
			if( materials[m].pTextureFilename )
			{
				// Получаем имя скрипта материала и загружаем его.
				char *name = new char[strlen( materials[m].pTextureFilename ) + 5];
				sprintf( name, "%s.txt", materials[m].pTextureFilename );
				m_staticMesh->materials[m] = g_engine->GetMaterialManager()->Add( name, GetPath() );
				SAFE_DELETE_ARRAY( name );
			}
			else
				m_staticMesh->materials[m] = NULL;
		}
	}

	// Создаём ограничивающий объём вокруг меша.
	BoundingVolumeFromMesh( m_staticMesh->originalMesh );

	// Уничтожаем буфер материалов.
	SAFE_RELEASE( materialBuffer );

	// Создаём массив вершин (vertex array) и массив индексов (array of indices) в нём.
	m_vertices = new Vertex[m_staticMesh->originalMesh->GetNumVertices()];
	m_indices = new unsigned short[m_staticMesh->originalMesh->GetNumFaces() * 3];

	// Используем массивы для сохранения локальной копии массива вершин статичного меша и
	// индексов, чтобы затем их можно было использовать в менеджере сцены что называется "на лету".
	Vertex* verticesPtr;
	m_staticMesh->originalMesh->LockVertexBuffer( 0, (void**)&verticesPtr );
	unsigned short *indicesPtr;
	m_staticMesh->originalMesh->LockIndexBuffer( 0, (void**)&indicesPtr );

	memcpy( m_vertices, verticesPtr, VERTEX_FVF_SIZE * m_staticMesh->originalMesh->GetNumVertices() );
	memcpy( m_indices, indicesPtr, sizeof( unsigned short ) * m_staticMesh->originalMesh->GetNumFaces() * 3 );

	m_staticMesh->originalMesh->UnlockVertexBuffer();
	m_staticMesh->originalMesh->UnlockIndexBuffer();
}

//-----------------------------------------------------------------------------
// The mesh class destructor.
//-----------------------------------------------------------------------------
Mesh::~Mesh()
{
	// Уничтожаем иерархию фреймов.
	AllocateHierarchy ah;
	D3DXFrameDestroy( m_firstFrame, &ah );

	// Уничтожаем список фреймов и список опорных точек (reference points list).
	m_frames->ClearPointers();
	SAFE_DELETE( m_frames );
	m_refPoints->ClearPointers();
	SAFE_DELETE( m_refPoints );

	// Освобождаем контроллер анимации.
	SAFE_RELEASE( m_animationController );

	// Уничтожаем матрицы (преобразования, деформации) костей.
	SAFE_DELETE_ARRAY( m_boneMatrices );

	// Уничтожаем статичный меш.
	if( m_staticMesh )
	{
		// Удаляем все текстуры статичного меша.
		for( unsigned long m = 0; m < m_staticMesh->NumMaterials; m++ )
			if( m_staticMesh->materials )
				g_engine->GetMaterialManager()->Remove( &m_staticMesh->materials[m] );

		// Подчищаем остальное.
		SAFE_DELETE_ARRAY( m_staticMesh->materials );
		SAFE_RELEASE( m_staticMesh->originalMesh );
		SAFE_DELETE( m_staticMesh );
	}

	// Уничтожаем массивы вершин и индексов вершин.
	SAFE_DELETE_ARRAY( m_vertices );
	SAFE_DELETE_ARRAY( m_indices );
}

//-----------------------------------------------------------------------------
// Обновляет меш.
//-----------------------------------------------------------------------------
void Mesh::Update()
{
	UpdateFrame( m_firstFrame );
}

//-----------------------------------------------------------------------------
// Рендерит меш.
//-----------------------------------------------------------------------------
void Mesh::Render()
{
	RenderFrame( m_firstFrame );
}

//-----------------------------------------------------------------------------
// Создаёт клон контроллера анимации меша (mesh's animation controller).
//-----------------------------------------------------------------------------
void Mesh::CloneAnimationController( ID3DXAnimationController **animationController )
{
	if( m_animationController )
		m_animationController->CloneAnimationController( m_animationController->GetMaxNumAnimationOutputs(),
		m_animationController->GetMaxNumAnimationSets(), m_animationController->GetMaxNumTracks(),
		m_animationController->GetMaxNumEvents(), &*animationController );
	else
		*animationController = NULL;
}

//-----------------------------------------------------------------------------
// Возвращает статичную (не анимированную) версию меша.
//-----------------------------------------------------------------------------
MeshContainer *Mesh::GetStaticMesh()
{
	return m_staticMesh;
}

//-----------------------------------------------------------------------------
// Возвращает статичные (не анимированные) вершины меша.
//-----------------------------------------------------------------------------
Vertex *Mesh::GetVertices()
{
	return m_vertices;
}

//-----------------------------------------------------------------------------
// Возвращает индексы вершин меша.
//-----------------------------------------------------------------------------
unsigned short *Mesh::GetIndices()
{
	return m_indices;
}

//-----------------------------------------------------------------------------
// Возвращает список фреймов в меше.
//-----------------------------------------------------------------------------
LinkedList< Frame > *Mesh::GetFrameList()
{
	return m_frames;
}

//-----------------------------------------------------------------------------
// Возвращает фрейм с данным именем.
//-----------------------------------------------------------------------------
Frame *Mesh::GetFrame( char *name )
{
	m_frames->Iterate( true );
	while( m_frames->Iterate() )
		if( strcmp( m_frames->GetCurrent()->Name, name ) == 0 )
			return m_frames->GetCurrent();

	return NULL;
}

//-----------------------------------------------------------------------------
// Возвращает опорную точку (reference point) с данным именем.
//-----------------------------------------------------------------------------
Frame *Mesh::GetReferencePoint( char *name )
{
	m_refPoints->Iterate( true );
	while( m_refPoints->Iterate() )
		if( strcmp( m_refPoints->GetCurrent()->Name, name ) == 0 )
			return m_refPoints->GetCurrent();

	return NULL;
}

//-----------------------------------------------------------------------------
// Подготавливает данный фрейм.
//-----------------------------------------------------------------------------
void Mesh::PrepareFrame( Frame *frame )
{
	m_frames->Add( frame );

	// Проверяем, является ли данный фрейм опорной точкой.
	if( strncmp( "rp_", frame->Name, 3 ) == 0 )
		m_refPoints->Add( frame );

	// Устанавливаем исходную финальную трансформацию.
	frame->finalTransformationMatrix = frame->TransformationMatrix;

	// Подготавливаем меш-контейнер фрейма, если таковой имеется.
	if( frame->pMeshContainer != NULL )
	{
		MeshContainer *meshContainer = (MeshContainer*)frame->pMeshContainer;

		// Проверяем, является ли данный меш скинированным (skinned).
		if( meshContainer->pSkinInfo != NULL )
		{
			// Создаём массив указателей матрицы (преобразования) костей.
			meshContainer->boneMatrixPointers = new D3DXMATRIX*[meshContainer->pSkinInfo->GetNumBones()];

			// Устанавливаем указатели на матрицы трансформации костей меша.
			for( unsigned long b = 0; b < meshContainer->pSkinInfo->GetNumBones(); b++ )
			{
				Frame *bone = (Frame*)D3DXFrameFind( m_firstFrame, meshContainer->pSkinInfo->GetBoneName( b ) );
				if( bone == NULL )
					continue;

				meshContainer->boneMatrixPointers[b] = &bone->finalTransformationMatrix;
			}

			// Отслеживаем, сколько костей содержится во всех меш-контейнерах.
			if( m_totalBoneMatrices < meshContainer->pSkinInfo->GetNumBones() )
				m_totalBoneMatrices = meshContainer->pSkinInfo->GetNumBones();
		}

		// Проверяем, есть ли у меша материал.
		if( meshContainer->NumMaterials > 0 )
		{
			// Загружаем все материалы через менеджер материалов.
			for( unsigned long m = 0; m < meshContainer->NumMaterials; m++ )
			{
				// Убеждаемся, что материал содержит текстуру.
				if( meshContainer->materialNames[m] != NULL )
				{
					// Получаем имя скрипта материала и загружаем его.
					char *name = new char[strlen( meshContainer->materialNames[m] ) + 5];
					sprintf( name, "%s.txt", meshContainer->materialNames[m] );
					meshContainer->materials[m] = g_engine->GetMaterialManager()->Add( name, GetPath() );
					SAFE_DELETE_ARRAY( name );
				}
			}
		}
	}

	// Подготавливаем одноуровневые фреймы (siblings) данного фрейма.
	if( frame->pFrameSibling != NULL )
		PrepareFrame( (Frame*)frame->pFrameSibling );

	// Подготавливаем дочерние (нижестоящие) фреймы (childrens) данного фрейма.
	if( frame->pFrameFirstChild != NULL )
		PrepareFrame( (Frame*)frame->pFrameFirstChild );
}

//-----------------------------------------------------------------------------
// Обновляет матрицы преобразований данного фрейма.
//-----------------------------------------------------------------------------
void Mesh::UpdateFrame( Frame *frame, D3DXMATRIX *parentTransformationMatrix )
{
	if( parentTransformationMatrix != NULL )
		D3DXMatrixMultiply( &frame->finalTransformationMatrix, &frame->TransformationMatrix, parentTransformationMatrix );
	else
		frame->finalTransformationMatrix = frame->TransformationMatrix;

	// Обновляем одноуровневые фреймы (siblings) данного фрейма.
	if( frame->pFrameSibling != NULL )
		UpdateFrame( (Frame*)frame->pFrameSibling, parentTransformationMatrix );

	// Обновляем дочерние (нижестоящие) фреймы (childrens) данного фрейма.
	if( frame->pFrameFirstChild != NULL )
		UpdateFrame( (Frame*)frame->pFrameFirstChild, &frame->finalTransformationMatrix );
}

//-----------------------------------------------------------------------------
// Рендерит меш-контейнеры данного фрейма, если таковые имеются.
//-----------------------------------------------------------------------------
void Mesh::RenderFrame( Frame *frame )
{
	MeshContainer *meshContainer = (MeshContainer*)frame->pMeshContainer;

	// Рендерим меш данного фрейма, если таковой имеется.
	if( frame->pMeshContainer != NULL )
	{
		// Проверяем, является ли данный меш скинированным (skined).
		if( meshContainer->pSkinInfo != NULL )
		{
			// Создаём трансформации костей с использованием матриц преобразования меша.
			for( unsigned long b = 0; b < meshContainer->pSkinInfo->GetNumBones(); ++b )
				D3DXMatrixMultiply( &m_boneMatrices[b], meshContainer->pSkinInfo->GetBoneOffsetMatrix( b ), meshContainer->boneMatrixPointers[b] );

			// Обновляем вершины меша с учётом матриц преобразований меша.
			PBYTE sourceVertices, destinationVertices;
			meshContainer->originalMesh->LockVertexBuffer( D3DLOCK_READONLY, (void**)&sourceVertices );
			meshContainer->MeshData.pMesh->LockVertexBuffer( 0, (void**)&destinationVertices );
			meshContainer->pSkinInfo->UpdateSkinnedMesh( m_boneMatrices, NULL, sourceVertices, destinationVertices );
			meshContainer->originalMesh->UnlockVertexBuffer();
			meshContainer->MeshData.pMesh->UnlockVertexBuffer();

			// Рендерим меш по группам атрибутов.
			for( unsigned long a = 0; a < meshContainer->totalAttributeGroups; a++ )
			{
				g_engine->GetDevice()->SetMaterial( meshContainer->materials[meshContainer->attributeTable[a].AttribId]->GetLighting() );
				g_engine->GetDevice()->SetTexture( 0, meshContainer->materials[meshContainer->attributeTable[a].AttribId]->GetTexture() );
				meshContainer->MeshData.pMesh->DrawSubset( meshContainer->attributeTable[a].AttribId );
			}
		}
		else
		{
			// Это не скинированный меш, поэтому его будем рендерить как статичный (static).
			for( unsigned long m = 0; m < meshContainer->NumMaterials; m++)
			{
				if( meshContainer->materials[m] )
				{
					g_engine->GetDevice()->SetMaterial( meshContainer->materials[m]->GetLighting() );
					g_engine->GetDevice()->SetTexture( 0, meshContainer->materials[m]->GetTexture() );
				}
				else
					g_engine->GetDevice()->SetTexture( 0, NULL );

				meshContainer->MeshData.pMesh->DrawSubset( m );
			}
		}
	}

	// Рендерим одноуровневые фреймы (siblings) данного фрейма.
	if( frame->pFrameSibling != NULL )
		RenderFrame( (Frame*)frame->pFrameSibling );

	// Рендерим дочерние (нижестоящие в иерархии) фреймы (childrens) данного фрейма.
	if( frame->pFrameFirstChild != NULL )
		RenderFrame( (Frame*)frame->pFrameFirstChild );
}

...
//-----------------------------------------------------------------------------
// Создаёт новый фрейм.
//-----------------------------------------------------------------------------
HRESULT AllocateHierarchy::CreateFrame( THIS_ LPCSTR Name, LPD3DXFRAME *ppNewFrame )
{
	// Создаём новый фрейм и обнуляем его память.
	Frame *frame = new Frame;
	ZeroMemory( frame, sizeof( Frame ) );

	// Копируем имя фрейма.
	if( Name == NULL )
	{
		// Имя отсутствует, поэтому создаём уникальное имя.
		static unsigned long nameCount = 0;
		char newName[32];
		sprintf( newName, "unknown_frame_%d", nameCount );
		nameCount++;

		frame->Name = new char[strlen( newName ) + 1];
		strcpy( frame->Name, newName );
	}
	else
	{
		frame->Name = new char[strlen( Name ) + 1];
		strcpy( frame->Name, Name );
	}

	*ppNewFrame = frame;

	return S_OK;
}
...

...
//-----------------------------------------------------------------------------
// Уничтожает данный фрейм.
//-----------------------------------------------------------------------------
HRESULT AllocateHierarchy::DestroyFrame( THIS_ LPD3DXFRAME pFrameToFree )
{
	SAFE_DELETE_ARRAY( pFrameToFree->Name );
	SAFE_DELETE( pFrameToFree );

	return S_OK;
}
...

...
//-----------------------------------------------------------------------------
// Уничтожает данный меш-контейнер.
//-----------------------------------------------------------------------------
HRESULT AllocateHierarchy::DestroyMeshContainer( THIS_ LPD3DXMESHCONTAINER pMeshContainerToFree )
{
	MeshContainer *meshContainer = (MeshContainer*)pMeshContainerToFree;

	// Удаляет все материалы меша из менеджера материалов.
	for( unsigned long m = 0; m < meshContainer->NumMaterials; m++ )
		if( meshContainer->materials )
			g_engine->GetMaterialManager()->Remove( &meshContainer->materials[m] );

	// Уничтожает меш-контейнер.
	SAFE_DELETE_ARRAY( meshContainer->Name );
	SAFE_DELETE_ARRAY( meshContainer->pAdjacency );
	SAFE_DELETE_ARRAY( meshContainer->pMaterials );
	SAFE_DELETE_ARRAY( meshContainer->materialNames );
	SAFE_DELETE_ARRAY( meshContainer->materials );
	SAFE_DELETE_ARRAY( meshContainer->boneMatrixPointers );
	SAFE_DELETE_ARRAY( meshContainer->attributeTable );
	SAFE_RELEASE( meshContainer->MeshData.pMesh );
	SAFE_RELEASE( meshContainer->pSkinInfo );
	SAFE_RELEASE( meshContainer->originalMesh );
	SAFE_DELETE( meshContainer );

	return S_OK;
}
...

...
//-----------------------------------------------------------------------------
// The mesh class constructor.
//-----------------------------------------------------------------------------
Mesh::Mesh( char *name, char *path ) : Resource< Mesh >( name, path )
{
	// Создаём список опорных точек (reference points).
	m_frames = new LinkedList< Frame >;
	m_refPoints = new LinkedList< Frame >;

	// Загружаем иерархию меша.
	AllocateHierarchy ah;
	D3DXLoadMeshHierarchyFromX( GetFilename(), D3DXMESH_MANAGED, g_engine->GetDevice(), &ah, NULL, (D3DXFRAME**)&m_firstFrame, &m_animationController );

	// Изначально отключаем все треки анимации (animation tracks).
	if( m_animationController != NULL )
		for( unsigned long t = 0; t < m_animationController->GetMaxNumTracks(); ++t )
			m_animationController->SetTrackEnable( t, false );

	// Обнуляем (Invalidate) массив матрицы трансформации костей (bone transformation matrices array).
	m_boneMatrices = NULL;
	m_totalBoneMatrices = 0;

	// Подготавливаем иерархию фреймов.
	PrepareFrame( m_firstFrame );

	// Выделяем память для матриц трансформации костей.
	m_boneMatrices = new D3DXMATRIX[m_totalBoneMatrices];

	// Создаём статичную (неанимированную) версию меша.
	m_staticMesh = new MeshContainer;
	ZeroMemory( m_staticMesh, sizeof( MeshContainer ) );

	// Загружаем меш.
	ID3DXBuffer *materialBuffer, *adjacencyBuffer;
	D3DXLoadMeshFromX( GetFilename(), D3DXMESH_MANAGED, g_engine->GetDevice(), &adjacencyBuffer,
		&materialBuffer, NULL, &m_staticMesh->NumMaterials, &m_staticMesh->originalMesh );

	// Оптимизируем меш для лучшей производительности рендеринга.
	m_staticMesh->originalMesh->OptimizeInplace( D3DXMESHOPT_COMPACT | D3DXMESHOPT_ATTRSORT
		| D3DXMESHOPT_VERTEXCACHE, (DWORD*)adjacencyBuffer->GetBufferPointer(), NULL, NULL, NULL );

	// Закончили работать с буфером подстройки (adjacency buffer), поэтому уничтожаем его.
	SAFE_RELEASE( adjacencyBuffer );

	// Проверяем, есть ли у меша материалы.
	if( m_staticMesh->NumMaterials > 0 )
	{
		// Создаём массив материалов.
		m_staticMesh->materials = new Material*[m_staticMesh->NumMaterials];

		// Получаем список материалов из буфера материалов.
		D3DXMATERIAL *materials = (D3DXMATERIAL*)materialBuffer->GetBufferPointer();

		// Загружаем каждый материал в массив через менеджер материалов.
		for( unsigned long m = 0; m < m_staticMesh->NumMaterials; m++ )
		{
			// Убеждаемся, что материал имеет текстуру.
			if( materials[m].pTextureFilename )
			{
				// Получаем имя скрипта материала и загружаем его.
				char *name = new char[strlen( materials[m].pTextureFilename ) + 5];
				sprintf( name, "%s.txt", materials[m].pTextureFilename );
				m_staticMesh->materials[m] = g_engine->GetMaterialManager()->Add( name, GetPath() );
				SAFE_DELETE_ARRAY( name );
			}
			else
				m_staticMesh->materials[m] = NULL;
		}
	}

	// Создаём ограничивающий объём вокруг меша.
	BoundingVolumeFromMesh( m_staticMesh->originalMesh );

	// Уничтожаем буфер материалов.
	SAFE_RELEASE( materialBuffer );

	// Создаём массив вершин (vertex array) и массив индексов (array of indices) в нём.
	m_vertices = new Vertex[m_staticMesh->originalMesh->GetNumVertices()];
	m_indices = new unsigned short[m_staticMesh->originalMesh->GetNumFaces() * 3];

	// Используем массивы для сохранения локальной копии массива вершин статичного меша и
	// индексов, чтобы затем их можно было использовать в менеджере сцены что называется "на лету".
	Vertex* verticesPtr;
	m_staticMesh->originalMesh->LockVertexBuffer( 0, (void**)&verticesPtr );
	unsigned short *indicesPtr;
	m_staticMesh->originalMesh->LockIndexBuffer( 0, (void**)&indicesPtr );

	memcpy( m_vertices, verticesPtr, VERTEX_FVF_SIZE * m_staticMesh->originalMesh->GetNumVertices() );
	memcpy( m_indices, indicesPtr, sizeof( unsigned short ) * m_staticMesh->originalMesh->GetNumFaces() * 3 );

	m_staticMesh->originalMesh->UnlockVertexBuffer();
	m_staticMesh->originalMesh->UnlockIndexBuffer();
}
...

...
	// Загружаем иерархию меша.
	AllocateHierarchy ah;
	D3DXLoadMeshHierarchyFromX( GetFilename(), D3DXMESH_MANAGED, g_engine->GetDevice(), &ah, NULL, (D3DXFRAME**)&m_firstFrame, &m_animationController );
...

HRESULT D3DXLoadMeshHierarchyFromX(
  _In_  LPCTSTR                   Filename,		// Полное имя файла (имя + путь до него) загружаемого .х-файла
  _In_  DWORD                     MeshOptions,	// Опциональные флаги создания меша
  _In_  LPDIRECT3DDEVICE9         pDevice,		// Указатель на экземпляр устройства Direct3D будет ассоциирован
												// создаваемый меш
  _In_  LPD3DXALLOCATEHIERARCHY   pAlloc,		// Указатель на интерфейс IEPEXAllocateHierarchy
  _In_  LPD3DXLOADUSERDATA        pUserDataLoader,	// Указатель на интерфейс для загрузки данных, специфичных для приложения
  _Out_ LPD3DXFRAME               *ppFrameHierarchy,	// Возвращённый указатель на первый кадр в загруженной иерархии
  _Out_ LPD3DXANIMATIONCONTROLLER *ppAnimController		// Возвращённый указатель на контроллер анимации меша
);

typedef enum D3DXMESH { 
  D3DXMESH_32BIT                  = 0x001,
  D3DXMESH_DONOTCLIP              = 0x002,
  D3DXMESH_POINTS                 = 0x004,
  D3DXMESH_RTPATCHES              = 0x008,
  D3DXMESH_NPATCHES               = 0x4000,
  D3DXMESH_VB_SYSTEMMEM           = 0x010,
  D3DXMESH_VB_MANAGED             = 0x020,
  D3DXMESH_VB_WRITEONLY           = 0x040,
  D3DXMESH_VB_DYNAMIC             = 0x080,
  D3DXMESH_VB_SOFTWAREPROCESSING  = 0x8000,
  D3DXMESH_IB_SYSTEMMEM           = 0x100,
  D3DXMESH_IB_MANAGED             = 0x200,
  D3DXMESH_IB_WRITEONLY           = 0x400,
  D3DXMESH_IB_DYNAMIC             = 0x800,
  D3DXMESH_IB_SOFTWAREPROCESSING  = 0x10000,
  D3DXMESH_VB_SHARE               = 0x1000,
  D3DXMESH_USEHWONLY              = 0x2000,
  D3DXMESH_SYSTEMMEM              = 0x110,
  D3DXMESH_MANAGED                = 0x220,
  D3DXMESH_WRITEONLY              = 0x440,
  D3DXMESH_DYNAMIC                = 0x880,
  D3DXMESH_SOFTWAREPROCESSING     = 0x18000
} D3DXMESH, *LPD3DXMESH;

typedef struct D3DXFRAME {
  LPSTR               Name;
  D3DXMATRIX          TransformationMatrix;
  LPD3DXMESHCONTAINER pMeshContainer;
  D3DXFRAME           *pFrameSibling;
  D3DXFRAME           *pFrameFirstChild;
} D3DXFRAME, *LPD3DXFRAME;

...
	// Подготавливаем иерархию фреймов.
	PrepareFrame( m_firstFrame );
...

...
//-----------------------------------------------------------------------------
// Подготавливает данный фрейм.
//-----------------------------------------------------------------------------
void Mesh::PrepareFrame( Frame *frame )
{
	m_frames->Add( frame );

	// Проверяем, является ли данный фрейм опорной точкой.
	if( strncmp( "rp_", frame->Name, 3 ) == 0 )
		m_refPoints->Add( frame );

	// Устанавливаем исходную финальную трансформацию.
	frame->finalTransformationMatrix = frame->TransformationMatrix;

	// Подготавливаем меш-контейнер фрейма, если таковой имеется.
	if( frame->pMeshContainer != NULL )
	{
		MeshContainer *meshContainer = (MeshContainer*)frame->pMeshContainer;

		// Проверяем, является ли данный меш скинированным (skinned).
		if( meshContainer->pSkinInfo != NULL )
		{
			// Создаём массив указателей матрицы (преобразования) костей.
			meshContainer->boneMatrixPointers = new D3DXMATRIX*[meshContainer->pSkinInfo->GetNumBones()];

			// Устанавливаем указатели на матрицы трансформации костей меша.
			for( unsigned long b = 0; b < meshContainer->pSkinInfo->GetNumBones(); b++ )
			{
				Frame *bone = (Frame*)D3DXFrameFind( m_firstFrame, meshContainer->pSkinInfo->GetBoneName( b ) );
				if( bone == NULL )
					continue;

				meshContainer->boneMatrixPointers[b] = &bone->finalTransformationMatrix;
			}

			// Отслеживаем, сколько костей содержится во всех меш-контейнерах.
			if( m_totalBoneMatrices < meshContainer->pSkinInfo->GetNumBones() )
				m_totalBoneMatrices = meshContainer->pSkinInfo->GetNumBones();
		}

		// Проверяем, есть ли у меша материал.
		if( meshContainer->NumMaterials > 0 )
		{
			// Загружаем все материалы через менеджер материалов.
			for( unsigned long m = 0; m < meshContainer->NumMaterials; m++ )
			{
				// Убеждаемся, что материал содержит текстуру.
				if( meshContainer->materialNames[m] != NULL )
				{
					// Получаем имя скрипта материала и загружаем его.
					char *name = new char[strlen( meshContainer->materialNames[m] ) + 5];
					sprintf( name, "%s.txt", meshContainer->materialNames[m] );
					meshContainer->materials[m] = g_engine->GetMaterialManager()->Add( name, GetPath() );
					SAFE_DELETE_ARRAY( name );
				}
			}
		}
	}

	// Подготавливаем одноуровневые фреймы (siblings) данного фрейма.
	if( frame->pFrameSibling != NULL )
		PrepareFrame( (Frame*)frame->pFrameSibling );

	// Подготавливаем дочерние (нижестоящие) фреймы (childrens) данного фрейма.
	if( frame->pFrameFirstChild != NULL )
		PrepareFrame( (Frame*)frame->pFrameFirstChild );
}
...

void Count(int number, int CountTo)
{
	number++;
	printf( "%d\n", number);
		
	if(number < CountTo)
		Count( number, CountTo );
}

...
	// Подготавливаем одноуровневые фреймы (siblings) данного фрейма.
	if( frame->pFrameSibling != NULL )
		PrepareFrame( (Frame*)frame->pFrameSibling );

	// Подготавливаем дочерние (нижестоящие) фреймы (childrens) данного фрейма.
	if( frame->pFrameFirstChild != NULL )
		PrepareFrame( (Frame*)frame->pFrameFirstChild );
}
...

...
	// Подготавливаем меш-контейнер фрейма, если таковой имеется.
	if( frame->pMeshContainer != NULL )
	{
		MeshContainer *meshContainer = (MeshContainer*)frame->pMeshContainer;

		// Проверяем, является ли данный меш скинированным (skinned).
		if( meshContainer->pSkinInfo != NULL )
		{
			// Создаём массив указателей матрицы (преобразования) костей.
			meshContainer->boneMatrixPointers = new D3DXMATRIX*[meshContainer->pSkinInfo->GetNumBones()];

			// Устанавливаем указатели на матрицы трансформации костей меша.
			for( unsigned long b = 0; b < meshContainer->pSkinInfo->GetNumBones(); b++ )
			{
				Frame *bone = (Frame*)D3DXFrameFind( m_firstFrame, meshContainer->pSkinInfo->GetBoneName( b ) );
				if( bone == NULL )
					continue;

				meshContainer->boneMatrixPointers[b] = &bone->finalTransformationMatrix;
			}

			// Отслеживаем, сколько костей содержится во всех меш-контейнерах.
			if( m_totalBoneMatrices < meshContainer->pSkinInfo->GetNumBones() )
				m_totalBoneMatrices = meshContainer->pSkinInfo->GetNumBones();
		}
...

...
		// Проверяем, есть ли у меша материал.
		if( meshContainer->NumMaterials > 0 )
		{
			// Загружаем все материалы через менеджер материалов.
			for( unsigned long m = 0; m < meshContainer->NumMaterials; m++ )
			{
				// Убеждаемся, что материал содержит текстуру.
				if( meshContainer->materialNames[m] != NULL )
				{
					// Получаем имя скрипта материала и загружаем его.
					char *name = new char[strlen( meshContainer->materialNames[m] ) + 5];
					sprintf( name, "%s.txt", meshContainer->materialNames[m] );
					meshContainer->materials[m] = g_engine->GetMaterialManager()->Add( name, GetPath() );
					SAFE_DELETE_ARRAY( name );
				}
			}
		}
	}
...

...
	// Создаём статичную (неанимированную) версию меша.
	m_staticMesh = new MeshContainer;
	ZeroMemory( m_staticMesh, sizeof( MeshContainer ) );

	// Загружаем меш.
	ID3DXBuffer *materialBuffer, *adjacencyBuffer;
	D3DXLoadMeshFromX( GetFilename(), D3DXMESH_MANAGED, g_engine->GetDevice(), &adjacencyBuffer,
		&materialBuffer, NULL, &m_staticMesh->NumMaterials, &m_staticMesh->originalMesh );

	// Оптимизируем меш для лучшей производительности рендеринга.
	m_staticMesh->originalMesh->OptimizeInplace( D3DXMESHOPT_COMPACT | D3DXMESHOPT_ATTRSORT
		| D3DXMESHOPT_VERTEXCACHE, (DWORD*)adjacencyBuffer->GetBufferPointer(), NULL, NULL, NULL );
...

...
	// Оптимизируем меш для лучшей производительности рендеринга.
	m_staticMesh->originalMesh->OptimizeInplace( D3DXMESHOPT_COMPACT | D3DXMESHOPT_ATTRSORT
		| D3DXMESHOPT_VERTEXCACHE, (DWORD*)adjacencyBuffer->GetBufferPointer(), NULL, NULL, NULL );
...

HRESULT ID3DXMesh::OptimizeInplace(
  [in]        DWORD        Flags,
  [in]  const DWORD        *pAdjacencyIn,
  [out]       DWORD        *pAdjacencyOut,
  [out]       DWORD        *pFaceRemap,
  [out]       LPD3DXBUFFER *ppVertexRemap
);

...
	// Создаём ограничивающий объём вокруг меша.
	BoundingVolumeFromMesh( m_staticMesh->originalMesh );
...

...
//-----------------------------------------------------------------------------
// Обновляет меш.
//-----------------------------------------------------------------------------
void Mesh::Update()
{
	UpdateFrame( m_firstFrame );
}

//-----------------------------------------------------------------------------
// Рендерит меш.
//-----------------------------------------------------------------------------
void Mesh::Render()
{
	RenderFrame( m_firstFrame );
}
...

...
//-----------------------------------------------------------------------------
// Обновляет матрицы преобразований данного фрейма.
//-----------------------------------------------------------------------------
void Mesh::UpdateFrame( Frame *frame, D3DXMATRIX *parentTransformationMatrix )
{
	if( parentTransformationMatrix != NULL )
		D3DXMatrixMultiply( &frame->finalTransformationMatrix, &frame->TransformationMatrix, parentTransformationMatrix );
	else
		frame->finalTransformationMatrix = frame->TransformationMatrix;

	// Обновляем одноуровневые фреймы (siblings) данного фрейма.
	if( frame->pFrameSibling != NULL )
		UpdateFrame( (Frame*)frame->pFrameSibling, parentTransformationMatrix );

	// Обновляем дочерние (нижестоящие) фреймы (childrens) данного фрейма.
	if( frame->pFrameFirstChild != NULL )
		UpdateFrame( (Frame*)frame->pFrameFirstChild, &frame->finalTransformationMatrix );
}
...

...
//-----------------------------------------------------------------------------
// Рендерит меш-контейнеры данного фрейма, если таковые имеются.
//-----------------------------------------------------------------------------
void Mesh::RenderFrame( Frame *frame )
{
	MeshContainer *meshContainer = (MeshContainer*)frame->pMeshContainer;

	// Рендерим меш данного фрейма, если таковой имеется.
	if( frame->pMeshContainer != NULL )
	{
		// Проверяем, является ли данный меш скинированным (skined).
		if( meshContainer->pSkinInfo != NULL )
		{
			// Создаём трансформации костей с использованием матриц преобразования меша.
			for( unsigned long b = 0; b < meshContainer->pSkinInfo->GetNumBones(); ++b )
				D3DXMatrixMultiply( &m_boneMatrices[b], meshContainer->pSkinInfo->GetBoneOffsetMatrix( b ), meshContainer->boneMatrixPointers[b] );

			// Обновляем вершины меша с учётом матриц преобразований меша.
			PBYTE sourceVertices, destinationVertices;
			meshContainer->originalMesh->LockVertexBuffer( D3DLOCK_READONLY, (void**)&sourceVertices );
			meshContainer->MeshData.pMesh->LockVertexBuffer( 0, (void**)&destinationVertices );
			meshContainer->pSkinInfo->UpdateSkinnedMesh( m_boneMatrices, NULL, sourceVertices, destinationVertices );
			meshContainer->originalMesh->UnlockVertexBuffer();
			meshContainer->MeshData.pMesh->UnlockVertexBuffer();

			// Рендерим меш по группам атрибутов.
			for( unsigned long a = 0; a < meshContainer->totalAttributeGroups; a++ )
			{
				g_engine->GetDevice()->SetMaterial( meshContainer->materials[meshContainer->attributeTable[a].AttribId]->GetLighting() );
				g_engine->GetDevice()->SetTexture( 0, meshContainer->materials[meshContainer->attributeTable[a].AttribId]->GetTexture() );
				meshContainer->MeshData.pMesh->DrawSubset( meshContainer->attributeTable[a].AttribId );
			}
		}
		else
		{
			// Это не скинированный меш, поэтому его будем рендерить как статичный (static).
			for( unsigned long m = 0; m < meshContainer->NumMaterials; m++)
			{
				if( meshContainer->materials[m] )
				{
					g_engine->GetDevice()->SetMaterial( meshContainer->materials[m]->GetLighting() );
					g_engine->GetDevice()->SetTexture( 0, meshContainer->materials[m]->GetTexture() );
				}
				else
					g_engine->GetDevice()->SetTexture( 0, NULL );

				meshContainer->MeshData.pMesh->DrawSubset( m );
			}
		}
	}

	// Рендерим одноуровневые фреймы (siblings) данного фрейма.
	if( frame->pFrameSibling != NULL )
		RenderFrame( (Frame*)frame->pFrameSibling );

	// Рендерим дочерние (нижестоящие в иерархии) фреймы (childrens) данного фрейма.
	if( frame->pFrameFirstChild != NULL )
		RenderFrame( (Frame*)frame->pFrameFirstChild );
}
...

...
//-----------------------------
// Engine Includes
//-----------------------------
#include "resource.h"
#include "LinkedList.h"
#include "ResourceManagement.h"
#include "Geometry.h"
#include "Font.h"
#include "Scripting.h"
#include "DeviceEnumeration.h"
#include "Input.h"
#include "Network.h"
#include "SoundSystem.h"
#include "BoundingVolume.h"
#include "Material.h"
#include "Mesh.h"
#include "State.h"
...

ResourceManager< Mesh > *m_meshManager;

...
	LinkedList< State > *m_states; // Связный список (Linked list) стейтов.
	State *m_currentState; // Указатель на текущий стейт.
	bool m_stateChanged; // Флаг показывает, изменён ли стейт в текущем кадре.
	ResourceManager< Script > *m_scriptManager; // Менеджер скриптов.
	ResourceManager< Material > *m_materialManager;
	ResourceManager< Mesh > *m_meshManager;
...

ResourceManager< Mesh > *GetMeshManager();

...
	void AddState( State *state, bool change = true );
	void RemoveState ( State *state );
	void ChangeState( unsigned long id );
	State *GetCurrentState();
	ResourceManager< Script > *GetScriptManager();
	ResourceManager< Material > *GetMaterialManager();
	ResourceManager< Mesh > *GetMeshManager();
...

m_meshManager = new ResourceManager< Mesh >;

...
	m_states = new LinkedList< State >;
	m_currentState = NULL;
	m_scriptManager = new ResourceManager< Script >;
	m_materialManager = new ResourceManager< Material >( m_setup->CreateMaterialResource );
	m_meshManager = new ResourceManager< Mesh >;

	// Создаём экземпляр класса Input.
	m_input = new Input( m_window );
...

SAFE_DELETE( m_meshManager);

...
			SAFE_DELETE( m_soundSystem );
			SAFE_DELETE( m_network );

			// Уничтожаем объект Input.
			SAFE_DELETE( m_input );

			SAFE_DELETE( m_meshManager);
...

...
//-----------------------------------------------------------------------------
// Возвращает указатель на текущий менеджер мешей.
//-----------------------------------------------------------------------------
ResourceManager< Mesh > *Engine::GetMeshManager()
{
	return m_meshManager;
}
...

//-----------------------------------------------------------------------------
// File: RenderCache.h
//
// Version: 1.0
//
// Description: Manages the rendering of indexed faces from a set of vertices.
// Управляет рендерингом индексированных граней из набора вершин.
//
// Change History
// ~~~~~~~~~~~~~~
// v1.0 (17/02/04) - Inception.
//
// Copyright (c) 2004 Vaughan Young
//-----------------------------------------------------------------------------
#ifndef RENDER_CACHE_H
#define RENDER_CACHE_H

//-----------------------------------------------------------------------------
// Render Cache Class
//-----------------------------------------------------------------------------
class RenderCache
{
public:
	RenderCache( IDirect3DDevice9 *device, Material *material );
	virtual ~RenderCache();

	void AddFace();
	void Prepare( unsigned long totalVertices );

	void Begin();
	void RenderFace( unsigned short vertex0, unsigned short vertex1, unsigned short vertex2 );
	void End();

	Material *GetMaterial();

private:
	IDirect3DDevice9 *m_device; // Указатель на объект устройства Direct3D.
	Material *m_material; // Указатель на материал, используемый данным рендер-кэшем.

	IDirect3DIndexBuffer9 *m_indexBuffer; // Индексный буфер, указывающий на вершины, подлежащие рендерингу.
	unsigned short *m_indexPointer; // Указатель для доступа к индексному буферу из других функций и классов.
	unsigned long m_totalIndices; // Общее число индексов, которое поддерживает данный индексный буфер.
	unsigned long m_faces; // Общее число граней, готовящихся к рендерингу.

	unsigned long m_totalVertices; // ќбщее число вершин.
};

#endif

//-----------------------------------------------------------------------------
// File: RenderCache.cpp
//
// Description: RenderCache.h implementation.
//              Refer to the RenderCache.h interface for more details.
// Реализация класса RenderCache, объявленного в RenderCache.h
//
// Copyright (c) 2004 Vaughan Young
//-----------------------------------------------------------------------------
#include "Engine.h"

//-----------------------------------------------------------------------------
// The render cache class constructor.
//-----------------------------------------------------------------------------
RenderCache::RenderCache( IDirect3DDevice9 *device, Material *material )
{
	m_device = device;

	m_material = material;

	m_indexBuffer = NULL;
	m_totalIndices = 0;
}

//-----------------------------------------------------------------------------
// The render cache class destructor.
//-----------------------------------------------------------------------------
RenderCache::~RenderCache()
{
	SAFE_RELEASE( m_indexBuffer );
}

//-----------------------------------------------------------------------------
// Увеличиваем размер рендер-кэша для управления ещё одной гранью.
//-----------------------------------------------------------------------------
void RenderCache::AddFace()
{
	m_totalIndices += 3;
}

//-----------------------------------------------------------------------------
// Подготавливаем рендер-кэш к использованию. Функция вызывается не раньше установки размера рендер-кэша.
//-----------------------------------------------------------------------------
void RenderCache::Prepare( unsigned long totalVertices )
{
	// Устанавливаем общее число вершин, готовящихся к рендерингу.
	m_totalVertices = totalVertices;

	// Создаём индексный буфер рендер-кэша.
	m_device->CreateIndexBuffer( m_totalIndices * sizeof( unsigned short ), D3DUSAGE_WRITEONLY, D3DFMT_INDEX16, D3DPOOL_MANAGED, &m_indexBuffer, NULL );
}

//-----------------------------------------------------------------------------
// Информируем рендер-кэш о том, что рендеринг уже начался.
//-----------------------------------------------------------------------------
void RenderCache::Begin()
{
	m_indexBuffer->Lock( 0, 0, (void**)&m_indexPointer, 0 );

	m_faces = 0;
}

//-----------------------------------------------------------------------------
// Добавить индексы вершин данной грани, готовящейся к рендерингу.
//-----------------------------------------------------------------------------
void RenderCache::RenderFace( unsigned short vertex0, unsigned short vertex1, unsigned short vertex2 )
{
	*m_indexPointer++ = vertex0;
	*m_indexPointer++ = vertex1;
	*m_indexPointer++ = vertex2;

	m_faces++;
}

//-----------------------------------------------------------------------------
// Информируем рендер-кэш о том, что рендеринг окончен, поэтому пусть рендерит грани.
//-----------------------------------------------------------------------------
void RenderCache::End()
{
	// Разблокируем (unlock) буфер индексов.
	m_indexBuffer->Unlock();

	// Проверяем, есть ли грани, готовящиеся к рендерингу.
	if( m_faces == 0 )
		return;

	// Проверяем, должен ли материал игнорировать туман.
	if( m_material->GetIgnoreFog() == true )
		m_device->SetRenderState( D3DRS_FOGENABLE, false );

	// Назначаем материал и текстуру.
	m_device->SetMaterial( m_material->GetLighting() );
	m_device->SetTexture( 0, m_material->GetTexture() );

	// Назначаем индексы нужных вершин для рендеринга корректных граней.
	m_device->SetIndices( m_indexBuffer );

	// Рендерим все грани.
	m_device->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, 0, m_totalVertices, 0, m_faces );

	// Восстанавливаем настройки тумана, если те были изменены.
	if( m_material->GetIgnoreFog() == true )
		m_device->SetRenderState( D3DRS_FOGENABLE, true );
}

//-----------------------------------------------------------------------------
// Возвращает указатель на материал, используемый данным рендер-кэшем.
//-----------------------------------------------------------------------------
Material *RenderCache::GetMaterial()
{
	return m_material;
}

...
//-----------------------------
// Engine Includes
//-----------------------------
#include "resource.h"
#include "LinkedList.h"
#include "ResourceManagement.h"
#include "Geometry.h"
#include "Font.h"
#include "Scripting.h"
#include "DeviceEnumeration.h"
#include "Input.h"
#include "Network.h"
#include "SoundSystem.h"
#include "BoundingVolume.h"
#include "Material.h"
#include "Mesh.h"
#include "RenderCache.h"
#include "State.h"
...

//-----------------------------------------------------------------------------
// System Includes
//-----------------------------------------------------------------------------
#include <windows.h>

//-----------------------------------------------------------------------------
// Engine Includes
//-----------------------------------------------------------------------------
#include "..\GameProject01\Engine.h"

//-----------------------------------------------------------------------------
// Test State Class
//-----------------------------------------------------------------------------
class TestState : public State
{
public:
	//-------------------------------------------------------------------------
	// Allows the test state to preform any pre-processing construction.
	//-------------------------------------------------------------------------
	virtual void Load()
	{
		m_mesh = new Mesh( "Gun.x", "./Assets/" );

		// Устанавливаем подходящую матрицу просмотра для просмотра тестового меша.
		D3DXMATRIX view;
		D3DXMatrixLookAtLH( &view, &D3DXVECTOR3( -50.0f, 50.0f, -150.0f ), &D3DXVECTOR3( 0.0f, 0.0f, 0.0f ), &D3DXVECTOR3( 0.0f, 1.0f, 0.0f ) );
		g_engine->GetDevice()->SetTransform( D3DTS_VIEW, &view );	
	};

	//--------------------------------------
	// Перемещаем камеру по нажатию клавиш на клавиатуре...
	//----------------------------------------
	virtual void Update(float elapsed)
	{
		static D3DXVECTOR3 pos = D3DXVECTOR3( -50.0f, 50.0f, -150.0f);
			if (g_engine->GetInput()->GetKeyPress(DIK_W, true) == true) pos.z += 0.05f;
			if (g_engine->GetInput()->GetKeyPress(DIK_S, true) == true) pos.z -= 0.05f;
			if (g_engine->GetInput()->GetKeyPress(DIK_A, true) == true) pos.x -= 0.05f;
			if (g_engine->GetInput()->GetKeyPress(DIK_D, true) == true) pos.x += 0.05f;

		D3DXMATRIX view;
		D3DXMatrixLookAtLH(&view, &pos, &D3DXVECTOR3(pos.x + 50.f, pos.y - 50.0f, pos.z + 150.0f),
			&D3DXVECTOR3(0.0f, 1.0f, 0.0f));

		g_engine->GetDevice()->SetTransform(D3DTS_VIEW, &view);
	}

	//-------------------------------------------------------------------------
	// Allows the test state to preform any post-processing destruction.
	//-------------------------------------------------------------------------
	virtual void Close()
	{
		SAFE_DELETE( m_mesh );
	};

	//-------------------------------------------------------------------------
	// Возвращает текущие настройки вьюера для данного кадра.
	//-------------------------------------------------------------------------
	virtual void RequestViewer( ViewerSetup *viewer )
	{
		viewer->viewClearFlags = D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER;
	}

	//-------------------------------------------------------------------------
	// Renders the test state.
	//-------------------------------------------------------------------------
	virtual void Render()
	{
		m_mesh->Render();
	};

private:
	Mesh *m_mesh; // Указатель на 3D-меш.
};

//-----------------------------------------------------------------------------
// Установки стейта, специфичные для приложения.
//-----------------------------------------------------------------------------
void StateSetup()
{
	g_engine->AddState( new TestState, true );
}

//-----------------------------------------------------------------------------
// Точка входа в приложение.
//-----------------------------------------------------------------------------
int WINAPI WinMain( HINSTANCE instance, HINSTANCE prev, LPSTR cmdLine, int cmdShow )
{
	// Создаём структуру EngineSetup.
	EngineSetup setup;
	setup.instance = instance;
	setup.name = "Mesh/Material Test";
	setup.scale = 0.01f;
	setup.StateSetup = StateSetup;

	// Создаём инстанс движка (используя структуру EngineSetup), затем запускаем его.
	new Engine( &setup );
	g_engine->Run();

	return true;
}

...
m_mesh = new Mesh( "Gun.x", "./Assets/" );
...

...
		// Устанавливаем подходящую матрицу просмотра для просмотра тестового меша.
		D3DXMATRIX view;
		D3DXMatrixLookAtLH( &view, &D3DXVECTOR3( -50.0f, 50.0f, -150.0f ), &D3DXVECTOR3( 0.0f, 0.0f, 0.0f ), &D3DXVECTOR3( 0.0f, 1.0f, 0.0f ) );
		g_engine->GetDevice()->SetTransform( D3DTS_VIEW, &view );	
...

...
	//-------------------------------------------------------------------------
	// Возвращает текущие настройки вьюера для данного кадра.
	//-------------------------------------------------------------------------
	virtual void RequestViewer( ViewerSetup *viewer )
	{
		viewer->viewClearFlags = D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER;
	}
...

...
	//--------------------------------------
	// Перемещаем камеру по нажатию клавиш на клавиатуре...
	//----------------------------------------
	virtual void Update(float elapsed)
	{
		static D3DXVECTOR3 pos = D3DXVECTOR3( -50.0f, 50.0f, -150.0f);
			if (g_engine->GetInput()->GetKeyPress(DIK_W, true) == true) pos.z += 0.05f;
			if (g_engine->GetInput()->GetKeyPress(DIK_S, true) == true) pos.z -= 0.05f;
			if (g_engine->GetInput()->GetKeyPress(DIK_A, true) == true) pos.x -= 0.05f;
			if (g_engine->GetInput()->GetKeyPress(DIK_D, true) == true) pos.x += 0.05f;
...