1.17 Создаём менеджер сцены

//-----------------------------------------------------------------------------
// File: SceneManager.h
// Manages and renders a scene and the objects in it using frustum and
// occlusion culling, and performing collision detection.
// Управляет и рендерит сцену и объекты в ней, используя отсечения методом
// усечённой пирамиды и на основе перекрытия. Выполняет определение столкновений.
//
// Original SourcrCode:
// Programming a Multiplayer First Person Shooter in DirectX
// Copyright (c) 2004 Vaughan Young
//-----------------------------------------------------------------------------
#ifndef SCENE_MANAGER_H
#define SCENE_MANAGER_H

//-----------------------------------------------------------------------------
// Scene Occluder Structure
// Структура данных заслоняющего объекта сцены
//-----------------------------------------------------------------------------
struct SceneOccluder : public BoundingVolume
{
	unsigned long visibleStamp; // Stamp indicating if the occluder is visible in the current frame.
			// Шатмп, указывающий, видим ли перекрывающий объект (оклюдер) в данном фрейме.
	D3DXVECTOR3 translation; // Translation of the occluder.
			// Трансляция оклюдера.
	unsigned long totalFaces; // Total number of faces in the occluder's mesh.
			// Общее число граней в меше оклюдера.
	Vertex *vertices; // Array containing the occluder's vertices transformed into world space.
			// Массив, содержащий вершины оклюдера, трансформированные в мировое пространство.
	unsigned short *indices; // Array of indices into the vertex array.
			// Массив индексов массива вершин.
	LinkedList< D3DXPLANE > *planes; // List of planes that define the occluded volume.
			// Список плоскостей, которые определяют перекрывающий объём (occluding volume).
	float distance; // Distance between the viewer and the occluder.
			// Расстояние между наблюдателем и оклюдером.

	//-------------------------------------------------------------------------
	// The scene occluder structure constructor.
	//-------------------------------------------------------------------------
	SceneOccluder( D3DXVECTOR3 t, ID3DXMesh *mesh, D3DXMATRIX *world )
	{
		// Clear the visible stamp.
		// Очищаем штамп видимости.
		visibleStamp = -1;

		// Set the translation.
		// Устанавливаем трансляцию.
		translation = t;

		// Set the total faces and create the vertx and idex arrays.
		// Устанавливаем общее число граней и создаём массивы вершин и индеков.
		totalFaces = mesh->GetNumFaces();
		vertices = new Vertex[mesh->GetNumVertices()];
		indices = new unsigned short[totalFaces * 3];

		// Lock the given mesh's vertex and index buffers.
		// Блокируем (lock) буферы вершин и индексов данного меша.
		Vertex* verticesPtr;
		mesh->LockVertexBuffer( 0, (void**)&verticesPtr );
		unsigned short *indicesPtr;
		mesh->LockIndexBuffer( 0, (void**)&indicesPtr );

		// Copy the vertices and the indices.
		// Копируем вершины и индексы.
		memcpy( vertices, verticesPtr, VERTEX_FVF_SIZE * mesh->GetNumVertices() );
		memcpy( indices, indicesPtr, sizeof( unsigned short ) * totalFaces * 3 );

		// Unlock the vertex and index buffers.
		// Разблокируем (unlock) буферы вершин и индексов данного меша.
		mesh->UnlockVertexBuffer();
		mesh->UnlockIndexBuffer();

		// Transform the vertices into world space.
		// Трансформируем вершины в мировое пространство.
		for( unsigned long v = 0; v < mesh->GetNumVertices(); v++ )
			D3DXVec3TransformCoord( &vertices[v].translation, &vertices[v].translation, world );

		// Create a list of planes for building the occlusion volume.
		// Создаём список плоскостей для построения перекрывающего объёма (occlusion volume).
		planes = new LinkedList< D3DXPLANE >;

		// Create a bounding volume from the occluder's mesh.
		// Создаём ограничивающий объём из меша оклюдера.
		BoundingVolumeFromMesh( mesh );

		// Resposition the bounding volume into world space.
		// Репозиционируем ограничивающий объём в мировое пространство.
		D3DXMATRIX location;
		D3DXMatrixTranslation( &location, t.x, t.y, t.z );
		RepositionBoundingVolume( &location );
	}

	//-------------------------------------------------------------------------
	// The scene occluder structure destructor.
	//-------------------------------------------------------------------------
	virtual ~SceneOccluder()
	{
		SAFE_DELETE_ARRAY( vertices );
		SAFE_DELETE_ARRAY( indices );

		SAFE_DELETE( planes );
	}
};

//-----------------------------------------------------------------------------
// Scene Leaf Structure
// Структура данных листка (leaf) сцены
//-----------------------------------------------------------------------------
struct SceneLeaf : public BoundingVolume
{
	SceneLeaf *children[8]; // Array of child scene leaf pointers.
				// Массив указателей на дочерние листки сцены
	unsigned long visibleStamp; // Indicates if the scene leaf is visible in the current frame.
				// Указывает, видим ли листок сцены в данном фрейме.
	LinkedList< SceneOccluder > *occluders; // list of scene occluders in the scene leaf.
				// Список оклюдеров сцены в листке сцены.
	unsigned long totalFaces; // Total number of faces in the scene leaf.
				// Общее число граней в листке сцены.
	unsigned long *faces; // Array of indices pointing to the faces in the scene leaf.
				// Массив индексов, указывающих на грани листка сцены.

	//-------------------------------------------------------------------------
	// The scene leaf structure constructor.
	//-------------------------------------------------------------------------
	SceneLeaf()
	{
		for( char l = 0; l < 8; l++ )
			children[l] = NULL;
		occluders = new LinkedList< SceneOccluder >;
		totalFaces = 0;
		faces = NULL;
	}

	//-------------------------------------------------------------------------
	// The scene leaf structure destructor.
	//-------------------------------------------------------------------------
	virtual ~SceneLeaf()
	{
		for( char l = 0; l < 8; l++ )
			SAFE_DELETE( children[l] );
		occluders->ClearPointers();
		SAFE_DELETE( occluders );
		SAFE_DELETE_ARRAY( faces );
	}
};

//-----------------------------------------------------------------------------
// Scene Face Structure
// Структура данных грани сцены
//-----------------------------------------------------------------------------
struct SceneFace : public IndexedFace
{
	RenderCache *renderCache; // Pointer to the render cache this face belongs to.
				// Указатель на рендер-кэш, которому принадлежит данная грань.
	unsigned long renderStamp; // Indicates when the face was last rendered.
				// Указывает, когда грань рендерилась последний раз.
};

//-----------------------------------------------------------------------------
// Ray Intersection Result Struction
// Структура данных пересечения лучей
//-----------------------------------------------------------------------------
struct RayIntersectionResult
{
	Material *material; // Pointer to the material of the intersected face.
			// Указатель на материал пересекаемой грани.
	float distance; // Distance the ray can travel until intersection occurs.
			// Расстояние, которое луч может преодолеть до наступления пересечения.
	D3DXVECTOR3 point; // Intersection point in 3D space.
			// Точка пересечения в ЗD-пространстве.
	SceneObject *hitObject; // Pointer to the hit scene object (if one was hit).
			// Указатель на удар по объекту сцены (если объект был ударен).

	//-------------------------------------------------------------------------
	// The ray intersection result structure constructor.
	//-------------------------------------------------------------------------
	RayIntersectionResult()
	{
		material = NULL;
		distance = 0.0f;
		point = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
		hitObject = NULL;
	}
};

//-----------------------------------------------------------------------------
// Scene Manager Class
//-----------------------------------------------------------------------------
class SceneManager
{
public:
	SceneManager( float scale, char *spawnerPath );
	virtual ~SceneManager();

	void LoadScene( char *name, char *path = "./" );
	void DestroyScene();
	bool IsLoaded();

	void Update( float elapsed, D3DXMATRIX *view = NULL );
	void Render( float elapsed, D3DXVECTOR3 viewer );

	SceneObject *AddObject( SceneObject *object );
	void RemoveObject( SceneObject **object );

	SceneObject *GetRandomPlayerSpawnPoint();
	SceneObject *GetSpawnPointByID( long id );
	long GetSpawnPointID( SceneObject *point );

	LinkedList< SpawnerObject > *GetSpawnerObjectList();

	bool RayIntersectScene( RayIntersectionResult *result, D3DXVECTOR3 rayPosition,
		D3DXVECTOR3 rayDirection, bool checkScene = true, SceneObject *thisObject = NULL,
		bool checkObjects = false );

private:
	void BuildOcclusionVolume( SceneOccluder *occluder, D3DXVECTOR3 viewer );

	void RecursiveSceneBuild( SceneLeaf *leaf, D3DXVECTOR3 translation, float halfSize );
	bool RecursiveSceneFrustumCheck( SceneLeaf *leaf, D3DXVECTOR3 viewer );
	void RecursiveSceneOcclusionCheck( SceneLeaf *leaf );

private:
	char *m_name; // Name of the scene.
			// Имя сцены.
	float m_scale; // Scene scale in meters/unit.
			// Масштаб (scale) сцены в метрах или юнитах.
	ViewFrustum m_viewFrustum; // View frustum for visiblity culling.
			// Усечённая пирамида вида для отсечения невидимые граней.
	D3DXVECTOR3 m_gravity; // Constant gravity pull.
			// Постоянная сила притяжения.
	bool m_loaded; // Indicates if the scene has been loaded or not.
			// Указывает, была сцена загружена или нет.
	Mesh *m_mesh; // Mesh for the scene.
			// Меш сцены.
	unsigned long m_maxFaces; // Maximum number of faces per scene leaf.
			// Макс, число граней в каждом листке сцены.
	float m_maxHalfSize; // Maximum half size of a scene leaf.
			// Макс, размер половины листка сцены.
	unsigned long m_frameStamp; // Current frame time stamp.
			// Текущий штамп времени кадра.

	LinkedList< SceneObject > *m_dynamicObjects; // Linked list of dynamic objects.
			// Связный список динамических объектов.
	LinkedList< SceneOccluder > *m_occludingObjects; // Linked list of occluding objects.
			// Связный список перекрывающие объектов.
	LinkedList< SceneOccluder > *m_visibleOccluders; // Linked list of visible occluders each frame.
			// Связный список оклюдеров, видимых в каждом кадре.
	LinkedList< SceneObject > *m_playerSpawnPoints; // Linked list of player spawn points.
			// Связный список точек респауна игрока.
	LinkedList< SpawnerObject > *m_objectSpawners; // Linked list of object spawners.
			// Связный список спаунер-объектов.
	char *m_spawnerPath; // Path used for loading the spawner object scripts.
			// Путь, используемый для загрузки скриптов спаунер-объектов.

	SceneLeaf *m_firstLeaf; // The first scene leaf in the scene hierarchy.
			// Первый листок сцены в иерархии сцены.

	IDirect3DVertexBuffer9 *m_sceneVertexBuffer; // Vertex buffer for all the vertices in the scene.
			// Вершинный буфер для всей вершин сцены.
	Vertex *m_vertices; // Pointer for accessing the vertices in the vertex buffer.
			// Указатель для доступа к вершинам в вершинном буфере.
	unsigned long m_totalVertices; // Total number of vertices in the scene.
			// Общее число вершин в сцене.

	LinkedList< RenderCache > *m_renderCaches; // Linked list of render caches.
			// Связный список рендер-кэшей.

	unsigned long m_totalFaces; // Total number of faces in the scene.
			// Общее число граней в сцене.
	SceneFace *m_faces; // Array of faces in the scene.
			// Указатель на грани в сцене.
};

#endif

inline void PerformCollisionDetection( CollisionData *data, Vertex *vertices, SceneFace *faces,
unsigned long totalFaces, LinkedListcSceneObject> *dynamicObjects )

...
//-----------------------------------------------------------------------------
// Scene Face Structure
// Структура данных грани сцены
//-----------------------------------------------------------------------------
struct SceneFace : public IndexedFace
{
	RenderCache *renderCache; // Pointer to the render cache this face belongs to.
				// Указатель на рендер-кэш, которому принадлежит данная грань.
	unsigned long renderStamp; // Indicates when the face was last rendered.
				// Указывает, когда грань рендерилась последний раз.
};
...

...
//-----------------------------------------------------------------------------
// Scene Leaf Structure
// Структура данных листка (leaf) сцены
//-----------------------------------------------------------------------------
struct SceneLeaf : public BoundingVolume
{
	SceneLeaf *children[8]; // Array of child scene leaf pointers.
				// Массив указателей на дочерние листки сцены
	unsigned long visibleStamp; // Indicates if the scene leaf is visible in the current frame.
				// Указывает, видим ли листок сцены в данном кадре.
	LinkedList< SceneOccluder > *occluders; // list of scene occluders in the scene leaf.
				// Список оклюдеров сцены в листке сцены.
	unsigned long totalFaces; // Total number of faces in the scene leaf.
				// Общее число граней в листке сцены.
	unsigned long *faces; // Array of indices pointing to the faces in the scene leaf.
				// Массив индексов, указывающих на грани листка сцены.

	//-------------------------------------------------------------------------
	// The scene leaf structure constructor.
	//-------------------------------------------------------------------------
	SceneLeaf()
	{
		for( char l = 0; l < 8; l++ )
			children[l] = NULL;
		occluders = new LinkedList< SceneOccluder >;
		totalFaces = 0;
		faces = NULL;
	}

	//-------------------------------------------------------------------------
	// The scene leaf structure destructor.
	//-------------------------------------------------------------------------
	virtual ~SceneLeaf()
	{
		for( char l = 0; l < 8; l++ )
			SAFE_DELETE( children[l] );
		occluders->ClearPointers();
		SAFE_DELETE( occluders );
		SAFE_DELETE_ARRAY( faces );
	}
};
...

...
//-----------------------------------------------------------------------------
// Scene Occluder Structure
// Структура данных заслоняющего объекта сцены
//-----------------------------------------------------------------------------
struct SceneOccluder : public BoundingVolume
{
	unsigned long visibleStamp; // Stamp indicating if the occluder is visible in the current frame.
			// Шатмп, указывающий, видим ли перекрывающий объект (оклюдер) в данном кадре.
	D3DXVECTOR3 translation; // Translation of the occluder.
			// Трансляция оклюдера.
	unsigned long totalFaces; // Total number of faces in the occluder's mesh.
			// Общее число граней в меше оклюдера.
	Vertex *vertices; // Array containing the occluder's vertices transformed into world space.
			// Массив, содержащий вершины оклюдера, трансформированные в мировое пространство.
	unsigned short *indices; // Array of indices into the vertex array.
			// Массив индексов массива вершин.
	LinkedList< D3DXPLANE > *planes; // List of planes that define the occluded volume.
			// Список плоскостей, которые определяют перекрывающий объём (occluding volume).
	float distance; // Distance between the viewer and the occluder.
			// Расстояние между наблюдателем и оклюдером.

	//-------------------------------------------------------------------------
	// The scene occluder structure constructor.
	//-------------------------------------------------------------------------
	SceneOccluder( D3DXVECTOR3 t, ID3DXMesh *mesh, D3DXMATRIX *world )
	{
		// Clear the visible stamp.
		// Очищаем штамп видимости.
		visibleStamp = -1;

		// Set the translation.
		// Устанавливаем трансляцию.
		translation = t;

		// Set the total faces and create the vertx and idex arrays.
		// Устанавливаем общее число граней и создаём массивы вершин и индеков.
		totalFaces = mesh->GetNumFaces();
		vertices = new Vertex[mesh->GetNumVertices()];
		indices = new unsigned short[totalFaces * 3];

		// Lock the given mesh's vertex and index buffers.
		// Блокируем (lock) буферы вершин и индексов данного меша.
		Vertex* verticesPtr;
		mesh->LockVertexBuffer( 0, (void**)&verticesPtr );
		unsigned short *indicesPtr;
		mesh->LockIndexBuffer( 0, (void**)&indicesPtr );

		// Copy the vertices and the indices.
		// Копируем вершины и индексы.
		memcpy( vertices, verticesPtr, VERTEX_FVF_SIZE * mesh->GetNumVertices() );
		memcpy( indices, indicesPtr, sizeof( unsigned short ) * totalFaces * 3 );

		// Unlock the vertex and index buffers.
		// Разблокируем (unlock) буферы вершин и индексов данного меша.
		mesh->UnlockVertexBuffer();
		mesh->UnlockIndexBuffer();

		// Transform the vertices into world space.
		// Трансформируем вершины в мировое пространство.
		for( unsigned long v = 0; v < mesh->GetNumVertices(); v++ )
			D3DXVec3TransformCoord( &vertices[v].translation, &vertices[v].translation, world );

		// Create a list of planes for building the occlusion volume.
		// Создаём список плоскостей для построения перекрывающего объёма (occlusion volume).
		planes = new LinkedList< D3DXPLANE >;

		// Create a bounding volume from the occluder's mesh.
		// Создаём ограничивающий объём из меша оклюдера.
		BoundingVolumeFromMesh( mesh );

		// Resposition the bounding volume into world space.
		// Репозиционируем ограничивающий объём в мировое пространство.
		D3DXMATRIX location;
		D3DXMatrixTranslation( &location, t.x, t.y, t.z );
		RepositionBoundingVolume( &location );
	}

	//-------------------------------------------------------------------------
	// The scene occluder structure destructor.
	//-------------------------------------------------------------------------
	virtual ~SceneOccluder()
	{
		SAFE_DELETE_ARRAY( vertices );
		SAFE_DELETE_ARRAY( indices );

		SAFE_DELETE( planes );
	}
};
...

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

//-----------------------------------------------------------------------------
// The scene manager class constructor.
//-----------------------------------------------------------------------------
SceneManager::SceneManager( float scale, char *spawnerPath )
{
	m_name = NULL;
	m_scale = scale;
	m_gravity = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
	m_loaded = false;
	m_mesh = NULL;
	m_maxFaces = 0;
	m_maxHalfSize = 0.0f;
	m_frameStamp = 0;

	m_dynamicObjects = new LinkedList< SceneObject >;
	m_occludingObjects = NULL;
	m_visibleOccluders = NULL;
	m_playerSpawnPoints = NULL;
	m_objectSpawners = NULL;
	m_spawnerPath = spawnerPath;

	m_firstLeaf = NULL;

	m_sceneVertexBuffer = NULL;
	m_vertices = NULL;
	m_totalVertices = 0;

	m_renderCaches = NULL;

	m_totalFaces = 0;
	m_faces = NULL;
}

//-----------------------------------------------------------------------------
// The scene manager class destructor.
//-----------------------------------------------------------------------------
SceneManager::~SceneManager()
{
	DestroyScene();

	// Destroy the dynamic objects list as it was created in the constructor.
	// Уничтожает связный список динамических объектов, созданный конструктором.
	SAFE_DELETE( m_dynamicObjects );
}

//-----------------------------------------------------------------------------
// Loads a new scene from the given scene file.
// Загружает новую сцену из данного файла скрипта сцены.
//-----------------------------------------------------------------------------
void SceneManager::LoadScene( char *name, char *path )
{
	// Create the lists of objects used in the scene. The dynamic object list
	// is persistent across scene changes so it doesn't need to be created.
	// Создаём связные списки объектов сцены (по типам).
	m_occludingObjects = new LinkedList< SceneOccluder >;
	m_visibleOccluders = new LinkedList< SceneOccluder >;
	m_playerSpawnPoints = new LinkedList< SceneObject >;
	m_objectSpawners = new LinkedList< SpawnerObject >;

	// Load the script for the scene.
	// Загружаем скрипт сцены.
	Script *script = new Script( name, path );

	// Store the name of the scene.
	// Сохраняем имя сцены.
	m_name = new char[strlen( script->GetStringData( "name" ) ) + 1];
	memcpy( m_name, script->GetStringData( "name" ), ( strlen( script->GetStringData( "name" ) ) + 1 ) * sizeof( char ) );

	// Store the scene's gravity vector.
	// Сохраняем вектор гравитации сцены.
	m_gravity = *script->GetVectorData( "gravity" ) / m_scale;

	// Create the sun light source.
	// Создаём источник солнечного света.
	D3DLIGHT9 sun;
	sun.Type = D3DLIGHT_DIRECTIONAL;
	sun.Diffuse.r = 1.0f;
	sun.Diffuse.g = 1.0f;
	sun.Diffuse.b = 1.0f;
	sun.Diffuse.a = 1.0f;
	sun.Specular = sun.Diffuse;
	sun.Ambient.r = script->GetColourData( "ambient_light" )->r;
	sun.Ambient.g = script->GetColourData( "ambient_light" )->g;
	sun.Ambient.b = script->GetColourData( "ambient_light" )->b;
	sun.Ambient.a = script->GetColourData( "ambient_light" )->a;
	sun.Direction = D3DXVECTOR3( script->GetVectorData( "sun_direction" )->x,
		script->GetVectorData( "sun_direction" )->y,
		script->GetVectorData( "sun_direction" )->z );
	sun.Range = 0.0f;

	// Switch lighting on, enable the sun light, and specular highlights.
	// Включаем созданный выше источник света. Активируем блики.
	g_engine->GetDevice()->SetRenderState( D3DRS_LIGHTING, true );
	g_engine->GetDevice()->SetLight( 0, &sun );
	g_engine->GetDevice()->LightEnable( 0, true );
	g_engine->GetDevice()->SetRenderState( D3DRS_SPECULARENABLE, true );

	// Set up the fog.
	// Настраиваем туман.
	float density = *script->GetFloatData( "fog_density" ) * m_scale;
	g_engine->GetDevice()->SetRenderState( D3DRS_FOGENABLE, true );
	g_engine->GetDevice()->SetRenderState( D3DRS_FOGCOLOR, D3DCOLOR_COLORVALUE(
		script->GetColourData( "fog_colour" )->r,
		script->GetColourData( "fog_colour" )->g,
		script->GetColourData( "fog_colour" )->b,
		script->GetColourData( "fog_colour" )->a ) );
	g_engine->GetDevice()->SetRenderState( D3DRS_FOGVERTEXMODE, D3DFOG_EXP );
	g_engine->GetDevice()->SetRenderState( D3DRS_FOGDENSITY, *(unsigned long*)&density );

	// Store the constraints used for creating the scene.
	// Получаем из скрипта сцены параметры листков и сохраняем их в переменные.
	m_maxFaces = *script->GetNumberData( "max_faces" );
	m_maxHalfSize = *script->GetFloatData( "max_half_size" );

	// Load the scene's mesh.
	// Загружаем меш сцены (прописан в скрипте меша).
	m_mesh = g_engine->GetMeshManager()->Add( script->GetStringData( "mesh" ), script->GetStringData( "mesh_path" ) );

	// Destory the scene's script as it is no longer needed.
	// Уничтожаем скрипт сцены, т.к. он болвше не нужен.
	SAFE_DELETE( script );

	// Set a new projection matrix so the view frustum will fit the scene.
	// Устанавливаем новую матрицу проекции такм образом, чтобы усечённая пирамида вида вмещала в себя сцену.
	D3DDISPLAYMODE *display;
	display = g_engine->GetDisplayMode();
	D3DXMATRIX projection;
	D3DXMatrixPerspectiveFovLH( &projection, D3DX_PI / 4, (float)display->Width / (float)display->Height,
		0.1f / m_scale, m_mesh->GetBoundingSphere()->radius * 2.0f );
	g_engine->GetDevice()->SetTransform( D3DTS_PROJECTION, &projection );

	// Set the view frustum's projection matrix.
	// Назначаем усечённой пирамиде вида рассчитанную выше матрицу проекции. 
	m_viewFrustum.SetProjectionMatrix( projection );

	// Create the list of render caches.
	// Создаём связный список рендер-кэшей.
	m_renderCaches = new LinkedList< RenderCache >;

	// Search the mesh for unique materials.
	// Ищем в меше уникальные материалы.
	for( unsigned long m = 0; m < m_mesh->GetStaticMesh()->NumMaterials; m++ )
	{
		// Flag to determine if the material has been found already.
		// Флаг, определяющий, найден ли материал ранее.
		bool found = false;

		// Ensure the new material is valid.
		// Проверяем, валиден ли новый материал.
		if( m_mesh->GetStaticMesh()->materials[m] == NULL )
			continue;

		// Iterate through the already existing render caches.
		// Итерируем через существующие рендер-кэши.
		m_renderCaches->Iterate( true );
		while( m_renderCaches->Iterate() )
		{
			// Check if the new material already exists.
			// Проверяем случай, когда найденный материал уже есть в списке.
			if( m_renderCaches->GetCurrent()->GetMaterial() == m_mesh->GetStaticMesh()->materials[m] )
			{
				found = true;
				break;
			}
		}

		// Add the material if it wasn't found and not set to ignore faces.
		// Добавляем материал в связный список материалов, если он ранее не был найден в списке
		// и у него не стоит опция "игнорировать грани".
		if( found == false && m_mesh->GetStaticMesh()->materials[m]->GetIgnoreFace() == false )
			m_renderCaches->Add( new RenderCache( g_engine->GetDevice(), m_mesh->GetStaticMesh()->materials[m] ) );
	}

	// Get a pointer to the mesh's frame list.
	// Получаем указатель на список фреймов меша.
	LinkedList< Frame > *frames = m_mesh->GetFrameList();

	// Iterate through the frame list.
	// Итерируем через связный список фреймов.
	frames->Iterate( true );
	while( frames->Iterate() != NULL )
	{
		// Check if this frame contains an occluder.
		// Проверяем, содержит ли данный фрейм оклюдер (объект, перекрывающий другие объекты).
		if( strncmp( "oc_", frames->GetCurrent()->Name, 3 ) == 0 )
		{
			// If so, load the occluder, and continue to the next frame.
			// Если да, то загружаем оклюдер и переходим к следующему кадру.
			m_occludingObjects->Add( new SceneOccluder( frames->GetCurrent()->GetTranslation(),
				( (MeshContainer*)frames->GetCurrent()->pMeshContainer )->originalMesh,
				&frames->GetCurrent()->finalTransformationMatrix ) );
			continue;
		}

		// Check if this frame is a spawn point.
		// Проверяем, является ли данный фрейм точкой спауна.
		if( strncmp( "sp_", frames->GetCurrent()->Name, 3 ) == 0 )
		{
			// Get the actual name of the spawner object at this spawn point.
			// Получаем актуальное имя спавнер-объекта в данной точке.
			char *firstDash = strpbrk( frames->GetCurrent()->Name, "_" );
			firstDash++;
			char *lastDash = strrchr( firstDash, '_' );
			unsigned long length = lastDash - firstDash;
			char *name = new char[length + 5];
			ZeroMemory( name, sizeof( char ) * ( length + 5 ) );
			strncpy( name, firstDash, length );
			strcat( name, ".txt" );

			// Check if it is a player spawn point.
			// Проверяем, содержит ли фрейм точку спауна игрока.
			if( _stricmp( name, "player.txt" ) == 0 )
			{
				// Get the name of the player spawn point's radius frame.
				// Получаем имя фрейма спаун-радиуса точки спауна игрока.
				char *radiusName = new char[strlen( firstDash ) + 8];
				ZeroMemory( radiusName, sizeof( char ) * ( strlen( firstDash ) + 8 ) );
				strncpy( radiusName, firstDash, strlen( firstDash ) );
				strcat( radiusName, "_radius" );

				// Find the player spawn point's radius frame.
				// Ищем спаун-радиус точки спауна игрока.
				Frame *radiusFrame = frames->GetFirst();
				while( radiusFrame != NULL )
				{
					if( _stricmp( radiusFrame->Name, radiusName ) == 0 )
						break;

					radiusFrame = frames->GetNext( radiusFrame );
				}

				// Destroy the string buffer for the radius frame's name.
				// Уничтожаем строковый буфер, содержащий имя фрейма спаун-радиуса.
				SAFE_DELETE_ARRAY( radiusName );

				// Find the distance between the two points (the radius).
				// Находим расстояние между двумя точками (=радиус).
				float radius = 0.0f;
				if( radiusFrame != NULL )
					radius = D3DXVec3Length( &( radiusFrame->GetTranslation() - frames->GetCurrent()->GetTranslation() ) );

				// Create the player spawn point.
				// Создаём точку спауна игрока.
				SceneObject *point = new SceneObject( NULL, NULL );
				point->SetTranslation( frames->GetCurrent()->GetTranslation() );
				point->SetBoundingSphere( D3DXVECTOR3( 0.0f, 0.0f, 0.0f ), radius );
				point->SetVisible( false );
				point->SetGhost( true );
				point->Update( 0.0f );
				m_dynamicObjects->Add( m_playerSpawnPoints->Add( point ) );
			}
			else
			{
				// Create the application specific spawner object.
				// Создаём спаунер-объект, специфичный для приложения.
				SpawnerObject *spawner = new SpawnerObject( name, m_spawnerPath );
				spawner->SetTranslation( frames->GetCurrent()->GetTranslation() );
				spawner->Update( 0.0f );
				m_dynamicObjects->Add( m_objectSpawners->Add( spawner ) );
			}

			// Destroy the string buffer used to create the spawner's name.
			// Уничтожаем строковый буфер, содержащий имя спаун-объекта.
			SAFE_DELETE_ARRAY( name );
		}
	}

	// A list of valid faces (those with a valid material).
	// Список валидных (= допущенных к рендерингу) граней (т.е. те, которые имеют валидные материалы)
	bool *validFaces = new bool[m_mesh->GetStaticMesh()->originalMesh->GetNumFaces()];
	ZeroMemory( validFaces, sizeof( bool ) * m_mesh->GetStaticMesh()->originalMesh->GetNumFaces() );

	// These are used for locking the vertex, index, and attribute buffers of
	// the meshes. They act as pointers into the data returned by the locks.
	// Эти переменные применяются для блокировки вершин, индексов и буферов атрибутов мешей.
	// Они выступают в роли указателей, куда будут передаваться данные для блокировки.
	Vertex *vertices = NULL;
	unsigned short *indices = NULL;
	unsigned long *attributes = NULL;

	// Lock the mesh's vertex, index, and attribute buffers.
	// Лочим все 3 буфера.
	m_mesh->GetStaticMesh()->originalMesh->LockVertexBuffer( D3DLOCK_READONLY, (void**)&vertices );
	m_mesh->GetStaticMesh()->originalMesh->LockIndexBuffer( D3DLOCK_READONLY, (void**)&indices );
	m_mesh->GetStaticMesh()->originalMesh->LockAttributeBuffer( D3DLOCK_READONLY, &attributes );

	// Count the faces in the scene that have a valid material.
	// Подсчитываем число граней сцены с валидными материалами.
	for( unsigned long f = 0; f < m_mesh->GetStaticMesh()->originalMesh->GetNumFaces(); f++ )
	{
		m_renderCaches->Iterate( true );
		while( m_renderCaches->Iterate() )
		{
			if( m_renderCaches->GetCurrent()->GetMaterial() == m_mesh->GetStaticMesh()->materials[attributes[f]] )
			{
				m_totalFaces++;
				validFaces[f] = true;
				break;
			}
		}
	}

	// Create the array of faces.
	// Создаём массив граней.
	m_faces = new SceneFace[m_totalFaces];

	// Set the number of vertices.
	// Считаем общее кол-во вершин сцены.
	m_totalVertices = m_totalFaces * 3;

	// Create the vertex buffer that will hold all the vertices in the scene.
	// Создаём вершинный буфер, в котором будут храниться все вершины сцены.
	g_engine->GetDevice()->CreateVertexBuffer( m_totalVertices * VERTEX_FVF_SIZE,
		D3DUSAGE_WRITEONLY, VERTEX_FVF, D3DPOOL_MANAGED, &m_sceneVertexBuffer, NULL );

	// Used for temporary storage of the final vertices that make the scene.
	// Применяем временное хранилище для конечного набора вершин, формирующих сцену.
	Vertex *tempVertices = new Vertex[m_totalVertices];

	// Lock the scene's vertex buffer
	// Лочим (=блокируем) вершинный буфер) сцены.
	m_sceneVertexBuffer->Lock( 0, 0, (void**)&m_vertices, 0 );

	// Go through all of the valid faces in the mesh and store their details.
	// Итерируем через все валидные грани меша и сохраняем их детали.
	for( unsigned long f = 0; f < m_totalFaces; f++ )
	{
		// Ensure this face is valid.
		// Проверяем, валидна ли грань.
		if( validFaces[f] == false )
		{
			// Advance the indices pointer to skip this face.
			// Увеличиваем число индексов, припустив данную грань.
			indices += 3;
			continue;
		}

		// Store the index pointer for each vertex in the face.
		// Инкрементируем кол-во указателей на каждый из индексов после размещения
		// в индексном буфере каждой вершины
		m_faces[f].vertex0 = *indices++;
		m_faces[f].vertex1 = *indices++;
		m_faces[f].vertex2 = *indices++;

		// Find the render cache this face belongs to.
		// Находим рендер-кэш, которому принадлежит данная грань.
		m_renderCaches->Iterate( true );
		while( m_renderCaches->Iterate() )
		{
			if( m_renderCaches->GetCurrent()->GetMaterial() == m_mesh->GetStaticMesh()->materials[attributes[f]] )
			{
				m_faces[f].renderCache = m_renderCaches->GetCurrent();
				m_renderCaches->GetCurrent()->AddFace();
				break;
			}
		}

		// Take of temporary copy of these vertices.
		// Делаем временную копию этих вершин.
		tempVertices[m_faces[f].vertex0] = vertices[m_faces[f].vertex0];
		tempVertices[m_faces[f].vertex1] = vertices[m_faces[f].vertex1];
		tempVertices[m_faces[f].vertex2] = vertices[m_faces[f].vertex2];
	}

	// Copy the final vertices (that make up the scene) into the vertex buffer.
	// Копируем конечный список вершин (которые сформируют сцену) в вершинный буфер.
	memcpy( m_vertices, tempVertices, m_totalVertices * VERTEX_FVF_SIZE );

	// Unlock the scene's vertex buffer.
	// Разблокируем вершинный буфер сцены.
	m_sceneVertexBuffer->Unlock();

	// Destroy the temporary vertices array.
	// Уничтожаем временный массив вершин.
	SAFE_DELETE_ARRAY( tempVertices );

	// Unlock the mesh's vertex, index, and attribute buffers.
	// Разблокируем все 3 буфера.
	m_mesh->GetStaticMesh()->originalMesh->UnlockAttributeBuffer();
	m_mesh->GetStaticMesh()->originalMesh->UnlockIndexBuffer();
	m_mesh->GetStaticMesh()->originalMesh->UnlockVertexBuffer();

	// Destroy the array of valid faces.
	// Уничтожаем массив валидных граней.
	SAFE_DELETE_ARRAY( validFaces );

	// Create the first scene leaf (the largest leaf that encloses the scene).
	// Создаём первый лист октодерева (самый большой, заключающий в себе всю сцену целиком).
	m_firstLeaf = new SceneLeaf();

	// Recursively build the scene, starting with the first leaf.
	// Рекурсивно строим сцену, начиная с первого листа октодерева.
	RecursiveSceneBuild( m_firstLeaf, m_mesh->GetBoundingSphere()->centre, m_mesh->GetBoundingBox()->halfSize );

	// Allow the render caches to prepare themselves.
	// Готовим рендер-кэши.
	m_renderCaches->Iterate( true );
	while( m_renderCaches->Iterate() )
		m_renderCaches->GetCurrent()->Prepare( m_totalVertices );

	// Indicate that the scene is now loaded.
	// Ставим отметку о том, что сцена загружена.
	m_loaded = true;
}

//-----------------------------------------------------------------------------
// Destroys the currently loaded scene.
// Уничтожает ранее загруженную сцену.
//-----------------------------------------------------------------------------
void SceneManager::DestroyScene()
{
	// Destroy the array of polygons.
	// Уничтожаем массив полигонов (=граней).
	SAFE_DELETE_ARRAY( m_faces );
	m_totalFaces = 0;

	// Destroy the list of render caches.
	// Уничтожаем список рендер-кэшей.
	SAFE_DELETE( m_renderCaches );

	// Release the scene's vertex buffer.
	// Освобождаем память вершинного буфера сцены.
	SAFE_RELEASE( m_sceneVertexBuffer );
	m_vertices = NULL;
	m_totalVertices = 0;

	// Destroy the scene leaf hierarchy.
	// Уничтожаем иерархию октодерева сцены.
	SAFE_DELETE( m_firstLeaf );

	// Destroy the object spawner list.
	if( m_objectSpawners != NULL )
		m_objectSpawners->ClearPointers();
	SAFE_DELETE( m_objectSpawners );

	// Destroy the list of player spawn points.
	// Уничтожаем список объектов-спавунеров.
	if( m_playerSpawnPoints != NULL )
		m_playerSpawnPoints->ClearPointers();
	SAFE_DELETE( m_playerSpawnPoints );

	// Destroy the lists of occluding objects.
	// Уничтожаем список оклюдерюв.
	if( m_visibleOccluders != NULL )
		m_visibleOccluders->ClearPointers();
	SAFE_DELETE( m_visibleOccluders );
	SAFE_DELETE( m_occludingObjects );

	// Empty the list of dynamic objects.
	// Уничтожаем спсисок динамических объектов.
	m_dynamicObjects->Empty();

	// Destroy the scene's mesh.
	// Уничтожаем меш сцены.
	g_engine->GetMeshManager()->Remove( &m_mesh );

	// Destroy the scene name.
	// Уничтожаем имя сцены.
	SAFE_DELETE_ARRAY( m_name );

	// Indicate that the scene is no longer loaded.
	// Сигналим, о том что сцена более не загружена.
	m_loaded = false;
}

//-----------------------------------------------------------------------------
// Returns true if the scene is loaded and ready for use.
// Возвращает TRUE, если сцена загружена и готова к использованию.
//-----------------------------------------------------------------------------
bool SceneManager::IsLoaded()
{
	return m_loaded;
}

//-----------------------------------------------------------------------------
// Updates the scene and all the objects in it.
// Обновляет сцену и все объекты на ней.
//-----------------------------------------------------------------------------
void SceneManager::Update( float elapsed, D3DXMATRIX *view )
{
	// Ensure a scene is loaded.
	// Убеждаемся, что сцена загружена.
	if( m_firstLeaf == NULL )
		return;

	// Increment the frame stamp. Indicating the start of a new frame.
	// Инкрементируем (увеличиваем на 1) штамп фрейма.
	m_frameStamp++;

	// Update the view frustum.
	// Обновляем усечённую пирамиду вида.
	m_viewFrustum.Update( view );

	// Go through all the dynamic object's and update them.
	// Итерируем все динамические объекты и обновляем их.
	m_dynamicObjects->Iterate( true );
	while( m_dynamicObjects->Iterate() )
	{
		// Ignore the object if it is not enabled.
		// Игнорируем отключенные объекты.
		if( m_dynamicObjects->GetCurrent()->GetEnabled() == false )
			continue;

		// If this object is a ghost, then it cannot collided with anything.
		// However, it still needs to be updated. Since objects receive their
		// movement through the collision system, ghost objects will have to be
		// allowed to update their movement manually.
		// Если объект является призраком, то он не может сталкиваться с чем-либо.
		// Но в любом случае он тоже должен быть обновлён.
		// В свете того, что объекты получают своё движение через систему столкновений,
		// объекты-призраки должны быть допущены к обновлению своих положений вручную.
		if( m_dynamicObjects->GetCurrent()->GetGhost() == true )
		{
			m_dynamicObjects->GetCurrent()->Update( elapsed );
			continue;
		}

		// Objects without an ellipsoid radius cannot collide with anything.
		// Объекты без радиуса эллипсоида не могут сталкиваться с чем-либо.
		if( m_dynamicObjects->GetCurrent()->GetEllipsoidRadius().x + m_dynamicObjects->GetCurrent()->GetEllipsoidRadius().y,
			m_dynamicObjects->GetCurrent()->GetEllipsoidRadius().z <= 0.0f )
		{
			m_dynamicObjects->GetCurrent()->Update( elapsed );
			continue;
		}

		// Build the collision data for this object.
		// Заполняем данные столкновения по данном объекту.
		static CollisionData collisionData;
		collisionData.scale = m_scale;
		collisionData.elapsed = elapsed;
		collisionData.frameStamp = m_frameStamp;
		collisionData.object = m_dynamicObjects->GetCurrent();
		collisionData.gravity = m_gravity * elapsed;

		// Perform collision detection for this object.
		// Выполняем определение столкновения для данного объекта.
		PerformCollisionDetection( &collisionData, (Vertex*)m_vertices, m_faces, m_totalFaces, m_dynamicObjects );

		// Allow the object to update itself.
		// Позволяем объекту обновить самого себя.
		m_dynamicObjects->GetCurrent()->Update( elapsed, false );
	}
}

//-----------------------------------------------------------------------------
// Renders the scene and all the objects in it.
// Рендерпт сцену и все объекты на ней.
//-----------------------------------------------------------------------------
void SceneManager::Render( float elapsed, D3DXVECTOR3 viewer )
{
	// Ensure a scene is loaded.
	// Убеждаемся, что сцена загружена.
	if( m_firstLeaf == NULL )
		return;

	// Clear the list of visible occluders.
	// Очищаем список видимых оклюдеров.
	m_visibleOccluders->ClearPointers();

	// Begin the process of determining the visible leaves in the scene. The
	// first step involves checking the scene leaves against the view frustum.
	// Начинаем процесс определения видимых листьев октодерева сцены.
	// Первым делом проверяем листья, расположенные напротив усечённой пирамиды вида.
	RecursiveSceneFrustumCheck( m_firstLeaf, viewer );

	// A list of potentially visible leaves and occluders has been determined
	// after check against the view frustum. The next step is to go through and
	// further refine the list of visible occluders through occlusion culling.
	// Далее итерируем список видимых оклюдеров для определения отсечений объектов,
	// заслонённых ими.
	m_visibleOccluders->Iterate( true );
	while( m_visibleOccluders->Iterate() )
	{
		// If the occluder's visible stamp does not not equal the current frame
		// stamp then the occluder has been hidden somehow, so ignore it.
		// Если штамп видимости оклюдера не соответствует штампу текущего фрейма,
		// значит этот оклюдер спрятан. Поэтому игнорируем его.
		if( m_visibleOccluders->GetCurrent()->visibleStamp != m_frameStamp )
			continue;

		// Build the occluder's occlusion volume.
		// Создаем ограничивающий объём вокруг оклюдера.
		BuildOcclusionVolume( m_visibleOccluders->GetCurrent(), viewer );

		// Iterate through the rest of the visible occluder's.
		// Итерируем оставшиеся видимые оклюдеры.
		SceneOccluder *occludee = m_visibleOccluders->GetNext( m_visibleOccluders->GetCurrent() );
		while( occludee != NULL )
		{
			// If the occludee's bounding sphere is overlapping the occluder's
			// volume and the occludee's bounding box is completely enclosed by
			// the occluder's volume, then the occludee is hidden.
			// Если ограничивающая сфера заслоняемого объекта перекрывает
			// ограничивающий объём оклюдера, а ограничивающий куб заслоняемого объекта
			// полностью заключён внутри огарипчивающего объёма оклюдера (лучи, касающиеся
			// краёв оклюдера уходят бесконечно вдаль), то заслоняемый объект не виден
			// наблюдателю. => Его можно не рендерпть.
			if( IsSphereOverlappingVolume( m_visibleOccluders->GetCurrent()->planes,
				occludee->translation,
				occludee->GetBoundingSphere()->radius ) == true )
				if( IsBoxEnclosedByVolume( m_visibleOccluders->GetCurrent()->planes,
					occludee->GetBoundingBox()->min,
					occludee->GetBoundingBox()->max ) == true )
					occludee->visibleStamp--;

			occludee = m_visibleOccluders->GetNext( occludee );
		}
	}

	// Tell all the render caches to prepare for rendering.
	// Командуем всем рендер-кэшам приготовиться к рендерингу.
	m_renderCaches->Iterate( true );
	while( m_renderCaches->Iterate() )
		m_renderCaches->GetCurrent()->Begin();

	// Finally, check the scene's leaves against the visible occluders.
	// Проверяем листья октодерева сцены на предмет заслонённости оклюдерами.
	RecursiveSceneOcclusionCheck( m_firstLeaf );

	// Set an identity world transformation matrix to render around the origin.
	// Устанавливаем мировую матрицу идентичности для рендеринга относительно
	// начала координат.
	D3DXMATRIX world;
	D3DXMatrixIdentity( &world );
	g_engine->GetDevice()->SetTransform( D3DTS_WORLD, &world );

	// Set the scene vertex buffer as the current device data stream.
	// Назначаем вершинный буфер сцены в качестве потока данных объекта устройства Direct3D.
	g_engine->GetDevice()->SetStreamSource( 0, m_sceneVertexBuffer, 0, VERTEX_FVF_SIZE );
	g_engine->GetDevice()->SetFVF( VERTEX_FVF );

	// Tell all the render caches to end rendering. This will cause them to
	// send their faces to be render to the video card.
	// Командуем всем рендер-кэшам заканчивать рендеринг. Это приведёт к отправке ими всех
	// граней в видеокарту, на рендеринг.
	m_renderCaches->Iterate( true );
	while( m_renderCaches->Iterate() )
		m_renderCaches->GetCurrent()->End();

	// Iterate through the list of dynamic objects.
	// Итерируем через список динамических объектов.
	m_dynamicObjects->Iterate( true );
	while( m_dynamicObjects->Iterate() )
	{
		// Check if the object is visible.
		// Проверяем, видим ли объект.
		if( m_dynamicObjects->GetCurrent()->GetVisible() == false )
			continue;

		// Check if the object's bounding sphere is inside the view frustum.
		// Проверяем, расположена ли ограничивающая сфера объекта внутри
		// усечённой пирамиды вида.
		if( m_viewFrustum.IsSphereInside( m_dynamicObjects->GetCurrent()->GetBoundingSphere()->centre,
			m_dynamicObjects->GetCurrent()->GetBoundingSphere()->radius ) == false )
			continue;

		// Iterate through the list of visible occluders.
		// Итерируем список видимых оклюдеров.
		bool occluded = false;
		m_visibleOccluders->Iterate( true );
		while( m_visibleOccluders->Iterate() )
		{
			// Ignore hidden occluders.
			// Игнориуем спрятанные оклюдеры.
			if( m_visibleOccluders->GetCurrent()->visibleStamp != m_frameStamp )
				continue;

			occluded = true;

			// Check the object's bounding sphere against the occlusion volume.
			// Проверяем ограничивающую сферу объекта на предмет попадания внутрь
			// перекрывающего объёма.
			m_visibleOccluders->GetCurrent()->planes->Iterate( true );
			while( m_visibleOccluders->GetCurrent()->planes->Iterate() )
			{
				if( D3DXPlaneDotCoord( m_visibleOccluders->GetCurrent()->planes->GetCurrent(),
					&m_dynamicObjects->GetCurrent()->GetBoundingSphere()->centre )
					< m_dynamicObjects->GetCurrent()->GetBoundingSphere()->radius )
				{
					occluded = false;
					break;
				}
			}

			// Break if the object is completely hidden by this occluder.
			// Прерываем, если объект полностью заслонён данным оклюдером.
			if( occluded == true )
				break;
		}

		// Ignore this object if it is occluded.
		// Игнорируем полностью заслонённый объект и продолжаем итерацию дальше.
		if( occluded == true )
			continue;

		// Render the object.
		// Рендерпм объект.
		m_dynamicObjects->GetCurrent()->Render();
	}
}

//-----------------------------------------------------------------------------
// Adds the given object to the scene.
// Добавляет данный объект в сцену.
//-----------------------------------------------------------------------------
SceneObject *SceneManager::AddObject( SceneObject *object )
{
	return m_dynamicObjects->Add( object );
}

//-----------------------------------------------------------------------------
// Removes the given object from the scene.
// Убирает данный объект из сцены.
//-----------------------------------------------------------------------------
void SceneManager::RemoveObject( SceneObject **object )
{
	m_dynamicObjects->ClearPointer( object );
}

//-----------------------------------------------------------------------------
// Returns a random player spawnpoint.
// Возвращает случайным образом одну из точек спауна игрока.
//-----------------------------------------------------------------------------
SceneObject *SceneManager::GetRandomPlayerSpawnPoint()
{
	// Get a random spawn point.
	// Получаем случайную точку спауна игрока.
	SceneObject *point = m_playerSpawnPoints->GetRandom();

	// If the spawner's collision stamp equals the current frame stamp, then
	// something has collided with the spawner. Alternatively this spawner may
	// not be enabled. In either case, return NULL to indicate that a vacent
	// spawn point was not found. The caller will have to try again later.
	// Если штамп столкновения спаунера равен штампу текущего кадра, значит
	// что-то столкнулось со спаунером и он не может быть включён.
	// Значение NULL указывает на то, что точка спауна не найдена и нужно поискать её
	// ещё раз.
	if( point->GetCollisionStamp() != m_frameStamp && point->GetEnabled() == true )
		return point;
	else
		return NULL;
}

//-----------------------------------------------------------------------------
// Returns the spawn point with the given ID (position in the linked list).
// Возвращает точку спауна с данным ID) (порядковым номером в связном списке)
//-----------------------------------------------------------------------------
SceneObject *SceneManager::GetSpawnPointByID( long id )
{
	SceneObject *point = NULL;

	// Ensure the ID is in range.
	// Проверяем, входит ли ID в даннй диапазон.
	if( id < (long)m_playerSpawnPoints->GetTotalElements() )
	{
		// Loop through the player spawn point list until the id is reached.
		point = m_playerSpawnPoints->GetFirst();
		for( long i = 0; i < id; i++ )
			point = m_playerSpawnPoints->GetNext( point );
	}

	return point;
}

//-----------------------------------------------------------------------------
// Returns the ID (position in the linked list) of the given spawn point.
// Возвращает ID (позицию в связном списке) данной точки спауна.
//-----------------------------------------------------------------------------
long SceneManager::GetSpawnPointID( SceneObject *point )
{
	// Ensure the given spawn point is valid.
	// Проверяем, валидна ли данная точка спауна.
	if( point == NULL )
		return -1;

	long id = 0;

	// Iterate the player spawn point list looking for the given spawn point.
	// Итерируем список спаун-точек игрока в поисках данной спаун-точки.
	m_playerSpawnPoints->Iterate( true );
	while( m_playerSpawnPoints->Iterate() != NULL )
	{
		if( m_playerSpawnPoints->GetCurrent() == point )
			break;

		id++;
	}

	// If the ID equals the total elements, then the spawn point was not found.
	// Если ID точки равен кол-ву элементов в связном списке, то данная
	// спаун-точка не найдена.
	if( id == (long)m_playerSpawnPoints->GetTotalElements() )
		id = -1;

	return id;
}

//-----------------------------------------------------------------------------
// Returns the list of object spawners in the scene.
// Возвращает список спаун-объектов сцены.
//-----------------------------------------------------------------------------
LinkedList< SpawnerObject > *SceneManager::GetSpawnerObjectList()
{
	return m_objectSpawners;
}

//-----------------------------------------------------------------------------
// Returns the result of a ray intersection with the scene and all its objects.
// Возвращает результат пересечения луча со сценой и всеми её объектами.
//-----------------------------------------------------------------------------
bool SceneManager::RayIntersectScene( RayIntersectionResult *result, D3DXVECTOR3 rayPosition,
	D3DXVECTOR3 rayDirection, bool checkScene, SceneObject *thisObject, bool checkObjects )
{
	float hitDistance = 0.0f;

	// Check if the ray needs to check for intersection with the scene.
	// Проверяем, надо ли проверять луч на пересечение со сценой.
	if( checkScene == true )
	{
		// Go through all the faces in the scene, check for intersection.
		// Проходим через все грани сцены, проверяя на пересечение с лучом.
		for( unsigned long f = 0; f < m_totalFaces; f++ )
		{
			// Skip this face if its material is set to ignore rays.
			// Пропускаем грань, если в скрипте её материала указано игнорировать лучи.
			if( m_faces[f].renderCache->GetMaterial()->GetIgnoreRay() == true )
				continue;

			// Check the ray against this face.
			// Проверяем луч на пересечненпе с данной гранью.
			if( D3DXIntersectTri( (D3DXVECTOR3*)&m_vertices[m_faces[f].vertex0],
				(D3DXVECTOR3*)&m_vertices[m_faces[f].vertex1],
				(D3DXVECTOR3*)&m_vertices[m_faces[f].vertex2],
				&rayPosition, &rayDirection, NULL, NULL, &hitDistance ) == TRUE )
			{
				if( hitDistance < result->distance || result->material == NULL )
				{
					( *result ).distance = hitDistance;
					( *result ).material = m_faces[f].renderCache->GetMaterial();
				}
			}
		}
	}

	// Check if the ray needs to check for intersection with the objects.
	// Проверяем, надо ли проверять луч на пересечение с объектами.
	if( checkObjects == true )
	{
		// Stores the ray in model space.
		// Сохраняем луч в пространстве модели.
		D3DXVECTOR3 rp, rd;

		// Iterate all the objects in the scene, check for intersection.
		// Итерируем все объекты сцены, проверяя на пересечение.
		SceneObject *object = m_dynamicObjects->GetFirst();
		while( object != NULL )
		{
			// Only check this object if it is enabled, has a mesh and is not
			// the calling object.
			// Проверяем только те объекты, которые включены, имеют меш и
			// не являются объектами, спаунящими другие объекты.
			if( object->GetEnabled() == true && object->GetMesh() != NULL && object != thisObject )
			{
				// Transform the ray into model space.
				// Трансформируем луч в пространство модели.
				D3DXMATRIX inverse;
				D3DXMatrixInverse( &inverse, NULL, object->GetWorldMatrix() );
				D3DXVec3TransformCoord( &rp, &rayPosition, &inverse );
				D3DXVec3TransformNormal( &rd, &rayDirection, &inverse );

				// Go through the list of frames in the object's mesh.
				// Проходим через список фреймов меша объекта.
				LinkedList< Frame > *frames = object->GetMesh()->GetFrameList();
				frames->Iterate( true );
				while( frames->Iterate() != NULL )
				{
					// Ignore this frame if it has no mesh.
					// Пропускаем фрейм без меша.
					if( frames->GetCurrent()->pMeshContainer == NULL )
						continue;

					// Check the ray against this frame's mesh.
					// Проверяем луч на пересечение с мешем фрейма.
					BOOL hit;
					D3DXIntersect( frames->GetCurrent()->pMeshContainer->MeshData.pMesh, &rp, &rd,
						&hit, NULL, NULL, NULL, &hitDistance, NULL, NULL );
					if( hit == TRUE && ( hitDistance < result->distance || result->material == NULL ) )
					{
						( *result ).distance = hitDistance;
						( *result ).material = object->GetMesh()->GetStaticMesh()->materials[0];
						( *result ).hitObject = object;
					}
				}
			}

			// Go to the next object.
			// Переходим к следующему объекту.
			object = m_dynamicObjects->GetNext( object );
		}
	}

	// Return false if no intersection occured.
	// Возвращаем FALSE, если пересечение не найдено.
	if( result->material == NULL )
		return false;

	// Calculate the point of intersection.
	// Вычисляем точку пересечения.
	( *result ).point = rayPosition + rayDirection * result->distance;

	return true;
}

//-----------------------------------------------------------------------------
// Builds an occlusion volume for the given occluder.
// Строим перекрывающий объём для данного оклюдера.
//-----------------------------------------------------------------------------
void SceneManager::BuildOcclusionVolume( SceneOccluder *occluder, D3DXVECTOR3 viewer )
{
	// Create a list of edges for the occluder's silhouette.
	// Создаём список рёбер силуэта оклюдера.
	LinkedList< Edge > *edges = new LinkedList< Edge >;

	// Go through all the faces in the occluder's mesh.
	for( unsigned long f = 0; f < occluder->totalFaces; f++ )
	{
		// Get the indices of this face.
		// Получаем индексы вершин грани.
		unsigned short index0 = occluder->indices[3 * f + 0];
		unsigned short index1 = occluder->indices[3 * f + 1];
		unsigned short index2 = occluder->indices[3 * f + 2];

		// Find the angle between the face's normal and the vector point from
		// viewer's position to the face's position. If the angle is less than
		// 0, then the face is visible to the viewer.
		// Вычисляем угол между нормалью грани и вектором, направленным от вьюера
		// к грани. Если данный угол меньше 0, то данная грань вьюеру (=игроку) не видна.
		if( D3DXVec3Dot( &occluder->vertices[index0].normal, &( occluder->vertices[index0].translation - viewer ) ) < 0.0f )
		{
			// Check if the list of edges is empty.
			// Если список граней пуст...
			if( edges->GetTotalElements() == 0 )
			{
				// Add all the edges for this face.
				// Добавляем в список 3 ребра данной грани.
				edges->Add( new Edge( &occluder->vertices[index0], &occluder->vertices[index1] ) );
				edges->Add( new Edge( &occluder->vertices[index1], &occluder->vertices[index2] ) );
				edges->Add( new Edge( &occluder->vertices[index2], &occluder->vertices[index0] ) );
			}
			else
			{
				Edge *found0 = NULL;
				Edge *found1 = NULL;
				Edge *found2 = NULL;

				// Iterate through the list of edges.
				// Итерируем список рёбер.
				edges->Iterate( true );
				while( edges->Iterate() != NULL )
				{
					// Check if the first edge of this face already exists.
					// Проверяем случай, когда первое ребро данной грани уже существует.
					if( ( edges->GetCurrent()->vertex0->translation == occluder->vertices[index0].translation &&
						edges->GetCurrent()->vertex1->translation == occluder->vertices[index1].translation ) ||
						( edges->GetCurrent()->vertex0->translation == occluder->vertices[index1].translation &&
						edges->GetCurrent()->vertex1->translation == occluder->vertices[index0].translation ) )
						found0 = edges->GetCurrent();

					// Check if the second edge of this face already exists.
					// Проверяем случай, когда второе ребро данной грани уже существует.
					if( ( edges->GetCurrent()->vertex0->translation == occluder->vertices[index1].translation &&
						edges->GetCurrent()->vertex1->translation == occluder->vertices[index2].translation ) ||
						( edges->GetCurrent()->vertex0->translation == occluder->vertices[index2].translation &&
						edges->GetCurrent()->vertex1->translation == occluder->vertices[index1].translation ) )
						found1 = edges->GetCurrent();

					// Check if the third edge of this face already exists.
					// Проверяем случай, когда третье ребро данной грани уже существует.
					if( ( edges->GetCurrent()->vertex0->translation == occluder->vertices[index2].translation &&
						edges->GetCurrent()->vertex1->translation == occluder->vertices[index0].translation ) ||
						( edges->GetCurrent()->vertex0->translation == occluder->vertices[index0].translation &&
						edges->GetCurrent()->vertex1->translation == occluder->vertices[index2].translation ) )
						found2 = edges->GetCurrent();
				}

				// If the first edge was found, remove it. Otherwise add it.
				// Если первое ребро найдено, удалим его. В противном случае - добавим в список рёбер.
				if( found0 != NULL )
					edges->Remove( &found0 );
				else
					edges->Add( new Edge( &occluder->vertices[index0], &occluder->vertices[index1] ) );

				// If the second edge was found, remove it. Otherwise add it.
				// Если второе ребро найдено, удалим его. В противном случае - добавим в список рёбер.
				if( found1 != NULL )
					edges->Remove( &found1 );
				else
					edges->Add( new Edge( &occluder->vertices[index1], &occluder->vertices[index2] ) );

				// If the thrid edge was found, remove it. Otherwise add it.
				// Если третье ребро найдено, удалим его. В противном случае - добавим в список рёбер.
				if( found2 != NULL )
					edges->Remove( &found2 );
				else
					edges->Add( new Edge( &occluder->vertices[index2], &occluder->vertices[index0] ) );
			}
		}
	}

	// Empty the occluder's list of planes.
	// Опустошаем список плоскостей оклюдера.
	occluder->planes->Empty();

	// Create the front cap plane.
	// Создаём плоскость верхнего сечения. 
	D3DXPLANE *plane = new D3DXPLANE;
	D3DXPlaneFromPointNormal( plane, &occluder->translation, &( occluder->translation - viewer ) );
	occluder->planes->Add( plane );

	// Iterate through the list of edges.
	// Итерируем список рёбер. 
	edges->Iterate( true );
	while( edges->Iterate() != NULL )
	{
		// Get the position of the vertices in the edge.
		// Получаем позицию вершин ребра.
		D3DXVECTOR3 vertex1 = edges->GetCurrent()->vertex0->translation;
		D3DXVECTOR3 vertex2 = edges->GetCurrent()->vertex1->translation;

		// Calculate the position of the thrid vertex for creating the plane.
		// Вычисляем положение третьей вершины для создания плоскости.
		D3DXVECTOR3 dir = vertex1 - viewer;
		D3DXVec3Normalize( &dir, &dir );
		D3DXVECTOR3 vertex3 = vertex1 + dir;

		// Create a plane from this edge.
		// Создаём плоскость на основе данной грани.
		plane = new D3DXPLANE;
		D3DXPlaneFromPoints( plane, &vertex1, &vertex2, &vertex3 );
		occluder->planes->Add( plane );
	}

	// Destroy the list of edges.
	// Уничтожаем список рёбер.
	SAFE_DELETE( edges );
}

//-----------------------------------------------------------------------------
// Recursively builds the scene.
// Рекурсивно строим сцену.
//-----------------------------------------------------------------------------
void SceneManager::RecursiveSceneBuild( SceneLeaf *leaf, D3DXVECTOR3 translation, float halfSize )
{
	// Build a bounding volume around this leaf.
	// Строим ограничивающие объёмы вокруг данного листа октодерева.
	leaf->SetBoundingBox( D3DXVECTOR3( translation.x - halfSize, translation.y - halfSize, translation.z - halfSize ),
		D3DXVECTOR3( translation.x + halfSize, translation.y + halfSize, translation.z + halfSize ) );
	leaf->SetBoundingSphere( translation, (float)sqrt( halfSize * halfSize + halfSize * halfSize + halfSize * halfSize ) );

	// Count the number of face in this leaf.
	// Считаем число граней в данном листе.
	unsigned long totalFaces = 0;
	for( unsigned long f = 0; f < m_totalFaces; f++ )
		if( IsFaceInBox( &m_vertices[m_faces[f].vertex0], &m_vertices[m_faces[f].vertex1],
			&m_vertices[m_faces[f].vertex2], leaf->GetBoundingBox()->min, leaf->GetBoundingBox()->max ) == true )
			totalFaces++;

	// Only divide the leaf up if it is too big and contains too many faces.
	// Делим лист только если он чересчур большой и содержит слишком много граней.
	if( halfSize > m_maxHalfSize && totalFaces > m_maxFaces )
	{
		// Go through all the child leaves.
		for( char c = 0; c < 8; c++ )
		{
			D3DXVECTOR3 newTranslation, newMin, newMax;
			float newHalfSize = halfSize / 2.0f;
			float mod;

			// Calculate the translation of the new leaf on the x axis.
			// Вычисляем трансляцию нового листа по оси х.
			mod = 1.0f;
			if( c % 2 < 1 )
				mod = -1.0f;
			newTranslation.x = translation.x + newHalfSize * mod;

			// Calculate the translation of the new leaf on the y axis.
			// Вычисляем трансляцию нового листа по оси y.
			mod = 1.0f;
			if( c % 4 < 2 )
				mod = -1.0f;
			newTranslation.y = translation.y + newHalfSize * mod;

			// Calculate the translation of the new leaf on the z axis.
			// Вычисляем трансляцию нового листа по оси z.
			mod = 1.0f;
			if( c % 8 < 4 )
				mod = -1.0f;
			newTranslation.z = translation.z + newHalfSize * mod;

			// Calculate the bounding box around the new leaf.
			// Подсчитываем размер ограничивающего объёма нового листа.
			newMin = D3DXVECTOR3( newTranslation.x - newHalfSize, newTranslation.y - newHalfSize,
				newTranslation.z - newHalfSize );
			newMax = D3DXVECTOR3( newTranslation.x + newHalfSize, newTranslation.y + newHalfSize,
				newTranslation.z + newHalfSize );

			// Check if the new scene leaf will have at least one face in it.
			// Проверяем, содержит ли новый лист хотя бы одну грань.
			for( unsigned long f = 0; f < m_totalFaces; f++ )
			{
				if( IsFaceInBox( &m_vertices[m_faces[f].vertex0], &m_vertices[m_faces[f].vertex1],
					&m_vertices[m_faces[f].vertex2], newMin, newMax ) == true )
				{
					// A face has been found that is inside the new child scene
					// leaf, so create the scene leaf. Then recurse through the
					// scene leaf's branch of the scene hierarchy.
					// В случае, когда грань/грани найдена внутри нового листа,
					// создаём его (лист). Затем рекурсивно проходим через
					// другие листья сцены, расположенные ниже по иерархии.
					leaf->children[c] = new SceneLeaf;
					RecursiveSceneBuild( leaf->children[c], newTranslation, halfSize / 2.0f );

					break;
				}
			}
		}

		return;
	}

	// Create the leaf's array of face indices.
	// Создаём массив индексов вершин граней листа.
	leaf->totalFaces = totalFaces;
	leaf->faces = new unsigned long[totalFaces];
	// If any face is contained in the leaf's bounding box, then store
	// the index of the face in the leaf's face index array.
	// Если грань расположена внутри ограничивающего бокса листа,
	// сохраняем индекс этой грани в массиве индексов вершин граней листа.
	totalFaces = 0;
	for( unsigned long f = 0; f < m_totalFaces; f++ )
		if( IsFaceInBox( &m_vertices[m_faces[f].vertex0], &m_vertices[m_faces[f].vertex1],
			&m_vertices[m_faces[f].vertex2], leaf->GetBoundingBox()->min, leaf->GetBoundingBox()->max ) == true )
			leaf->faces[totalFaces++] = f;

	// Store pointers to any occluding objects in the leaf.
	// Сохраняем указатели на любые перекрываемые объекты листа.
	m_occludingObjects->Iterate( true );
	while( m_occludingObjects->Iterate() )
		if( IsBoxInBox( m_occludingObjects->GetCurrent()->GetBoundingBox()->min,
			m_occludingObjects->GetCurrent()->GetBoundingBox()->max, leaf->GetBoundingBox()->min,
			leaf->GetBoundingBox()->max ) == true )
			leaf->occluders->Add( m_occludingObjects->GetCurrent() );
}

//-----------------------------------------------------------------------------
// Recursively checks the scene's leaves against the view frustum.
// Рекурсивно проверяет листья сцены относительно усечённой пирамиды вида.
//-----------------------------------------------------------------------------
bool SceneManager::RecursiveSceneFrustumCheck( SceneLeaf *leaf, D3DXVECTOR3 viewer )
{
	// Check if the leaf's bounding sphere is inside the view frustum.
	// Проверяем случай, когда ограничивающая сфера листа расположена внутри
	// усечённой пирамиды вида.
	if( m_viewFrustum.IsSphereInside( leaf->GetBoundingSphere()->centre,
		leaf->GetBoundingSphere()->radius ) == false )
		return false;

	// Check if the leaf's bounding box is inside the view frustum.
	// Проверяем случай, когда ограничивающий бокс листа расположен внутри
	// усечённой пирамиды вида.
	if( m_viewFrustum.IsBoxInside( leaf->GetBoundingBox()->min,
		leaf->GetBoundingBox()->max ) == false )
		return false;

	// Set the visible stamp on this leaf to the current frame stamp. This will
	// indicate that the leaf may be visible this frame and may need rendering.
	// Присваиваем штамп видимости данного листа штампу текущего кадра.
	// Это будет сигналом, что данный лист виден в текущем кадре и (возможно)
	// будет рендерится.
	leaf->visibleStamp = m_frameStamp;

	// Check if any of this leaf's children are visible.
	// Проверяем, видимы ли все дочерние листья (=потомки) данного листа.
	char visibleChildren = 0;
	for( char c = 0; c < 8; c++ )
		if( leaf->children[c] != NULL )
			if( RecursiveSceneFrustumCheck( leaf->children[c], viewer ) )
				visibleChildren++;

	// If this leaf has visible children then this branch of the scene can go
	// deeper. So ignore this leaf.
	// Если данный лист имеет видимые потомки, то можно спуститься ниже
	// по иерархии. В этом случае игнорируем его.
	if( visibleChildren > 0 )
		return false;

	// Iterate through all the occluders in this leaf.
	// Итерируем все оклюдеры данного листа.
	leaf->occluders->Iterate( true );
	while( leaf->occluders->Iterate() )
	{
		// Check if the occluder's bounding sphere is inside the view frustum.
		// Проверяем случай, когда ограничивающая сфера оклюдера расположена
		// внутри усечённой пирамиды вида.
		if( m_viewFrustum.IsSphereInside( leaf->occluders->GetCurrent()->translation,
			leaf->occluders->GetCurrent()->GetBoundingSphere()->radius ) == false )
			continue;

		// Check if the occluder's bounding box is inside the view frustum.
		// Проверяем случай, когда ограничивающий куб оклюдера расположен
		// внутри усечённой пирамиды вида.
		if( m_viewFrustum.IsBoxInside( leaf->occluders->GetCurrent()->GetBoundingBox()->min,
			leaf->occluders->GetCurrent()->GetBoundingBox()->max ) == false )
			continue;

		// Calculate the distance between the occluder and the viewer.
		// Вычисляем расстояние между оклюдером и вьюером.
		leaf->occluders->GetCurrent()->distance = D3DXVec3Length( &( leaf->occluders->GetCurrent()->translation - viewer ) );

		// Iterate through the list of visible occluders.
		// Итерируем список видимых оклюдеров.
		m_visibleOccluders->Iterate( true );
		while( m_visibleOccluders->Iterate() )
		{
			// If the new occluder is already in the list, don't add it agian.
			// Если новый оклюдер уже в списке, не надо его снова добавлять.
			if( leaf->occluders->GetCurrent() == m_visibleOccluders->GetCurrent() )
				break;

			// If the new occluder is closer to the viewer than this occluder,
			// then add it to the list before this occluder.
			// Если новый оклюдер расположен к вьюеру ближе, чем текущий оклюдер,
			// то добавляем его в список ДО данного оклюдера.
			if( leaf->occluders->GetCurrent()->distance < m_visibleOccluders->GetCurrent()->distance )
			{
				m_visibleOccluders->InsertBefore( leaf->occluders->GetCurrent(),
					m_visibleOccluders->GetCompleteElement( m_visibleOccluders->GetCurrent() ) );
				leaf->occluders->GetCurrent()->visibleStamp = m_frameStamp;
				break;
			}
		}

		// If the occluder wasn't in the list or not added then add it now.
		// Если оклюдер не был добавлен в список, то сделаем это сейчас.
		if( leaf->occluders->GetCurrent()->visibleStamp != m_frameStamp )
		{
			m_visibleOccluders->Add( leaf->occluders->GetCurrent() );
			leaf->occluders->GetCurrent()->visibleStamp = m_frameStamp;
		}
	}

	return true;
}

//-----------------------------------------------------------------------------
// Recursively checks the scene's leaves against the occlusion volumes.
// Рекурсивно проверяем положение листьев сцены относительно перекрывающих объёмов.
//-----------------------------------------------------------------------------
void SceneManager::RecursiveSceneOcclusionCheck( SceneLeaf *leaf )
{
	// Ignore the leaf if it is not visible this frame.
	// Пропускаем лист, если он не видим в данном кадре.
	if( leaf->visibleStamp != m_frameStamp )
		return;

	// Iterate through the list of visible occluders.
	// Итерируем список видимых оклюдеров.
	m_visibleOccluders->Iterate( true );
	while( m_visibleOccluders->Iterate() )
	{
		// Ignore hidden occluders.
		// Пропускаем скрытые оклюдеры.
		if( m_visibleOccluders->GetCurrent()->visibleStamp != m_frameStamp )
			continue;

		// If the leaf's bounding sphere is overlapping the occluder's volume
		// and the leaf's bounding box is completely enclosed by the occluder's
		// volume, then the leaf is hidden, so ignore it.
		// Если ограничивающая сфера листа пересекает перекрывающий объём
		// а ограничивающий куб листа полностью входит в перекрывающий объём,
		// то данный лист скрыт от вьюера.
		if( IsSphereOverlappingVolume( m_visibleOccluders->GetCurrent()->planes,
			leaf->GetBoundingSphere()->centre, leaf->GetBoundingSphere()->radius ) == true )
			if( IsBoxEnclosedByVolume( m_visibleOccluders->GetCurrent()->planes,
				leaf->GetBoundingBox()->min, leaf->GetBoundingBox()->max ) == true )
				return;
	}

	// Check if any of this leaf's children are visible.
	// Проверяем листы-потомки на видимость.
	for( char c = 0; c < 8; c++ )
		if( leaf->children[c] != NULL )
			RecursiveSceneOcclusionCheck( leaf->children[c] );

	// Go through all the faces in the leaf.
	for( unsigned long f = 0; f < leaf->totalFaces; f++ )
	{
		// Check this face's render stamp. If it is equal to the current frame
		// stamp, then the face has already been rendered this frame.
		// Проверяем штамп рендеринга данной грани. Если он равен штампу
		// текущего кадра, то грань уже отрендерена в этом кадре.
		if( m_faces[leaf->faces[f]].renderStamp == m_frameStamp )
			continue;

		// Set the face's render stamp to indicate that it has been rendered.
		// Устанавливаем рендер-штамп грани, чтобы показать, что она отрендерена.
		m_faces[leaf->faces[f]].renderStamp = m_frameStamp;

		// Tell the face's render cache to render this face.
		// Командуем рендер-кэшу грани рендерить данную грань.
		m_faces[leaf->faces[f]].renderCache->RenderFace( m_faces[leaf->faces[f]].vertex0,
			m_faces[leaf->faces[f]].vertex1, m_faces[leaf->faces[f]].vertex2 );
	}
}

...
//-----------------------------------------------------------------------------
// Loads a new scene from the given scene file.
// Загружает новую сцену из данного файла скрипта сцены.
//-----------------------------------------------------------------------------
void SceneManager::LoadScene( char *name, char *path )
{
	// Create the lists of objects used in the scene. The dynamic object list
	// is persistent across scene changes so it doesn't need to be created.
	// Создаём связные списки объектов сцены (по типам).
	m_occludingObjects = new LinkedList< SceneOccluder >;
	m_visibleOccluders = new LinkedList< SceneOccluder >;
	m_playerSpawnPoints = new LinkedList< SceneObject >;
	m_objectSpawners = new LinkedList< SpawnerObject >;
...

...
	// Load the script for the scene.
	// Загружаем скрипт сцены.
	Script *script = new Script( name, path );

	// Store the name of the scene.
	// Сохраняем имя сцены.
	m_name = new char[strlen( script->GetStringData( "name" ) ) + 1];
	memcpy( m_name, script->GetStringData( "name" ), ( strlen( script->GetStringData( "name" ) ) + 1 ) * sizeof( char ) );

	// Store the scene's gravity vector.
	// Сохраняем вектор гравитации сцены.
	m_gravity = *script->GetVectorData( "gravity" ) / m_scale;
...

...
	// Create the sun light source.
	// Создаём источник солнечного света.
	D3DLIGHT9 sun;
	sun.Type = D3DLIGHT_DIRECTIONAL;
	sun.Diffuse.r = 1.0f;
	sun.Diffuse.g = 1.0f;
	sun.Diffuse.b = 1.0f;
	sun.Diffuse.a = 1.0f;
	sun.Specular = sun.Diffuse;
	sun.Ambient.r = script->GetColourData( "ambient_light" )->r;
	sun.Ambient.g = script->GetColourData( "ambient_light" )->g;
	sun.Ambient.b = script->GetColourData( "ambient_light" )->b;
	sun.Ambient.a = script->GetColourData( "ambient_light" )->a;
	sun.Direction = D3DXVECTOR3( script->GetVectorData( "sun_direction" )->x,
		script->GetVectorData( "sun_direction" )->y,
		script->GetVectorData( "sun_direction" )->z );
	sun.Range = 0.0f;

	// Switch lighting on, enable the sun light, and specular highlights.
	// Включаем созданный выше источник света. Активируем блики.
	g_engine->GetDevice()->SetRenderState( D3DRS_LIGHTING, true );
	g_engine->GetDevice()->SetLight( 0, &sun );
	g_engine->GetDevice()->LightEnable( 0, true );
	g_engine->GetDevice()->SetRenderState( D3DRS_SPECULARENABLE, true );
...

typedef struct D3DLIGHT9 {
  D3DLIGHTTYPE  Type;	// Тип источника света. Возможные значения: D3DLIGHT9_POINT,
			// D3DLIGHT9_SPOT, D3DLIGHT9_DIRECTIONAL.
  D3DCOLORVALUE Diffuse;	// Цвет рассеянного (diffuse) света.
  D3DCOLORVALUE Specular;	// Цвет бликового (specular) света.
  D3DCOLORVALUE Ambient;	// Цвет приглушённого (ambient) света (цвет тени).
  D3DVECTOR     Position;	// Положение в пространстве источника света.
  D3DVECTOR     Direction;	// Направление источника света.
  float         Range;		// Указывает на то, как далеко светит источник.
  float         Falloff;	// Спад по мере увеличения растояния от источника.
  // Затухание по мере увеличения расстояния от источника.
  float         Attenuation0;	
  float         Attenuation1;
  float         Attenuation2;
  // Мутные параметры конусов освещённости. Только для точечных источников (D3DLIGHT9_SPOT).
  float         Theta;	// Угол в радианах внутреннего конуса точечного источника света.
			// В его зоне интенсивность света максимальна. Возможные значения:
			// от 0 до значения параметра Phi.
  float         Phi;	// Угол в радианах, опредеяющий внешний край внешнего конуса
			// точечного источника (край абажура светильника). Все объекты за пределами
			// данного края не освещаются данным источником.
} D3DLIGHT9, *LPD3DLIGHT;

ambient_light colour 0.5 0.5 0.5 1.0

...
	// Set up the fog.
	// Настраиваем туман.
	float density = *script->GetFloatData( "fog_density" ) * m_scale;
	g_engine->GetDevice()->SetRenderState( D3DRS_FOGENABLE, true );
	g_engine->GetDevice()->SetRenderState( D3DRS_FOGCOLOR, D3DCOLOR_COLORVALUE(
		script->GetColourData( "fog_colour" )->r,
		script->GetColourData( "fog_colour" )->g,
		script->GetColourData( "fog_colour" )->b,
		script->GetColourData( "fog_colour" )->a ) );
	g_engine->GetDevice()->SetRenderState( D3DRS_FOGVERTEXMODE, D3DFOG_EXP );
	g_engine->GetDevice()->SetRenderState( D3DRS_FOGDENSITY, *(unsigned long*)&density );
...

...
	// Store the constraints used for creating the scene.
	// Получаем из скрипта сцены параметры листков и сохраняем их в переменные.
	m_maxFaces = *script->GetNumberData( "max_faces" );
	m_maxHalfSize = *script->GetFloatData( "max_half_size" );

	// Load the scene's mesh.
	// Загружаем меш сцены (прописан в скрипте меша).
	m_mesh = g_engine->GetMeshManager()->Add( script->GetStringData( "mesh" ), script->GetStringData( "mesh_path" ) );

	// Destory the scene's script as it is no longer needed.
	// Уничтожаем скрипт сцены, т.к. он болвше не нужен.
	SAFE_DELETE( script );
...

...
	// Set a new projection matrix so the view frustum will fit the scene.
	// Устанавливаем новую матрицу проекции такм образом, чтобы усечённая пирамида вида вмещала в себя сцену.
	D3DDISPLAYMODE *display;
	display = g_engine->GetDisplayMode();
	D3DXMATRIX projection;
	D3DXMatrixPerspectiveFovLH( &projection, D3DX_PI / 4, (float)display->Width / (float)display->Height,
		0.1f / m_scale, m_mesh->GetBoundingSphere()->radius * 2.0f );
	g_engine->GetDevice()->SetTransform( D3DTS_PROJECTION, &projection );

	// Set the view frustum's projection matrix.
	// Назначаем усечённой пирамиде вида рассчитанную выше матрицу проекции. 
	m_viewFrustum.SetProjectionMatrix( projection );

	// Create the list of render caches.
	// Создаём связный список рендер-кэшей.
	m_renderCaches = new LinkedList< RenderCache >;

	// Search the mesh for unique materials.
	// Ищем в меше уникальные материалы.
	for( unsigned long m = 0; m < m_mesh->GetStaticMesh()->NumMaterials; m++ )
	{
		// Flag to determine if the material has been found already.
		// Флаг, определяющий, найден ли материал ранее.
		bool found = false;

		// Ensure the new material is valid.
		// Проверяем, валиден ли новый материал.
		if( m_mesh->GetStaticMesh()->materials[m] == NULL )
			continue;

		// Iterate through the already existing render caches.
		// Итерируем через существующие рендер-кэши.
		m_renderCaches->Iterate( true );
		while( m_renderCaches->Iterate() )
		{
			// Check if the new material already exists.
			// Проверяем случай, когда найденный материал уже есть в списке.
			if( m_renderCaches->GetCurrent()->GetMaterial() == m_mesh->GetStaticMesh()->materials[m] )
			{
				found = true;
				break;
			}
		}

		// Add the material if it wasn't found and not set to ignore faces.
		// Добавляем материал в связный список материалов, если он ранее не был найден в списке
		// и у него не стоит опция "игнорировать грани".
		if( found == false && m_mesh->GetStaticMesh()->materials[m]->GetIgnoreFace() == false )
			m_renderCaches->Add( new RenderCache( g_engine->GetDevice(), m_mesh->GetStaticMesh()->materials[m] ) );
	}
...

...
	// Get a pointer to the mesh's frame list.
	// Получаем указатель на список фреймов меша.
	LinkedList< Frame > *frames = m_mesh->GetFrameList();

	// Iterate through the frame list.
	// Итерируем через связный список фреймов.
	frames->Iterate( true );
	while( frames->Iterate() != NULL )
	{
		// Check if this frame contains an occluder.
		// Проверяем, содержит ли данный фрейм оклюдер (объект, перекрывающий другие объекты).
		if( strncmp( "oc_", frames->GetCurrent()->Name, 3 ) == 0 )
		{
			// If so, load the occluder, and continue to the next frame.
			// Если да, то загружаем оклюдер и переходим к следующему кадру.
			m_occludingObjects->Add( new SceneOccluder( frames->GetCurrent()->GetTranslation(),
				( (MeshContainer*)frames->GetCurrent()->pMeshContainer )->originalMesh,
				&frames->GetCurrent()->finalTransformationMatrix ) );
			continue;
		}

		// Check if this frame is a spawn point.
		// Проверяем, является ли данный фрейм точкой спауна.
		if( strncmp( "sp_", frames->GetCurrent()->Name, 3 ) == 0 )
		{
			// Get the actual name of the spawner object at this spawn point.
			// Получаем актуальное имя спавнер-объекта в данной точке.
			char *firstDash = strpbrk( frames->GetCurrent()->Name, "_" );
			firstDash++;
			char *lastDash = strrchr( firstDash, '_' );
			unsigned long length = lastDash - firstDash;
			char *name = new char[length + 5];
			ZeroMemory( name, sizeof( char ) * ( length + 5 ) );
			strncpy( name, firstDash, length );
			strcat( name, ".txt" );

			// Check if it is a player spawn point.
			// Проверяем, содержит ли фрейм точку спауна игрока.
			if( _stricmp( name, "player.txt" ) == 0 )
			{
				// Get the name of the player spawn point's radius frame.
				// Получаем имя фрейма спаун-радиуса точки спауна игрока.
				char *radiusName = new char[strlen( firstDash ) + 8];
				ZeroMemory( radiusName, sizeof( char ) * ( strlen( firstDash ) + 8 ) );
				strncpy( radiusName, firstDash, strlen( firstDash ) );
				strcat( radiusName, "_radius" );

				// Find the player spawn point's radius frame.
				// Ищем спаун-радиус точки спауна игрока.
				Frame *radiusFrame = frames->GetFirst();
				while( radiusFrame != NULL )
				{
					if( _stricmp( radiusFrame->Name, radiusName ) == 0 )
						break;

					radiusFrame = frames->GetNext( radiusFrame );
				}

				// Destroy the string buffer for the radius frame's name.
				// Уничтожаем строковый буфер, содержащий имя фрейма спаун-радиуса.
				SAFE_DELETE_ARRAY( radiusName );

				// Find the distance between the two points (the radius).
				// Находим расстояние между двумя точками (=радиус).
				float radius = 0.0f;
				if( radiusFrame != NULL )
					radius = D3DXVec3Length( &( radiusFrame->GetTranslation() - frames->GetCurrent()->GetTranslation() ) );

				// Create the player spawn point.
				// Создаём точку спауна игрока.
				SceneObject *point = new SceneObject( NULL, NULL );
				point->SetTranslation( frames->GetCurrent()->GetTranslation() );
				point->SetBoundingSphere( D3DXVECTOR3( 0.0f, 0.0f, 0.0f ), radius );
				point->SetVisible( false );
				point->SetGhost( true );
				point->Update( 0.0f );
				m_dynamicObjects->Add( m_playerSpawnPoints->Add( point ) );
			}
			else
			{
				// Create the application specific spawner object.
				// Создаём спаунер-объект, специфичный для приложения.
				SpawnerObject *spawner = new SpawnerObject( name, m_spawnerPath );
				spawner->SetTranslation( frames->GetCurrent()->GetTranslation() );
				spawner->Update( 0.0f );
				m_dynamicObjects->Add( m_objectSpawners->Add( spawner ) );
			}

			// Destroy the string buffer used to create the spawner's name.
			// Уничтожаем строковый буфер, содержащий имя спаун-объекта.
			SAFE_DELETE_ARRAY( name );
		}
	}
...

...
	// A list of valid faces (those with a valid material).
	// Список валидных (= допущенных к рендерингу) граней (т.е. те, которые имеют валидные материалы)
	bool *validFaces = new bool[m_mesh->GetStaticMesh()->originalMesh->GetNumFaces()];
	ZeroMemory( validFaces, sizeof( bool ) * m_mesh->GetStaticMesh()->originalMesh->GetNumFaces() );

	// These are used for locking the vertex, index, and attribute buffers of
	// the meshes. They act as pointers into the data returned by the locks.
	// Эти переменные применяются для блокировки вершин, индексов и буферов атрибутов мешей.
	// Они выступают в роли указателей, куда будут передаваться данные для блокировки.
	Vertex *vertices = NULL;
	unsigned short *indices = NULL;
	unsigned long *attributes = NULL;

	// Lock the mesh's vertex, index, and attribute buffers.
	// Лочим все 3 буфера.
	m_mesh->GetStaticMesh()->originalMesh->LockVertexBuffer( D3DLOCK_READONLY, (void**)&vertices );
	m_mesh->GetStaticMesh()->originalMesh->LockIndexBuffer( D3DLOCK_READONLY, (void**)&indices );
	m_mesh->GetStaticMesh()->originalMesh->LockAttributeBuffer( D3DLOCK_READONLY, &attributes );
...

...
	// Count the faces in the scene that have a valid material.
	// Подсчитываем число граней сцены с валидными материалами.
	for( unsigned long f = 0; f < m_mesh->GetStaticMesh()->originalMesh->GetNumFaces(); f++ )
	{
		m_renderCaches->Iterate( true );
		while( m_renderCaches->Iterate() )
		{
			if( m_renderCaches->GetCurrent()->GetMaterial() == m_mesh->GetStaticMesh()->materials[attributes[f]] )
			{
				m_totalFaces++;
				validFaces[f] = true;
				break;
			}
		}
	}

	// Create the array of faces.
	// Создаём массив граней.
	m_faces = new SceneFace[m_totalFaces];

	// Set the number of vertices.
	// Считаем общее кол-во вершин сцены.
	m_totalVertices = m_totalFaces * 3;

	// Create the vertex buffer that will hold all the vertices in the scene.
	// Создаём вершинный буфер, в котором будут храниться все вершины сцены.
	g_engine->GetDevice()->CreateVertexBuffer( m_totalVertices * VERTEX_FVF_SIZE,
		D3DUSAGE_WRITEONLY, VERTEX_FVF, D3DPOOL_MANAGED, &m_sceneVertexBuffer, NULL );

	// Used for temporary storage of the final vertices that make the scene.
	// Применяем временное хранилище для конечного набора вершин, формирующих сцену.
	Vertex *tempVertices = new Vertex[m_totalVertices];
...

...
	// Lock the scene's vertex buffer
	// Лочим (=блокируем) вершинный буфер) сцены.
	m_sceneVertexBuffer->Lock( 0, 0, (void**)&m_vertices, 0 );

	// Go through all of the valid faces in the mesh and store their details.
	// Итерируем через все валидные грани меша и сохраняем их детали.
	for( unsigned long f = 0; f < m_totalFaces; f++ )
	{
		// Ensure this face is valid.
		// Проверяем, валидна ли грань.
		if( validFaces[f] == false )
		{
			// Advance the indices pointer to skip this face.
			// Увеличиваем число индексов, припустив данную грань.
			indices += 3;
			continue;
		}

		// Store the index pointer for each vertex in the face.
		// Инкрементируем кол-во указателей на каждый из индексов после размещения
		// в индексном буфере каждой вершины
		m_faces[f].vertex0 = *indices++;
		m_faces[f].vertex1 = *indices++;
		m_faces[f].vertex2 = *indices++;

		// Find the render cache this face belongs to.
		// Находим рендер-кэш, которому принадлежит данная грань.
		m_renderCaches->Iterate( true );
		while( m_renderCaches->Iterate() )
		{
			if( m_renderCaches->GetCurrent()->GetMaterial() == m_mesh->GetStaticMesh()->materials[attributes[f]] )
			{
				m_faces[f].renderCache = m_renderCaches->GetCurrent();
				m_renderCaches->GetCurrent()->AddFace();
				break;
			}
		}

		// Take of temporary copy of these vertices.
		// Делаем временную копию этих вершин.
		tempVertices[m_faces[f].vertex0] = vertices[m_faces[f].vertex0];
		tempVertices[m_faces[f].vertex1] = vertices[m_faces[f].vertex1];
		tempVertices[m_faces[f].vertex2] = vertices[m_faces[f].vertex2];
	}
...

...
	// Copy the final vertices (that make up the scene) into the vertex buffer.
	// Копируем конечный список вершин (которые сформируют сцену) в вершинный буфер.
	memcpy( m_vertices, tempVertices, m_totalVertices * VERTEX_FVF_SIZE );

	// Unlock the scene's vertex buffer.
	// Разблокируем вершинный буфер сцены.
	m_sceneVertexBuffer->Unlock();

	// Destroy the temporary vertices array.
	// Уничтожаем временный массив вершин.
	SAFE_DELETE_ARRAY( tempVertices );

	// Unlock the mesh's vertex, index, and attribute buffers.
	// Разблокируем все 3 буфера.
	m_mesh->GetStaticMesh()->originalMesh->UnlockAttributeBuffer();
	m_mesh->GetStaticMesh()->originalMesh->UnlockIndexBuffer();
	m_mesh->GetStaticMesh()->originalMesh->UnlockVertexBuffer();

	// Destroy the array of valid faces.
	// Уничтожаем массив валидных граней.
	SAFE_DELETE_ARRAY( validFaces );
...

...
	// Create the first scene leaf (the largest leaf that encloses the scene).
	// Создаём первый лист октодерева (самый большой, заключающий в себе всю сцену целиком).
	m_firstLeaf = new SceneLeaf();

	// Recursively build the scene, starting with the first leaf.
	// Рекурсивно строим сцену, начиная с первого листа октодерева.
	RecursiveSceneBuild( m_firstLeaf, m_mesh->GetBoundingSphere()->centre, m_mesh->GetBoundingBox()->halfSize );

	// Allow the render caches to prepare themselves.
	// Готовим рендер-кэши.
	m_renderCaches->Iterate( true );
	while( m_renderCaches->Iterate() )
		m_renderCaches->GetCurrent()->Prepare( m_totalVertices );

	// Indicate that the scene is now loaded.
	// Ставим отметку о том, что сцена загружена.
	m_loaded = true;
}
...

...
//-----------------------------------------------------------------------------
// Recursively builds the scene.
// Рекурсивно строим сцену.
//-----------------------------------------------------------------------------
void SceneManager::RecursiveSceneBuild( SceneLeaf *leaf, D3DXVECTOR3 translation, float halfSize )
{
	// Build a bounding volume around this leaf.
	// Строим ограничивающие объёмы вокруг данного листа октодерева.
	leaf->SetBoundingBox( D3DXVECTOR3( translation.x - halfSize, translation.y - halfSize, translation.z - halfSize ),
		D3DXVECTOR3( translation.x + halfSize, translation.y + halfSize, translation.z + halfSize ) );
	leaf->SetBoundingSphere( translation, (float)sqrt( halfSize * halfSize + halfSize * halfSize + halfSize * halfSize ) );

	// Count the number of face in this leaf.
	// Считаем число граней в данном листе.
	unsigned long totalFaces = 0;
	for( unsigned long f = 0; f < m_totalFaces; f++ )
		if( IsFaceInBox( &m_vertices[m_faces[f].vertex0], &m_vertices[m_faces[f].vertex1],
			&m_vertices[m_faces[f].vertex2], leaf->GetBoundingBox()->min, leaf->GetBoundingBox()->max ) == true )
			totalFaces++;

	// Only divide the leaf up if it is too big and contains too many faces.
	// Делим лист только если он чересчур большой и содержит слишком много граней.
	if( halfSize > m_maxHalfSize && totalFaces > m_maxFaces )
	{
		// Go through all the child leaves.
		for( char c = 0; c < 8; c++ )
		{
			D3DXVECTOR3 newTranslation, newMin, newMax;
			float newHalfSize = halfSize / 2.0f;
			float mod;

			// Calculate the translation of the new leaf on the x axis.
			// Вычисляем трансляцию нового листа по оси х.
			mod = 1.0f;
			if( c % 2 < 1 )
				mod = -1.0f;
			newTranslation.x = translation.x + newHalfSize * mod;

			// Calculate the translation of the new leaf on the y axis.
			// Вычисляем трансляцию нового листа по оси y.
			mod = 1.0f;
			if( c % 4 < 2 )
				mod = -1.0f;
			newTranslation.y = translation.y + newHalfSize * mod;

			// Calculate the translation of the new leaf on the z axis.
			// Вычисляем трансляцию нового листа по оси z.
			mod = 1.0f;
			if( c % 8 < 4 )
				mod = -1.0f;
			newTranslation.z = translation.z + newHalfSize * mod;

			// Calculate the bounding box around the new leaf.
			// Подсчитываем размер ограничивающего объёма нового листа.
			newMin = D3DXVECTOR3( newTranslation.x - newHalfSize, newTranslation.y - newHalfSize,
				newTranslation.z - newHalfSize );
			newMax = D3DXVECTOR3( newTranslation.x + newHalfSize, newTranslation.y + newHalfSize,
				newTranslation.z + newHalfSize );

			// Check if the new scene leaf will have at least one face in it.
			// Проверяем, содержит ли новый лист хотя бы одну грань.
			for( unsigned long f = 0; f < m_totalFaces; f++ )
			{
				if( IsFaceInBox( &m_vertices[m_faces[f].vertex0], &m_vertices[m_faces[f].vertex1],
					&m_vertices[m_faces[f].vertex2], newMin, newMax ) == true )
				{
					// A face has been found that is inside the new child scene
					// leaf, so create the scene leaf. Then recurse through the
					// scene leaf's branch of the scene hierarchy.
					// В случае, когда грань/грани найдена внутри нового листа,
					// создаём его (лист). Затем рекурсивно проходим через
					// другие листья сцены, расположенные ниже по иерархии.
					leaf->children[c] = new SceneLeaf;
					RecursiveSceneBuild( leaf->children[c], newTranslation, halfSize / 2.0f );

					break;
				}
			}
		}

		return;
	}

	// Create the leaf's array of face indices.
	// Создаём массив индексов вершин граней листа.
	leaf->totalFaces = totalFaces;
	leaf->faces = new unsigned long[totalFaces];

	// If any face is contained in the leaf's bounding box, then store
	// the index of the face in the leaf's face index array.
	// Если грань расположена внутри ограничивающего бокса листа,
	// сохраняем индекс этой грани в массиве индексов вершин граней листа.
	totalFaces = 0;
	for( unsigned long f = 0; f < m_totalFaces; f++ )
		if( IsFaceInBox( &m_vertices[m_faces[f].vertex0], &m_vertices[m_faces[f].vertex1],
			&m_vertices[m_faces[f].vertex2], leaf->GetBoundingBox()->min, leaf->GetBoundingBox()->max ) == true )
			leaf->faces[totalFaces++] = f;

	// Store pointers to any occluding objects in the leaf.
	// Сохраняем указатели на любые перекрываемые объекты листа.
	m_occludingObjects->Iterate( true );
	while( m_occludingObjects->Iterate() )
		if( IsBoxInBox( m_occludingObjects->GetCurrent()->GetBoundingBox()->min,
			m_occludingObjects->GetCurrent()->GetBoundingBox()->max, leaf->GetBoundingBox()->min,
			leaf->GetBoundingBox()->max ) == true )
			leaf->occluders->Add( m_occludingObjects->GetCurrent() );
}
...

...
//-----------------------------------------------------------------------------
// Updates the scene and all the objects in it.
// Обновляет сцену и все объекты на ней.
//-----------------------------------------------------------------------------
void SceneManager::Update( float elapsed, D3DXMATRIX *view )
{
	// Ensure a scene is loaded.
	// Убеждаемся, что сцена загружена.
	if( m_firstLeaf == NULL )
		return;

	// Increment the frame stamp. Indicating the start of a new frame.
	// Инкрементируем (увеличиваем на 1) штамп фрейма.
	m_frameStamp++;

	// Update the view frustum.
	// Обновляем усечённую пирамиду вида.
	m_viewFrustum.Update( view );

	// Go through all the dynamic object's and update them.
	// Итерируем все динамические объекты и обновляем их.
	m_dynamicObjects->Iterate( true );
	while( m_dynamicObjects->Iterate() )
	{
		// Ignore the object if it is not enabled.
		// Игнорируем отключенные объекты.
		if( m_dynamicObjects->GetCurrent()->GetEnabled() == false )
			continue;

		// If this object is a ghost, then it cannot collided with anything.
		// However, it still needs to be updated. Since objects receive their
		// movement through the collision system, ghost objects will have to be
		// allowed to update their movement manually.
		// Если объект является призраком, то он не может сталкиваться с чем-либо.
		// Но в любом случае он тоже должен быть обновлён.
		// В свете того, что объекты получают своё движение через систему столкновений,
		// объекты-призраки должны быть допущены к обновлению своих положений вручную.
		if( m_dynamicObjects->GetCurrent()->GetGhost() == true )
		{
			m_dynamicObjects->GetCurrent()->Update( elapsed );
			continue;
		}

		// Objects without an ellipsoid radius cannot collide with anything.
		// Объекты без радиуса эллипсоида не могут сталкиваться с чем-либо.
		if( m_dynamicObjects->GetCurrent()->GetEllipsoidRadius().x + m_dynamicObjects->GetCurrent()->GetEllipsoidRadius().y,
			m_dynamicObjects->GetCurrent()->GetEllipsoidRadius().z <= 0.0f )
		{
			m_dynamicObjects->GetCurrent()->Update( elapsed );
			continue;
		}

		// Build the collision data for this object.
		// Заполняем данные столкновения по данном объекту.
		static CollisionData collisionData;
		collisionData.scale = m_scale;
		collisionData.elapsed = elapsed;
		collisionData.frameStamp = m_frameStamp;
		collisionData.object = m_dynamicObjects->GetCurrent();
		collisionData.gravity = m_gravity * elapsed;

		// Perform collision detection for this object.
		// Выполняем определение столкновения для данного объекта.
		PerformCollisionDetection( &collisionData, (Vertex*)m_vertices, m_faces, m_totalFaces, m_dynamicObjects );

		// Allow the object to update itself.
		// Позволяем объекту обновить самого себя.
		m_dynamicObjects->GetCurrent()->Update( elapsed, false );
	}
}
...

...
//-----------------------------------------------------------------------------
// Renders the scene and all the objects in it.
// Рендерпт сцену и все объекты на ней.
//-----------------------------------------------------------------------------
void SceneManager::Render( float elapsed, D3DXVECTOR3 viewer )
{
	// Ensure a scene is loaded.
	// Убеждаемся, что сцена загружена.
	if( m_firstLeaf == NULL )
		return;

	// Clear the list of visible occluders.
	// Очищаем список видимых оклюдеров.
	m_visibleOccluders->ClearPointers();

	// Begin the process of determining the visible leaves in the scene. The
	// first step involves checking the scene leaves against the view frustum.
	// Начинаем процесс определения видимых листьев октодерева сцены.
	// Первым делом проверяем листья, расположенные напротив усечённой пирамиды вида.
	RecursiveSceneFrustumCheck( m_firstLeaf, viewer );
...

...
//-----------------------------------------------------------------------------
// Recursively checks the scene's leaves against the view frustum.
// Рекурсивно проверяет листья сцены относительно усечённой пирамиды вида.
//-----------------------------------------------------------------------------
bool SceneManager::RecursiveSceneFrustumCheck( SceneLeaf *leaf, D3DXVECTOR3 viewer )
{
	// Check if the leaf's bounding sphere is inside the view frustum.
	// Проверяем случай, когда ограничивающая сфера листа расположена внутри
	// усечённой пирамиды вида.
	if( m_viewFrustum.IsSphereInside( leaf->GetBoundingSphere()->centre,
		leaf->GetBoundingSphere()->radius ) == false )
		return false;

	// Check if the leaf's bounding box is inside the view frustum.
	// Проверяем случай, когда ограничивающий бокс листа расположен внутри
	// усечённой пирамиды вида.
	if( m_viewFrustum.IsBoxInside( leaf->GetBoundingBox()->min,
		leaf->GetBoundingBox()->max ) == false )
		return false;

	// Set the visible stamp on this leaf to the current frame stamp. This will
	// indicate that the leaf may be visible this frame and may need rendering.
	// Присваиваем штамп видимости данного листа штампу текущего кадра.
	// Это будет сигналом, что данный лист виден в текущем кадре и (возможно)
	// будет рендерится.
	leaf->visibleStamp = m_frameStamp;

	// Check if any of this leaf's children are visible.
	// Проверяем, видимы ли все дочерние листья (=потомки) данного листа.
	char visibleChildren = 0;
	for( char c = 0; c < 8; c++ )
		if( leaf->children[c] != NULL )
			if( RecursiveSceneFrustumCheck( leaf->children[c], viewer ) )
				visibleChildren++;

	// If this leaf has visible children then this branch of the scene can go
	// deeper. So ignore this leaf.
	// Если данный лист имеет видимые потомки, то можно спуститься ниже
	// по иерархии. В этом случае игнорируем его.
	if( visibleChildren > 0 )
		return false;

	// Iterate through all the occluders in this leaf.
	// Итерируем все оклюдеры данного листа.
	leaf->occluders->Iterate( true );
	while( leaf->occluders->Iterate() )
	{
		// Check if the occluder's bounding sphere is inside the view frustum.
		// Проверяем случай, когда ограничивающая сфера оклюдера расположена
		// внутри усечённой пирамиды вида.
		if( m_viewFrustum.IsSphereInside( leaf->occluders->GetCurrent()->translation,
			leaf->occluders->GetCurrent()->GetBoundingSphere()->radius ) == false )
			continue;

		// Check if the occluder's bounding box is inside the view frustum.
		// Проверяем случай, когда ограничивающий куб оклюдера расположен
		// внутри усечённой пирамиды вида.
		if( m_viewFrustum.IsBoxInside( leaf->occluders->GetCurrent()->GetBoundingBox()->min,
			leaf->occluders->GetCurrent()->GetBoundingBox()->max ) == false )
			continue;

		// Calculate the distance between the occluder and the viewer.
		// Вычисляем расстояние между оклюдером и вьюером.
		leaf->occluders->GetCurrent()->distance = D3DXVec3Length( &( leaf->occluders->GetCurrent()->translation - viewer ) );

		// Iterate through the list of visible occluders.
		// Итерируем список видимых оклюдеров.
		m_visibleOccluders->Iterate( true );
		while( m_visibleOccluders->Iterate() )
		{
			// If the new occluder is already in the list, don't add it agian.
			// Если новый оклюдер уже в списке, не надо его снова добавлять.
			if( leaf->occluders->GetCurrent() == m_visibleOccluders->GetCurrent() )
				break;

			// If the new occluder is closer to the viewer than this occluder,
			// then add it to the list before this occluder.
			// Если новый оклюдер расположен к вьюеру ближе, чем текущий оклюдер,
			// то добавляем его в список ДО данного оклюдера.
			if( leaf->occluders->GetCurrent()->distance < m_visibleOccluders->GetCurrent()->distance )
			{
				m_visibleOccluders->InsertBefore( leaf->occluders->GetCurrent(),
					m_visibleOccluders->GetCompleteElement( m_visibleOccluders->GetCurrent() ) );
				leaf->occluders->GetCurrent()->visibleStamp = m_frameStamp;
				break;
			}
		}

		// If the occluder wasn't in the list or not added then add it now.
		// Если оклюдер не был добавлен в список, то сделаем это сейчас.
		if( leaf->occluders->GetCurrent()->visibleStamp != m_frameStamp )
		{
			m_visibleOccluders->Add( leaf->occluders->GetCurrent() );
			leaf->occluders->GetCurrent()->visibleStamp = m_frameStamp;
		}
	}

	return true;
}
...

...
	// A list of potentially visible leaves and occluders has been determined
	// after check against the view frustum. The next step is to go through and
	// further refine the list of visible occluders through occlusion culling.
	// Далее итерируем список видимых оклюдеров для определения отсечений объектов,
	// заслонённых ими.
	m_visibleOccluders->Iterate( true );
	while( m_visibleOccluders->Iterate() )
	{
		// If the occluder's visible stamp does not not equal the current frame
		// stamp then the occluder has been hidden somehow, so ignore it.
		// Если штамп видимости оклюдера не соответствует штампу текущего фрейма,
		// значит этот оклюдер спрятан. Поэтому игнорируем его.
		if( m_visibleOccluders->GetCurrent()->visibleStamp != m_frameStamp )
			continue;

		// Build the occluder's occlusion volume.
		// Создаем ограничивающий объём вокруг оклюдера.
		BuildOcclusionVolume( m_visibleOccluders->GetCurrent(), viewer );

		// Iterate through the rest of the visible occluder's.
		// Итерируем оставшиеся видимые оклюдеры.
		SceneOccluder *occludee = m_visibleOccluders->GetNext( m_visibleOccluders->GetCurrent() );
		while( occludee != NULL )
		{
			// If the occludee's bounding sphere is overlapping the occluder's
			// volume and the occludee's bounding box is completely enclosed by
			// the occluder's volume, then the occludee is hidden.
			// Если ограничивающая сфера заслоняемого объекта перекрывает
			// ограничивающий объём оклюдера, а ограничивающий куб заслоняемого объекта
			// полностью заключён внутри огарипчивающего объёма оклюдера (лучи, касающиеся
			// краёв оклюдера уходят бесконечно вдаль), то заслоняемый объект не виден
			// наблюдателю. => Его можно не рендерпть.
			if( IsSphereOverlappingVolume( m_visibleOccluders->GetCurrent()->planes,
				occludee->translation,
				occludee->GetBoundingSphere()->radius ) == true )
				if( IsBoxEnclosedByVolume( m_visibleOccluders->GetCurrent()->planes,
					occludee->GetBoundingBox()->min,
					occludee->GetBoundingBox()->max ) == true )
					occludee->visibleStamp--;

			occludee = m_visibleOccluders->GetNext( occludee );
		}
	}
...

...
//-----------------------------------------------------------------------------
// Builds an occlusion volume for the given occluder.
// Строим перекрывающий объём для данного оклюдера.
//-----------------------------------------------------------------------------
void SceneManager::BuildOcclusionVolume( SceneOccluder *occluder, D3DXVECTOR3 viewer )
{
	// Create a list of edges for the occluder's silhouette.
	// Создаём список рёбер силуэта оклюдера.
	LinkedList< Edge > *edges = new LinkedList< Edge >;

	// Go through all the faces in the occluder's mesh.
	for( unsigned long f = 0; f < occluder->totalFaces; f++ )
	{
		// Get the indices of this face.
		// Получаем индексы вершин грани.
		unsigned short index0 = occluder->indices[3 * f + 0];
		unsigned short index1 = occluder->indices[3 * f + 1];
		unsigned short index2 = occluder->indices[3 * f + 2];

		// Find the angle between the face's normal and the vector point from
		// viewer's position to the face's position. If the angle is less than
		// 0, then the face is visible to the viewer.
		// Вычисляем угол между нормалью грани и вектором, направленным от вьюера
		// к грани. Если данный угол меньше 0, то данная грань вьюеру (=игроку) не видна.
		if( D3DXVec3Dot( &occluder->vertices[index0].normal, &( occluder->vertices[index0].translation - viewer ) ) < 0.0f )
		{
			// Check if the list of edges is empty.
			// Если список граней пуст...
			if( edges->GetTotalElements() == 0 )
			{
				// Add all the edges for this face.
				// Добавляем в список 3 ребра данной грани.
				edges->Add( new Edge( &occluder->vertices[index0], &occluder->vertices[index1] ) );
				edges->Add( new Edge( &occluder->vertices[index1], &occluder->vertices[index2] ) );
				edges->Add( new Edge( &occluder->vertices[index2], &occluder->vertices[index0] ) );
			}
			else
			{
				Edge *found0 = NULL;
				Edge *found1 = NULL;
				Edge *found2 = NULL;

				// Iterate through the list of edges.
				// Итерируем список рёбер.
				edges->Iterate( true );
				while( edges->Iterate() != NULL )
				{
					// Check if the first edge of this face already exists.
					// Проверяем случай, когда первое ребро данной грани уже существует.
					if( ( edges->GetCurrent()->vertex0->translation == occluder->vertices[index0].translation &&
						edges->GetCurrent()->vertex1->translation == occluder->vertices[index1].translation ) ||
						( edges->GetCurrent()->vertex0->translation == occluder->vertices[index1].translation &&
						edges->GetCurrent()->vertex1->translation == occluder->vertices[index0].translation ) )
						found0 = edges->GetCurrent();

					// Check if the second edge of this face already exists.
					// Проверяем случай, когда второе ребро данной грани уже существует.
					if( ( edges->GetCurrent()->vertex0->translation == occluder->vertices[index1].translation &&
						edges->GetCurrent()->vertex1->translation == occluder->vertices[index2].translation ) ||
						( edges->GetCurrent()->vertex0->translation == occluder->vertices[index2].translation &&
						edges->GetCurrent()->vertex1->translation == occluder->vertices[index1].translation ) )
						found1 = edges->GetCurrent();

					// Check if the third edge of this face already exists.
					// Проверяем случай, когда третье ребро данной грани уже существует.
					if( ( edges->GetCurrent()->vertex0->translation == occluder->vertices[index2].translation &&
						edges->GetCurrent()->vertex1->translation == occluder->vertices[index0].translation ) ||
						( edges->GetCurrent()->vertex0->translation == occluder->vertices[index0].translation &&
						edges->GetCurrent()->vertex1->translation == occluder->vertices[index2].translation ) )
						found2 = edges->GetCurrent();
				}

				// If the first edge was found, remove it. Otherwise add it.
				// Если первое ребро найдено, удалим его. В противном случае - добавим в список рёбер.
				if( found0 != NULL )
					edges->Remove( &found0 );
				else
					edges->Add( new Edge( &occluder->vertices[index0], &occluder->vertices[index1] ) );

				// If the second edge was found, remove it. Otherwise add it.
				// Если второе ребро найдено, удалим его. В противном случае - добавим в список рёбер.
				if( found1 != NULL )
					edges->Remove( &found1 );
				else
					edges->Add( new Edge( &occluder->vertices[index1], &occluder->vertices[index2] ) );

				// If the thrid edge was found, remove it. Otherwise add it.
				// Если третье ребро найдено, удалим его. В противном случае - добавим в список рёбер.
				if( found2 != NULL )
					edges->Remove( &found2 );
				else
					edges->Add( new Edge( &occluder->vertices[index2], &occluder->vertices[index0] ) );
			}
		}
	}

	// Empty the occluder's list of planes.
	// Опустошаем список плоскостей оклюдера.
	occluder->planes->Empty();

	// Create the front cap plane.
	// Создаём плоскость верхнего сечения. 
	D3DXPLANE *plane = new D3DXPLANE;
	D3DXPlaneFromPointNormal( plane, &occluder->translation, &( occluder->translation - viewer ) );
	occluder->planes->Add( plane );

	// Iterate through the list of edges.
	// Итерируем список рёбер. 
	edges->Iterate( true );
	while( edges->Iterate() != NULL )
	{
		// Get the position of the vertices in the edge.
		// Получаем позицию вершин ребра.
		D3DXVECTOR3 vertex1 = edges->GetCurrent()->vertex0->translation;
		D3DXVECTOR3 vertex2 = edges->GetCurrent()->vertex1->translation;

		// Calculate the position of the thrid vertex for creating the plane.
		// Вычисляем положение третьей вершины для создания плоскости.
		D3DXVECTOR3 dir = vertex1 - viewer;
		D3DXVec3Normalize( &dir, &dir );
		D3DXVECTOR3 vertex3 = vertex1 + dir;

		// Create a plane from this edge.
		// Создаём плоскость на основе данной грани.
		plane = new D3DXPLANE;
		D3DXPlaneFromPoints( plane, &vertex1, &vertex2, &vertex3 );
		occluder->planes->Add( plane );
	}

	// Destroy the list of edges.
	// Уничтожаем список рёбер.
	SAFE_DELETE( edges );
}
...

...
	// Empty the occluder's list of planes.
	// Опустошаем список плоскостей оклюдера.
	occluder->planes->Empty();

	// Create the front cap plane.
	// Создаём плоскость верхнего сечения. 
	D3DXPLANE *plane = new D3DXPLANE;
	D3DXPlaneFromPointNormal( plane, &occluder->translation, &( occluder->translation - viewer ) );
	occluder->planes->Add( plane );
...

...
	// Iterate through the list of edges.
	// Итерируем список рёбер. 
	edges->Iterate( true );
	while( edges->Iterate() != NULL )
	{
		// Get the position of the vertices in the edge.
		// Получаем позицию вершин ребра.
		D3DXVECTOR3 vertex1 = edges->GetCurrent()->vertex0->translation;
		D3DXVECTOR3 vertex2 = edges->GetCurrent()->vertex1->translation;

		// Calculate the position of the thrid vertex for creating the plane.
		// Вычисляем положение третьей вершины для создания плоскости.
		D3DXVECTOR3 dir = vertex1 - viewer;
		D3DXVec3Normalize( &dir, &dir );
		D3DXVECTOR3 vertex3 = vertex1 + dir;

		// Create a plane from this edge.
		// Создаём плоскость на основе данной грани.
		plane = new D3DXPLANE;
		D3DXPlaneFromPoints( plane, &vertex1, &vertex2, &vertex3 );
		occluder->planes->Add( plane );
	}

	// Destroy the list of edges.
	// Уничтожаем список рёбер.
	SAFE_DELETE( edges );
}
...

...
	// Tell all the render caches to prepare for rendering.
	// Командуем всем рендер-кэшам приготовиться к рендерингу.
	m_renderCaches->Iterate( true );
	while( m_renderCaches->Iterate() )
		m_renderCaches->GetCurrent()->Begin();

	// Finally, check the scene's leaves against the visible occluders.
	// Проверяем листья октодерева сцены на предмет заслонённости оклюдерами.
	RecursiveSceneOcclusionCheck( m_firstLeaf );
...

...
//-----------------------------------------------------------------------------
// Recursively checks the scene's leaves against the occlusion volumes.
// Рекурсивно проверяем положение листьев сцены относительно перекрывающих объёмов.
//-----------------------------------------------------------------------------
void SceneManager::RecursiveSceneOcclusionCheck( SceneLeaf *leaf )
{
	// Ignore the leaf if it is not visible this frame.
	// Пропускаем лист, если он не видим в данном кадре.
	if( leaf->visibleStamp != m_frameStamp )
		return;

	// Iterate through the list of visible occluders.
	// Итерируем список видимых оклюдеров.
	m_visibleOccluders->Iterate( true );
	while( m_visibleOccluders->Iterate() )
	{
		// Ignore hidden occluders.
		// Пропускаем скрытые оклюдеры.
		if( m_visibleOccluders->GetCurrent()->visibleStamp != m_frameStamp )
			continue;

		// If the leaf's bounding sphere is overlapping the occluder's volume
		// and the leaf's bounding box is completely enclosed by the occluder's
		// volume, then the leaf is hidden, so ignore it.
		// Если ограничивающая сфера листа пересекает перекрывающий объём
		// а ограничивающий куб листа полностью входит в перекрывающий объём,
		// то данный лист скрыт от вьюера.
		if( IsSphereOverlappingVolume( m_visibleOccluders->GetCurrent()->planes,
			leaf->GetBoundingSphere()->centre, leaf->GetBoundingSphere()->radius ) == true )
			if( IsBoxEnclosedByVolume( m_visibleOccluders->GetCurrent()->planes,
				leaf->GetBoundingBox()->min, leaf->GetBoundingBox()->max ) == true )
				return;
	}

	// Check if any of this leaf's children are visible.
	// Проверяем листы-потомки на видимость.
	for( char c = 0; c < 8; c++ )
		if( leaf->children[c] != NULL )
			RecursiveSceneOcclusionCheck( leaf->children[c] );

	// Go through all the faces in the leaf.
	for( unsigned long f = 0; f < leaf->totalFaces; f++ )
	{
		// Check this face's render stamp. If it is equal to the current frame
		// stamp, then the face has already been rendered this frame.
		// Проверяем штамп рендеринга данной грани. Если он равен штампу
		// текущего кадра, то грань уже отрендерена в этом кадре.
		if( m_faces[leaf->faces[f]].renderStamp == m_frameStamp )
			continue;

		// Set the face's render stamp to indicate that it has been rendered.
		// Устанавливаем рендер-штамп грани, чтобы показать, что она отрендерена.
		m_faces[leaf->faces[f]].renderStamp = m_frameStamp;

		// Tell the face's render cache to render this face.
		// Командуем рендер-кэшу грани рендерить данную грань.
		m_faces[leaf->faces[f]].renderCache->RenderFace( m_faces[leaf->faces[f]].vertex0,
			m_faces[leaf->faces[f]].vertex1, m_faces[leaf->faces[f]].vertex2 );
	}
}
...

...
	// Check if any of this leaf's children are visible.
	// Проверяем, видимы ли все дочерние листья (=потомки) данного листа.
	char visibleChildren = 0;
	for( char c = 0; c < 8; c++ )
		if( leaf->children[c] != NULL )
			if( RecursiveSceneFrustumCheck( leaf->children[c], viewer ) )
				visibleChildren++;
...

...
	// Set an identity world transformation matrix to render around the origin.
	// Устанавливаем мировую матрицу идентичности для рендеринга относительно
	// начала координат.
	D3DXMATRIX world;
	D3DXMatrixIdentity( &world );
	g_engine->GetDevice()->SetTransform( D3DTS_WORLD, &world );

	// Set the scene vertex buffer as the current device data stream.
	// Назначаем вершинный буфер сцены в качестве потока данных объекта устройства Direct3D.
	g_engine->GetDevice()->SetStreamSource( 0, m_sceneVertexBuffer, 0, VERTEX_FVF_SIZE );
	g_engine->GetDevice()->SetFVF( VERTEX_FVF );

	// Tell all the render caches to end rendering. This will cause them to
	// send their faces to be render to the video card.
	// Командуем всем рендер-кэшам заканчивать рендеринг. Это приведёт к отправке ими всех
	// граней в видеокарту, на рендеринг.
	m_renderCaches->Iterate( true );
	while( m_renderCaches->Iterate() )
		m_renderCaches->GetCurrent()->End();
...

...
	// Iterate through the list of dynamic objects.
	// Итерируем через список динамических объектов.
	m_dynamicObjects->Iterate( true );
	while( m_dynamicObjects->Iterate() )
	{
		// Check if the object is visible.
		// Проверяем, видим ли объект.
		if( m_dynamicObjects->GetCurrent()->GetVisible() == false )
			continue;

		// Check if the object's bounding sphere is inside the view frustum.
		// Проверяем, расположена ли ограничивающая сфера объекта внутри
		// усечённой пирамиды вида.
		if( m_viewFrustum.IsSphereInside( m_dynamicObjects->GetCurrent()->GetBoundingSphere()->centre,
			m_dynamicObjects->GetCurrent()->GetBoundingSphere()->radius ) == false )
			continue;

		// Iterate through the list of visible occluders.
		// Итерируем список видимых оклюдеров.
		bool occluded = false;
		m_visibleOccluders->Iterate( true );
		while( m_visibleOccluders->Iterate() )
		{
			// Ignore hidden occluders.
			// Игнориуем спрятанные оклюдеры.
			if( m_visibleOccluders->GetCurrent()->visibleStamp != m_frameStamp )
				continue;

			occluded = true;

			// Check the object's bounding sphere against the occlusion volume.
			// Проверяем ограничивающую сферу объекта на предмет попадания внутрь
			// перекрывающего объёма.
			m_visibleOccluders->GetCurrent()->planes->Iterate( true );
			while( m_visibleOccluders->GetCurrent()->planes->Iterate() )
			{
				if( D3DXPlaneDotCoord( m_visibleOccluders->GetCurrent()->planes->GetCurrent(),
					&m_dynamicObjects->GetCurrent()->GetBoundingSphere()->centre )
					< m_dynamicObjects->GetCurrent()->GetBoundingSphere()->radius )
				{
					occluded = false;
					break;
				}
			}

			// Break if the object is completely hidden by this occluder.
			// Прерываем, если объект полностью заслонён данным оклюдером.
			if( occluded == true )
				break;
		}

		// Ignore this object if it is occluded.
		// Игнорируем полностью заслонённый объект и продолжаем итерацию дальше.
		if( occluded == true )
			continue;

		// Render the object.
		// Рендерпм объект.
		m_dynamicObjects->GetCurrent()->Render();
	}
}
...

#include "SceneManager.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 "Mesh.h"
#include "SceneObject.h"
#include "AnimatedObject.h"
#include "SpawnerObject.h"
#include "ViewFrustum.h"
#include "RenderCache.h"
#include "SceneManager.h"
#include "CollisionDetection.h"
#include "State.h"
...

SceneManager *m_sceneManager;// Scene manager.

...
private:
	bool m_loaded; // Indicates if the engine is loading.
					// Флаг показывает, загружен ли движок
	HWND m_window; // Main window handle.
					// Дескриптор главного окна приложения
	bool m_deactive; // Indicates if the application is active or not.
					// Флаг активности приложения

	EngineSetup *m_setup; // Copy of the engine setup structure.
					// Копия структуры EngineSetup
	IDirect3DDevice9 *m_device;
	D3DDISPLAYMODE m_displayMode;
	ID3DXSprite *m_sprite;
	unsigned char m_currentBackBuffer;

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

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

SceneManager *GetSceneManager();

...
//-----------------------------------------------------------------------------
// Engine Class
//-----------------------------------------------------------------------------
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();
	ResourceManager< Mesh > *GetMeshManager();
	Input *GetInput();
	Network *GetNetwork();
	SoundSystem *GetSoundSystem();
	SceneManager *GetSceneManager();
...

// Create the scene manager.
	m_sceneManager = new SceneManager( m_setup->scale, m_setup->spawnerPath );

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

	// Создаём экземпляр класса Network.
	m_network = new Network( m_setup->guid, m_setup->HandleNetworkMessage );

	m_soundSystem = new SoundSystem( m_setup->scale );

	// Create the scene manager.
	m_sceneManager = new SceneManager( m_setup->scale, m_setup->spawnerPath );

	// Seed the random number generator with the current time.
	// Стартуем генератор сулчайных чисел на основе текущего времени.
	srand( timeGetTime() );
...

SAFE_DELETE( m_sceneManager );

...
//-----------------------------------------------------------------------------
// The engine class destructor.
//-----------------------------------------------------------------------------
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_sceneManager );
		SAFE_DELETE( m_soundSystem );
		SAFE_DELETE( m_network );
		SAFE_DELETE( m_input );
		SAFE_DELETE( m_meshManager);
		SAFE_DELETE( m_materialManager);
...

// Update the scene.
m_sceneManager->Update( elapsed, viewer.viewer->GetViewMatrix() );

...
				// Запрос вьюера текущего стейта (если таковой имеется).
				if( m_currentState != NULL )
				{
					m_currentState->RequestViewer( &viewer );
				}

				if( viewer.viewer != NULL ) // Проверяем, валиден ли вьюер.
				{
					// Update the scene.
					m_sceneManager->Update( elapsed, viewer.viewer->GetViewMatrix() );

					// Устанавливаем трансформацию вида (view transformation).
					m_device->SetTransform( D3DTS_VIEW, viewer.viewer->GetViewMatrix() );

					// Обновляем объект 3D-слушателя (3D sound listener).
					m_soundSystem->UpdateListener( viewer.viewer->GetForwardVector(),
						viewer.viewer->GetTranslation(), viewer.viewer->GetVelocity() );
				}
...

// Render the scene, if there is a valid viewer.
					if( viewer.viewer != NULL )
						m_sceneManager->Render( elapsed, viewer.viewer->GetTranslation() );

...
				// Подготавливаем сцену.
				m_device->Clear( 0, NULL, viewer.viewClearFlags, 0, 1.0f, 0 );
				if( SUCCEEDED( m_device->BeginScene() ) )
				{
					// Render the scene, if there is a valid viewer.
					if( viewer.viewer != NULL )
						m_sceneManager->Render( elapsed, viewer.viewer->GetTranslation() );

					// Рендерим текущий стейт, если таковой имеется.
					if( m_currentState != NULL )
						m_currentState->Render();

					// Заканчиваем готовить сцену и показываем её.
					m_device->EndScene();
					m_device->Present( NULL, NULL, NULL, NULL );
...

...
//-----------------------------------------------------------------------------
// Returns a pointer to the scene manager.
//-----------------------------------------------------------------------------
SceneManager *Engine::GetSceneManager()
{
	return m_sceneManager;
}