/*===========================================================================
PROGRESS ENGINE    - Версия для игры "ВЕЧНОСТЬ"

math9_vector2.h    -    двумерный вектор

АВТОР:    Amon Ra
Copyright:    Infinitation Studio (c) 2001-2009
===========================================================================*/

#ifndef  MATH9_VECTOR2_H
#define  MATH9_VECTOR2_H

/****************************************************************************
Вектор о двух измерениях (может быть важно для реализации меню, и
подобных ему вещей)
****************************************************************************/

#include    "math9.h"

/****************************************************************************
Класс двумерного вектора    Vector2
****************************************************************************/

class    isVector2
{
public:  //Все члены класса публичны по умолчанию

//=======================================================================
//    Данные вектора - переменные x и y
//=======================================================================

float    x,    y;

//=======================================================================
//    Конструкторы вектора
//=======================================================================

eFxp    isVector2( void ){}    //Стандартный конструктор класса
eFxp    isVector2( float x, float y ){}    //Назначаем данные классу вектора

//=======================================================================
//    Операторы вектора
//=======================================================================

eFxp const float    operator[]( int index )  const
{
return (&x)[ index ];
}

eFxp float    operator[]( int index )
{
return (&x)[ index ];
}

//=======================================================================
//    Операции с флоатами
//=======================================================================

eFxp isVector2    operator+ ( float tVar )    const    //Складываем с флоатом
{
return isVector2( x + tVar, y + tVar );    //X и Y складываем по одиночке с флоатом, результат возвращаем в виде вектора
}

eFxp isVector2    operator- ( float tVar )    const    //Из вектора вычитаем флоат
{
return isVector2( x - tVar, y - tVar );    //Из X и Y вычитаем флоат, результат возвращаем в виде вектора
}

eFxp isVector2    operator* ( float tVar )    const    //Умножаем вектор на флоат
{
return isVector2( x * tVar, y * tVar );    //X и Y умножаем по одиночке на флоат, результат возвращаем в виде вектора
}

eFxp isVector2    operator/ ( float tVar )    const    //Делим вектор на флоат
{
return isVector2( x / tVar, y / tVar );    //X и Y делим по одиночке на флоат, результат возвращаем в виде вектора
}

//

eFxp isVector2    operator*=( const float tVar )
{
return isVector2( x *= tVar, y *= tVar );
}

eFxp isVector2    operator/=( const float tVar )
{
return isVector2( x /= tVar, y /= tVar );
}

eFxp isVector2    operator+=( const float tVar )
{
return isVector2( x += tVar, y += tVar );
}

eFxp isVector2    operator-=( const float tVar )
{
return isVector2( x -= tVar, y -= tVar );
}

//=======================================================================
//    Операции с другими двумерными векторами
//=======================================================================

eFxp isVector2    operator+ ( isVector2& tVec )    const
{
return isVector2( x + tVec.x, y + tVec.y );    //Складываем два вектора по элементам
}

eFxp isVector2    operator- ( isVector2& tVec )    const
{
return isVector2( x - tVec.x, y - tVec.y );    //Вычитаем два вектора по элементам
}

eFxp isVector2    operator* ( isVector2& tVec )    const
{
return isVector2( x * tVec.x, y * tVec.y );    //Умножаем поэлементно два вектора
}

eFxp isVector2    operator/ ( isVector2& tVec )    const
{
return isVector2( x / tVec.x, y / tVec.y );    //Поэлементное деление векторов
}

eFxp    float    operator/ ( isVector2& tVec )
{
return ((x * x + y * y) / (tVec.x * tVec.x + tVec.y * tVec.y));    //Деление длин векторов
}

//

eFxp isVector2    operator*=( const isVector2& tVec )
{
return isVector2( x *= tVec.x, y *= tVec.y );
}

eFxp isVector2    operator/=( const isVector2& tVec )
{
return isVector2( x /= tVec.x, y /= tVec.y );
}

eFxp isVector2    operator+=( const isVector2& tVec )
{
return isVector2( x += tVec.x, y += tVec.y );
}

eFxp isVector2    operator-=( const isVector2& tVec )
{
return isVector2( x -= tVec.x, y -= tVec.y );
}

//=======================================================================
//    Операции другого типа
//=======================================================================

eFxp float    operator* ( const isVector2& tVec )    const
{
return x * tVec.x + y * tVec.y;
}

//=======================================================================
//    Операции над самим собой
//=======================================================================

eFxp isVector2    operator- () const
{
return isVector2( -x, -y );     //Инвертируем вектор
}

eFxp isVector2    operator* () const
{
return isVector2( x * x, y * y );   //Умножаем вектор сам на себя
}

//=======================================================================
//    Процедуры
//=======================================================================
eFxp void    CrossProduct( isVector2& tVec1, isVector2& tVec2, isVector2& tVecR );   //Скалярное произведение
eFxp float    Lenght ( isVector2& tVec ) const;                              //Длина вектора
eFxp float    LenghtSquared ( isVector2& tVec ) const;                              //Квадратная длина вектора
eFxp void    Get (isVector2& tVec);                              //Получаем наш вектор
eFxp float    Normalize();                              //Нормализуем вектор
eFxp void    Scale(isVector2& tVec1, isVector2& tVecR, float Scale);       //Проводим изменение размеров вектора
eFxp void    UnScale(isVector2& tVec1, isVector2& tVec2, float Scale);      //Изменение размеров вектора по методу деления вектора на вектор
eFxp void    Add(isVector2& tVec1, isVector2& tVec2, isVector2& tVecR);      //Сложение векторов
eFxp void    Subtract(isVector2& tVec1, isVector2& tVec2, isVector2& tVecR);     //Вычитание векторов
eFxp void    AddScaled(isVector2& tVec1, isVector2& tVec2, float Scale, isVector2& tVecR);    //Сложение со скалированием
eFxp void    AddUnScaled(isVector2& tVec1, isVector2& tVec2, float Scale, isVector2& tVecR);    //Сложение с дескалированием
eFxp void    SubScaled(isVector2& tVec1, isVector2& tVec2, float Scale, isVector2& tVecR);    //Вычитание со скалированием
eFxp void    SubUnScaled(isVector2& tVec1, isVector2& tVec2, float Scale, isVector2& tVecR);    //Вычитание с дескалированием
eFxp void    Copy(isVector2& tVecSrc, isVector2& tVecDst);         //Копирование вектора
eFxp void    Inverse(isVector2& tVec);                              //Инверсия вектора
eFxp void    InverseCopy (isVector2& tVecSrc, isVector2& tVecDst);       //Копирование инвертированного вектора
eFxp float    Distance    (isVector2& tVec1, isVector2& tVec2);        //Расстояние между векторами
eFxp void    ToVec3D (isVector2& tVec2D, isVector& tVec3D);
};

/*===========================================================================
Конец файла
===========================================================================*/

#endif

/*===========================================================================
PROGRESS ENGINE    - Версия для игры "ВЕЧНОСТЬ"

math9_vector2.cpp    -    двумерный вектор

АВТОР:    Amon Ra
Copyright:    Infinitation Studio (c) 2001-2009
===========================================================================*/

#include    "math9_vector2.h"

//===========================================================================
//    Скалярное произведение векторов
//===========================================================================

eFxp void isVector2::CrossProduct(isVector2 &tVec1, isVector2 &tVec2, isVector2 &tVecR)
{
tVecR.x = tVec1.x * tVec2.y - tVec1.y * tVec2.x;
tVecR.y = tVec1.y * tVec2.x - tVec1.x * tVec2.y;
}

//===========================================================================
//    Длина вектора
//===========================================================================

eFxp float isVector2::Lenght(isVector2 &tVec) const
{
return sqrt( x * x + y * y );
}

//===========================================================================
//    Длина вектора в квадрате
//===========================================================================

eFxp float isVector2::LenghtSquared(isVector2 &tVec) const
{
return x * x + y * y;
}

//===========================================================================
//    Получаем значения вектора
//===========================================================================

eFxp void isVector2::Get(isVector2 &tVec)
{
x = tVec.x;
y = tVec.y;
}

//===========================================================================
//    Нормализация вектора
//===========================================================================

eFxp float isVector2::Normalize()
{
float OneOverDist, Dist;
Dist = sqrt( x * x + y * y );

if (Dist == 0.0)    return 0.0f;
OneOverDist = 1.0f/Dist;

x *= OneOverDist;
y *= OneOverDist;
return Dist;
}

//===========================================================================
//    Изменение размеров вектора
//===========================================================================

eFxp void isVector2::Scale(isVector2 &tVec1, isVector2 &tVecR, float Scale)
{
tVecR = tVec1 * Scale;
}

//===========================================================================
//    Второе изменение размеров вектора
//===========================================================================

eFxp void isVector2::UnScale(isVector2 &tVec1, isVector2 &tVec2, float Scale)
{
tVec2 = tVec1 / Scale;
}

//===========================================================================
//    Сложение векторов
//===========================================================================

eFxp void isVector2::Add(isVector2 &tVec1, isVector2 &tVec2, isVector2 &tVecR)
{
tVecR = tVec1 + tVec2;
}

//===========================================================================
//    Вычитание векторов
//===========================================================================

eFxp void isVector2::Subtract(isVector2 &tVec1, isVector2 &tVec2, isVector2 &tVecR)
{
tVecR = tVec1 - tVec2;
}

//===========================================================================
//    Сложение со скалируемым вектором
//===========================================================================

eFxp void isVector2::AddScaled(isVector2 &tVec1, isVector2 &tVec2, float Scale, isVector2 &tVecR)
{
tVecR = tVec1 + ( tVec2 * Scale );
}

//===========================================================================
//    Сложение со скалируемым векторов второе
//===========================================================================

eFxp void isVector2::AddUnScaled(isVector2 &tVec1, isVector2 &tVec2, float Scale, isVector2 &tVecR)
{
tVecR = tVec1 + ( tVec2 / Scale );
}

//===========================================================================
//    Вычитание скалируемого вектора
//===========================================================================

eFxp void isVector2::SubScaled(isVector2 &tVec1, isVector2 &tVec2, float Scale, isVector2 &tVecR)
{
tVecR = tVec1 - ( tVec2 * Scale );
}

//===========================================================================
//    Второе вычитание скалируемого вектора
//===========================================================================

eFxp void isVector2::SubUnScaled(isVector2 &tVec1, isVector2 &tVec2, float Scale, isVector2 &tVecR)
{
tVecR = tVec1 - ( tVec2 / Scale );
}

//===========================================================================
//    Копирование вектора
//===========================================================================

eFxp void isVector2::Copy(isVector2 &tVecSrc, isVector2 &tVecDst)
{
tVecDst = tVecSrc;
}

//===========================================================================
//    Инверсия вектора
//===========================================================================

eFxp void isVector2::Inverse(isVector2 &tVec)
{
tVec = -tVec;
}

//===========================================================================
//    Копирование обратного вектора
//===========================================================================

eFxp void isVector2::InverseCopy(isVector2 &tVecSrc, isVector2 &tVecDst)
{
tVecDst = -tVecSrc;
}

//===========================================================================
//    Расстояние между векторами
//===========================================================================

eFxp float isVector2::Distance(isVector2 &tVec1, isVector2 &tVec2)
{
isVector2 tVecR;
Subtract ( tVec1, tVec2, tVecR );
return    Lenght( tVecR );
}

#include    "math9_vector.h"

eFxp void isVector2::ToVec3D(isVector2 &tVec2D, isVector &tVec3D)
{
tVec3D.x = tVec2D.x;
tVec3D.y = tVec2D.y;
tVec3D.z = 0.0f;
}

//===========================================================================
//    Конец файла
//===========================================================================

/*===========================================================================
PROGRESS ENGINE    - Версия для игры "ВЕЧНОСТЬ"

basevars.h    -    базовые предобъявления и типы

АВТОР:    Amon Ra
Copyright:    Infinitation Studio (c) 2001-2009
===========================================================================*/

#ifndef BASEVARS
#define BASEVARS

//===========================================================================
//    Директивы
//===========================================================================

#define    eInl    inline
#define    eForce    __forceinline

#ifdef    E  TERNITY
#define    eExp    _declspec(dllexport)
#define    eIxp    _declspec(dllexport)    inline
#define    eFxp    _declspec(dllexport)    __forceinline
#else  
#define    eExp    _declspec(dllimport)
#define    eIxp    _declspec(dllimport)    inline
#define    eFxp    _declspec(dllimport)    __forceinline
#endif

ty  pedef    int    ibool;
typedef    enum {    ifalse,    itrue    };

//===========================================================================
//    Константы
//===========================================================================

const float    pi    =    3.14159265358979323846f;

//===========================================================================
//    Типы переменных
//===========================================================================

typedef signed long    int32;
typedef signed short   int16;
typedef signed char    int8 ;

typedef unsigned long  uint32;
typedef unsigned short  uint16;
typedef unsigned char  uint8 ;

//===========================================================================
//    Конец файла
//===========================================================================
#endif