1.5 Добавляем поддержку базовой геометрии (Geometry.h)

//-----------------------------------------------------------------------------
// File: Geometry.h
// Various geometry structures and processing functions.
// Объявление и реализация вспомогательных функций и классов для работы
// с геометрическими примитивами (точка, ребро, грань, шар, куб и т.д.).
//
// Programming a Multiplayer First Person Shooter in DirectX
// Copyright (c) 2004 Vaughan Young
//-----------------------------------------------------------------------------
#ifndef GEOMETRY_H
#define GEOMETRY_H

//-----------------------------------------------------------------------------
// Vertex Structure
//-----------------------------------------------------------------------------
struct Vertex
{
	D3DXVECTOR3 translation; // Translation of the vertex (in world space).
	D3DXVECTOR3 normal; // Vertex's normal vector.
	float tu, tv; // Texture UV coordinates.

	//-------------------------------------------------------------------------
	// The vertex structure constructor.
	//-------------------------------------------------------------------------
	Vertex()
	{
		translation = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
		normal = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
		tu = 0.0f;
		tv = 0.0f;
	}

	//-------------------------------------------------------------------------
	// The vertex structure constructor.
	//-------------------------------------------------------------------------
	Vertex( D3DXVECTOR3 t, D3DXVECTOR3 n, float u, float v )
	{
		translation = t;
		normal = n;
		tu = u;
		tv = v;
	}
};
#define VERTEX_FVF ( D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1 )
#define VERTEX_FVF_SIZE D3DXGetFVFVertexSize( VERTEX_FVF )

//-----------------------------------------------------------------------------
// Lit Vertex Structure
// Структура освещаемой вершины
//-----------------------------------------------------------------------------
struct LVertex
{
	D3DXVECTOR3 translation; // Translation of the vertex (in world space).
	D3DCOLOR diffuse; // Colour of the vertex.
	float tu, tv; // Texture UV coordinates.

	//-------------------------------------------------------------------------
	// The lit vertex structure constructor.
	//-------------------------------------------------------------------------
	LVertex()
	{
		translation = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
		diffuse = 0xFFFFFFFF;
		tu = 0.0f;
		tv = 0.0f;
	}

	//-------------------------------------------------------------------------
	// The lit vertex structure constructor.
	//-------------------------------------------------------------------------
	LVertex( D3DXVECTOR3 t, D3DCOLOR d, float u, float v )
	{
		translation = t;
		diffuse = d;
		tu = u;
		tv = v;
	}
};
#define L_VERTEX_FVF ( D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1 )
#define L_VERTEX_FVF_SIZE D3DXGetFVFVertexSize( L_VERTEX_FVF )

//-----------------------------------------------------------------------------
// Transformed & Lit Vertex Structure
// Структура трансформированной и освещенной вершины
//-----------------------------------------------------------------------------
struct TLVertex
{
	D3DXVECTOR4 translation; // Translation of the vertex (in screen space).
	D3DCOLOR diffuse; // Colour of the vertex.
	float tu, tv; // Texture UV coordinates.

	//-------------------------------------------------------------------------
	// The transformed & lit vertex structure constructor.
	//-------------------------------------------------------------------------
	TLVertex()
	{
		translation = D3DXVECTOR4( 0.0f, 0.0f, 0.0f, 1.0f );
		diffuse = 0xFFFFFFFF;
		tu = 0.0f;
		tv = 0.0f;
	}

	//-------------------------------------------------------------------------
	// The transformed & lit vertex structure constructor.
	//-------------------------------------------------------------------------
	TLVertex( D3DXVECTOR4 t, D3DCOLOR d, float u, float v )
	{
		translation = t;
		diffuse = d;
		tu = u;
		tv = v;
	}
};
#define TL_VERTEX_FVF ( D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1 )
#define TL_VERTEX_FVF_SIZE D3DXGetFVFVertexSize( TL_VERTEX_FVF )

//-----------------------------------------------------------------------------
// Edge Structure
// Сруктура ребра
//-----------------------------------------------------------------------------
struct Edge
{
	Vertex *vertex0; // First vertex of the edge.
	Vertex *vertex1; // Second vertex of the edge.

	//-------------------------------------------------------------------------
	// The edge structure constructor.
	//-------------------------------------------------------------------------
	Edge( Vertex *v0, Vertex *v1 )
	{
		vertex0 = v0;
		vertex1 = v1;
	}
};

//-----------------------------------------------------------------------------
// Indexed Edge Structure
// Структура индексированного ребра
//-----------------------------------------------------------------------------
struct IndexedEdge
{
	unsigned short vertex0; // Index of the edge's first vertex.
	unsigned short vertex1; // Index of the edge's second vertex.
};

//-----------------------------------------------------------------------------
// Face Structure
// Структура грани (Face Structure)
//-----------------------------------------------------------------------------
struct Face
{
	Vertex *vertex0; // First vertex of the face.
				// Первая вершина грани
	Vertex *vertex1; // Second vertex of the face.
				// Вторая вершина грани
	Vertex *vertex2; // Third vertex of the face.
				// Третья вершина грани

	//-------------------------------------------------------------------------
	// The face structure constructor.
	//-------------------------------------------------------------------------
	Face( Vertex *v0, Vertex *v1, Vertex *v2 )
	{
		vertex0 = v0;
		vertex1 = v1;
		vertex2 = v2;
	}
};

//-----------------------------------------------------------------------------
// Indexed Face Structure
// Структура индексированной грани
//-----------------------------------------------------------------------------
struct IndexedFace
{
	unsigned short vertex0; // Index of the face's first vertex.
				// Индекс первой вершины
	unsigned short vertex1; // Index of the face's second vertex.
				// Индекс второй вершины
	unsigned short vertex2; // Index of the face's third vertex.
				// Индекс третьей вершины
};

//-----------------------------------------------------------------------------
// Returns true if the first given box is inside the second given box.
// Возвращает true, если один данный бокс (куб, шестигранник) находится внутри второго бокса.
//-----------------------------------------------------------------------------
inline bool IsBoxInBox( D3DXVECTOR3 box1Min, D3DXVECTOR3 box1Max, D3DXVECTOR3 box2Min, D3DXVECTOR3 box2Max )
{
	if( box1Min.x > box2Max.x )
		return false;
	if( box1Min.y > box2Max.y )
		return false;
	if( box1Min.z > box2Max.z )
		return false;
	if( box1Max.x < box2Min.x )
		return false;
	if( box1Max.y < box2Min.y )
		return false;
	if( box1Max.z < box2Min.z )
		return false;

	return true;
}

//-----------------------------------------------------------------------------
// Returns true if the given face is inside the given box.
// Возвращает true, если данная грань находится внутри бокса.
//-----------------------------------------------------------------------------
inline bool IsFaceInBox( Vertex *vertex0, Vertex *vertex1, Vertex *vertex2, D3DXVECTOR3 boxMin, D3DXVECTOR3 boxMax )
{
	// Find the minimum and maximum points of the face along the x axis. Then
	// check if these two points are within the box's x axis extents.
	// Находим крайние (минимальную и максимальную) точки грани по оси x.
	// Затем проверяем, находятся ли эти 2 точки в пределах оси x бокса.
	float minX = min( vertex0->translation.x, min( vertex1->translation.x, vertex2->translation.x ) );
	float maxX = max( vertex0->translation.x, max( vertex1->translation.x, vertex2->translation.x ) );
	if( maxX < boxMin.x )
		return false;
	if( minX > boxMax.x )
		return false;

	// Find the minimum and maximum points of the face along the y axis. Then
	// check if these two points are within the box's y axis extents.
	// Находим крайние (минимальную и максимальную) точки грани по оси y.
	// Затем проверяем, находятся ли эти 2 точки в пределах оси y бокса.
	float minY = min( vertex0->translation.y, min( vertex1->translation.y, vertex2->translation.y ) );
	float maxY = max( vertex0->translation.y, max( vertex1->translation.y, vertex2->translation.y ) );
	if( maxY < boxMin.y )
		return false;
	if( minY > boxMax.y )
		return false;

	// Find the minimum and maximum points of the face along the z axis. Then
	// check if these two points are within the box's z axis extents.
	// Находим крайние (минимальную и максимальную) точки грани по оси z.
	// Затем проверяем, находятся ли эти 2 точки в пределах оси z бокса.
	float minZ = min( vertex0->translation.z, min( vertex1->translation.z, vertex2->translation.z ) );
	float maxZ = max( vertex0->translation.z, max( vertex1->translation.z, vertex2->translation.z ) );
	if( maxZ < boxMin.z )
		return false;
	if( minZ > boxMax.z )
		return false;

	return true;
}

//-----------------------------------------------------------------------------
// Returns true if the given box is completely enclosed by the given volume.
// Возвращает true, если данный бокс полностью размещён внутри данной ёмкости (volume).
//-----------------------------------------------------------------------------
inline bool IsBoxEnclosedByVolume( LinkedList< D3DXPLANE > *planes, D3DXVECTOR3 min, D3DXVECTOR3 max )
{
	planes->Iterate( true );
	while( planes->Iterate() )
	{
		if( D3DXPlaneDotCoord( planes->GetCurrent(), &D3DXVECTOR3( min.x, min.y, min.z ) ) < 0.0f )
			return false;
		if( D3DXPlaneDotCoord( planes->GetCurrent(), &D3DXVECTOR3( max.x, min.y, min.z ) ) < 0.0f )
			return false;
		if( D3DXPlaneDotCoord( planes->GetCurrent(), &D3DXVECTOR3( min.x, max.y, min.z ) ) < 0.0f )
			return false;
		if( D3DXPlaneDotCoord( planes->GetCurrent(), &D3DXVECTOR3( max.x, max.y, min.z ) ) < 0.0f )
			return false;
		if( D3DXPlaneDotCoord( planes->GetCurrent(), &D3DXVECTOR3( min.x, min.y, max.z ) ) < 0.0f )
			return false;
		if( D3DXPlaneDotCoord( planes->GetCurrent(), &D3DXVECTOR3( max.x, min.y, max.z ) ) < 0.0f )
			return false;
		if( D3DXPlaneDotCoord( planes->GetCurrent(), &D3DXVECTOR3( min.x, max.y, max.z ) ) < 0.0f )
			return false;
		if( D3DXPlaneDotCoord( planes->GetCurrent(), &D3DXVECTOR3( max.x, max.y, max.z ) ) < 0.0f )
			return false;
	}

	return true;
}

//-----------------------------------------------------------------------------
// Returns true if the given sphere is overlapping the given volume.
// Возвращает true, если данная сфера (sphere) полностью перекрывает данную ёмкость (volume).
//-----------------------------------------------------------------------------
inline bool IsSphereOverlappingVolume( LinkedList< D3DXPLANE > *planes, D3DXVECTOR3 translation, float radius )
{
	planes->Iterate( true );
	while( planes->Iterate() )
		if( D3DXPlaneDotCoord( planes->GetCurrent(), &translation ) < -radius )
			return false;

	return true;
}

//-----------------------------------------------------------------------------
// Returns true if the two given spheres collide.
// Возвращает true при столкновении двух данных сфер друг с другом.
//-----------------------------------------------------------------------------
inline bool IsSphereCollidingWithSphere( float *collisionDistance, D3DXVECTOR3 translation1,
      D3DXVECTOR3 translation2, D3DXVECTOR3 velocitySum, float radiiSum )
{
	// Get the distance between the two spheres.
	// Вычисляем расстояние между сферами.
	float distanceBetween = D3DXVec3Length( &( translation1 - translation2 ) ) - radiiSum;

	// Get the length of the sum of the velocity vectors of the two spheres.
	// Вычисляем длину суммы векторов скорости (velocity vectors) двух сфер.
	float velocityLength = D3DXVec3Length( &velocitySum );

	// If the spheres are not touching each other and the velocity length is
	// less than the distance between them, then they cannot collide.
	// Если сферы нигде не соприкасаются друг с другом и длина их общего вектора скорости
	// меньше, чем расстояние между ними, то они не могут сталкиваться.
	if( distanceBetween > 0.0f && velocityLength < distanceBetween )
		return false;

	// Get the normalized sum of the velocity vectors.
	// Вычисляем нормализованную сумму векторов скорости двух сфер.
	D3DXVECTOR3 normalizedVelocity;
	D3DXVec3Normalize( &normalizedVelocity, &velocitySum );

	// Get the direction vector from the second sphere to the first sphere.
	// Вычисляем вектор направления движения второй сферы к первой.
	D3DXVECTOR3 direction = translation1 - translation2;

	// Get the angle between the normalized velocity and direction vectors.
	// Вычисляем угол между нормализованными векторами скорости и направления движения.
	float angleBetween = D3DXVec3Dot( &normalizedVelocity, &direction );

	// Check if the spheres are moving away from one another.
	// Проверяем, не удаляются ли сферы друг от друга.
	if( angleBetween <= 0.0f )
	{
		// Check if they are touching (or inside) each other. If not then they
		// cannot collide since they are moving away from one another.
		// Проверяем, соприкасаются ли сферы друг с другом (или одна находится внутри другой). 
		// Если нет, то они не могут сталкиваться, так как они двигаются прочь друг от друга.
		if( distanceBetween < 0.0f )
		{
			// If the velocity length is greater than the distance between the
			// spheres then they are moving away from each other fast enough
			// that they will not be touching when they complete their move.
			// Если длина вектора скорости больше, чем расстояние между
			// сферами, то они удаляются друг от друга достаточно быстро,
			// и ни разу не столкнутся до завершения движения.
			if( velocityLength > -distanceBetween )
				return false;
		}
		else
			return false;
	}

	// Get the length of the direction vector.
	// Вычисляем длину вектора направления движения.
	float directionLength = D3DXVec3Length( &direction );

	// The vector between the two spheres and the velocity vector produce two
	// sides of a triangle. Now use Pythagorean Theorem to find the length of
	// the third side of the triangle (i.e. the hypotenuse).
	// Вектор между двумя сферами и вектор направления движэения образуют две
	// стороны треугольника. Теперь, применив теорему Пифагора, находим
	// третью сторону треугольника (т. е. гипотенузу).
	float hypotenuse = ( directionLength * directionLength ) - ( angleBetween * angleBetween );

	// Ensure that the spheres come closer than the sum of their radii.
	// Проверяем, не подошли ли сферы друг к другу ближе, чем сумма их радиусов.
	float radiiSumSquared = radiiSum * radiiSum;
	if( hypotenuse >= radiiSumSquared )
		return false;

	// Get the distance along the velocity vector that the spheres collide.
	// Then use this distance to calculate the distance to the collision.
	// Вычисляем расстояние по вектору скорости, при котором сферы столкнутся.
	// Затем используем это расстояние для расчёта расстояния до наступления столкновения.
	float distance = radiiSumSquared - hypotenuse;
	*collisionDistance = angleBetween - (float)sqrt( distance );

	// Ensure that the sphere will not travel more than the velocity allows.
	// Проверяем, что сферы не переместятся в пространстве более, чем позволяет их скорость.
	if( velocityLength < *collisionDistance )
		return false;

	return true;
}

#endif

inline bool IsBoxInBox( D3DXVECTOR3 boxlMin, D3DXVECTOR3 boxlMax, D3DXVECTOR3 box2Min, D3DXVECTOR3 box2Max );

inline bool IsFaceInBox( Vertex *vertex0, Vertex *vertex1, Vertex *vertex2, D3DXVECTOR3 boxMin, D3DXVECTOR3 boxMax );

inline bool IsBoxEnclosedByVolume(LinkedList< D3DXPLANE> *planes, D3DXVECTOR3 min, D3DXVECTOR3 max );

inline bool IsSphereOverlappingVolume(LinkedList< D3DXPLANE> *planes, D3DXVECTOR3 translation, float radius );

inline bool IsSphereCollidingWithSphere( float *collisionDistance,
	D3DXVECTOR3 translation1, D3DXVECTOR3 translation2, D3DXVECTOR3 velocitySum, D3DXVECTOR3 radiiSum );

...
//-----------------------------
// Engine Includes
//-----------------------------
#include "LinkedList.h"
#include "ResourceManagement.h"
#include "Geometry.h"
...