421 lines
11 KiB
C++
421 lines
11 KiB
C++
/**
|
|
*******************************************************************************
|
|
* @file etk/math/Vector3D.h
|
|
* @brief Ewol Tool Kit : Vector 3 dimention (x, y, z)
|
|
* @author Edouard DUPIN
|
|
* @date 26/10/2012
|
|
* @par Project
|
|
* Ewol TK
|
|
*
|
|
* @par Copyright
|
|
* Copyright 2011 Edouard DUPIN, all right reserved
|
|
*
|
|
* This software is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY.
|
|
*
|
|
* Licence summary :
|
|
* You can modify and redistribute the sources code and binaries.
|
|
* You can send me the bug-fix
|
|
*
|
|
* Term of the licence in in the file licence.txt.
|
|
*
|
|
*******************************************************************************
|
|
*/
|
|
|
|
#ifndef __ETK_MATH_VECTOR3D_H__
|
|
#define __ETK_MATH_VECTOR3D_H__
|
|
|
|
namespace etk
|
|
{
|
|
template <typename T> class Vector3D
|
|
{
|
|
public:
|
|
T x;
|
|
T y;
|
|
T z;
|
|
public:
|
|
/*****************************************************
|
|
* Constructor
|
|
*****************************************************/
|
|
Vector3D(void) : x(0), y(0), z(0) { };
|
|
Vector3D(double _x, double _y, double _z) : x(_x), y(_y), z(_z) { };
|
|
Vector3D(float _x, float _y, float _z) : x(_x), y(_y), z(_z) { };
|
|
Vector3D(int32_t _x, int32_t _y, int32_t _z) : x(_x), y(_y), z(_z) { };
|
|
Vector3D(const Vector3D<double>& obj) : x((T)obj.x), y((T)obj.y), z((T)obj.z) { };
|
|
Vector3D(const Vector3D<float>& obj) : x((T)obj.x), y((T)obj.y), z((T)obj.z) { };
|
|
Vector3D(const Vector3D<int32_t>& obj) : x((T)obj.x), y((T)obj.y), z((T)obj.z) { };
|
|
~Vector3D(void) { };
|
|
/*****************************************************
|
|
* = assigment
|
|
*****************************************************/
|
|
const Vector3D<T>& operator= (const Vector3D<T>& obj ) {
|
|
x = (T)obj.x;
|
|
y = (T)obj.y;
|
|
z = (T)obj.z;
|
|
return *this;
|
|
}
|
|
/*****************************************************
|
|
* == operator
|
|
*****************************************************/
|
|
bool operator== (const Vector3D<T>& obj) const {
|
|
if ((T)obj.x == x && (T)obj.y == y && (T)obj.z == z) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
/*****************************************************
|
|
* != operator
|
|
*****************************************************/
|
|
bool operator!= (const Vector3D<T>& obj) const {
|
|
if ((T)obj.x == x && (T)obj.y == y && (T)obj.z == z) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
/*****************************************************
|
|
* += operator
|
|
*****************************************************/
|
|
const Vector3D<T>& operator+= (const Vector3D<T>& obj) {
|
|
x += (T)obj.x;
|
|
y += (T)obj.y;
|
|
z += (T)obj.z;
|
|
return *this;
|
|
}
|
|
const Vector3D<T>& operator+= (const float val) {
|
|
x += val;
|
|
y += val;
|
|
z += val;
|
|
return *this;
|
|
}
|
|
/*****************************************************
|
|
* + operator
|
|
*****************************************************/
|
|
Vector3D<T> operator+ (const Vector3D<T>& obj) {
|
|
Vector3D<T> tmpp(x,y,y);
|
|
tmpp.x += (T)obj.x;
|
|
tmpp.y += (T)obj.y;
|
|
tmpp.z += (T)obj.z;
|
|
return *this;
|
|
}
|
|
Vector3D<T> operator+ (const float val) {
|
|
Vector3D<T> tmpp(x,y,y);
|
|
tmpp.x += val;
|
|
tmpp.y += val;
|
|
tmpp.z += val;
|
|
return *this;
|
|
}
|
|
/*****************************************************
|
|
* -= operator
|
|
*****************************************************/
|
|
const Vector3D<T>& operator-= (const Vector3D<T>& obj) {
|
|
x -= (T)obj.x;
|
|
y -= (T)obj.y;
|
|
z -= (T)obj.z;
|
|
return *this;
|
|
}
|
|
const Vector3D<T>& operator-= (const float val) {
|
|
x -= val;
|
|
y -= val;
|
|
z -= val;
|
|
return *this;
|
|
}
|
|
/*****************************************************
|
|
* - operator
|
|
*****************************************************/
|
|
Vector3D<T> operator- (const Vector3D<T>& obj) {
|
|
Vector3D<T> tmpp(x,y,y);
|
|
tmpp.x -= (T)obj.x;
|
|
tmpp.y -= (T)obj.y;
|
|
tmpp.z -= (T)obj.z;
|
|
return *this;
|
|
}
|
|
Vector3D<T> operator- (const float val) {
|
|
Vector3D<T> tmpp(x,y,y);
|
|
tmpp.x -= val;
|
|
tmpp.y -= val;
|
|
tmpp.z -= val;
|
|
return *this;
|
|
}
|
|
/*****************************************************
|
|
* /= operator
|
|
*****************************************************/
|
|
const Vector3D<T>& operator/= (const Vector3D<T>& obj) {
|
|
if (obj.x != 0) {
|
|
x /= (T)obj.x;
|
|
}
|
|
if (obj.y != 0) {
|
|
y /= (T)obj.y;
|
|
}
|
|
if (obj.z != 0) {
|
|
z /= (T)obj.z;
|
|
}
|
|
return *this;
|
|
}
|
|
const Vector3D<T>& operator/= (const float val) {
|
|
if (val==0) {
|
|
return *this;
|
|
}
|
|
x /= val;
|
|
y /= val;
|
|
z /= val;
|
|
return *this;
|
|
}
|
|
/*****************************************************
|
|
* / operator
|
|
*****************************************************/
|
|
Vector3D<T> operator/ (const Vector3D<T>& obj) {
|
|
Vector3D<T> tmpp(x,y,y);
|
|
if (obj.x != 0) {
|
|
tmpp.x /= (T)obj.x;
|
|
}
|
|
if (obj.y != 0) {
|
|
tmpp.y /= (T)obj.y;
|
|
}
|
|
if (obj.z != 0) {
|
|
tmpp.z /= (T)obj.z;
|
|
}
|
|
return tmpp;
|
|
}
|
|
Vector3D<T> operator/ (const float val) {
|
|
Vector3D<T> tmpp(x,y,y);
|
|
if (val==0) {
|
|
return tmpp;
|
|
}
|
|
tmpp.x /= val;
|
|
tmpp.y /= val;
|
|
tmpp.z /= val;
|
|
return tmpp;
|
|
}
|
|
/*****************************************************
|
|
* *= operator
|
|
*****************************************************/
|
|
const Vector3D<T>& operator*= (const Vector3D<T>& obj) {
|
|
x *= (T)obj.x;
|
|
y *= (T)obj.y;
|
|
z *= (T)obj.z;
|
|
return *this;
|
|
}
|
|
const Vector3D<T>& operator*= (const float val) {
|
|
x *= val;
|
|
y *= val;
|
|
z *= val;
|
|
return *this;
|
|
}
|
|
/*****************************************************
|
|
* * operator
|
|
*****************************************************/
|
|
Vector3D<T> operator* (const Vector3D<T>& obj) {
|
|
Vector3D<T> tmpp(x,y,y);
|
|
tmpp.x *= (T)obj.x;
|
|
tmpp.y *= (T)obj.y;
|
|
tmpp.z *= (T)obj.z;
|
|
return tmpp;
|
|
}
|
|
Vector3D<T> operator* (const float val) {
|
|
Vector3D<T> tmpp(x,y,y);
|
|
tmpp.x *= val;
|
|
tmpp.y *= val;
|
|
tmpp.z *= val;
|
|
return tmpp;
|
|
}
|
|
/*****************************************************
|
|
* ++ operator
|
|
*****************************************************/
|
|
Vector3D<T>& operator++() // prefix
|
|
{
|
|
++x;
|
|
++y;
|
|
++z;
|
|
return *this;
|
|
}
|
|
Vector3D<T> operator++(int unused) // postfix
|
|
{
|
|
Vector3D<T> result = *this;
|
|
++(*this);
|
|
return result;
|
|
}
|
|
/*****************************************************
|
|
* -- operator
|
|
*****************************************************/
|
|
Vector3D<T>& operator--() // prefix
|
|
{
|
|
--x;
|
|
--y;
|
|
--z;
|
|
return *this;
|
|
}
|
|
Vector3D<T> operator--(int unused) // postfix
|
|
{
|
|
Vector3D<T> result = *this;
|
|
--(*this);
|
|
return result;
|
|
}
|
|
|
|
void Zero(void)
|
|
{
|
|
x=0;
|
|
y=0;
|
|
z=0;
|
|
};
|
|
void One(void)
|
|
{
|
|
x=1;
|
|
y=1;
|
|
z=1;
|
|
};
|
|
|
|
//vector algebra
|
|
Vector3D<T> CrossProduct(const Vector3D<T>& obj) const
|
|
{
|
|
return Vector3D<T>( y*obj.z - z*obj.y,
|
|
z*obj.x - x*obj.z,
|
|
x*obj.y - y*obj.x);
|
|
};
|
|
|
|
float DotProduct(const Vector3D<T>& obj) const
|
|
{
|
|
return x*obj.x
|
|
+ y*obj.y
|
|
+ z*obj.z;
|
|
};
|
|
|
|
void Normalize()
|
|
{
|
|
float length=GetLength();
|
|
if(length==1 || length==0) {
|
|
return;
|
|
}
|
|
float scalefactor = 1.0f/length;
|
|
x *= scalefactor;
|
|
y *= scalefactor;
|
|
z *= scalefactor;
|
|
};
|
|
|
|
Vector3D<T> GetNormalized() const
|
|
{
|
|
Vector3D<T> tmpp(*this);
|
|
tmpp.Normalize();
|
|
return tmpp;
|
|
};
|
|
|
|
float GetLength() const
|
|
{
|
|
return (float)sqrt((x*x)+(y*y)+(z*z));
|
|
};
|
|
|
|
float GetSquaredLength() const
|
|
{
|
|
return (x*x)+(y*y)+(z*z);
|
|
};
|
|
|
|
//rotations
|
|
void RotateX(double angle)
|
|
{
|
|
(*this)=GetRotatedX(angle);
|
|
};
|
|
|
|
Vector3D<T> GetRotatedX(double angle) const
|
|
{
|
|
if(angle==0.0) {
|
|
return (*this);
|
|
}
|
|
float sinAngle=(float)sin(M_PI*angle/180);
|
|
float cosAngle=(float)cos(M_PI*angle/180);
|
|
|
|
return Vector3D<T>( x,
|
|
y*cosAngle - z*sinAngle,
|
|
y*sinAngle + z*cosAngle);
|
|
};
|
|
|
|
void RotateY(double angle)
|
|
{
|
|
(*this)=GetRotatedY(angle);
|
|
};
|
|
|
|
Vector3D<T> GetRotatedY(double angle) const
|
|
{
|
|
if(angle==0.0) {
|
|
return (*this);
|
|
}
|
|
float sinAngle=(float)sin(M_PI*angle/180);
|
|
float cosAngle=(float)cos(M_PI*angle/180);
|
|
return Vector3D<T>( x*cosAngle + z*sinAngle,
|
|
y,
|
|
-x*sinAngle + z*cosAngle);
|
|
};
|
|
|
|
void RotateZ(double angle)
|
|
{
|
|
(*this)=GetRotatedZ(angle);
|
|
};
|
|
|
|
Vector3D<T> GetRotatedZ(double angle) const
|
|
{
|
|
if(angle==0.0) {
|
|
return (*this);
|
|
}
|
|
float sinAngle=(float)sin(M_PI*angle/180);
|
|
float cosAngle=(float)cos(M_PI*angle/180);
|
|
return Vector3D<T>( x*cosAngle - y*sinAngle,
|
|
x*sinAngle + y*cosAngle,
|
|
z);
|
|
};
|
|
|
|
void RotateAxis(double angle, const Vector3D<T> & axis)
|
|
{
|
|
(*this)=GetRotatedAxis(angle, axis);
|
|
};
|
|
|
|
Vector3D<T> GetRotatedAxis(double angle, const Vector3D<T> & axis) const
|
|
{
|
|
if(angle==0.0) {
|
|
return (*this);
|
|
}
|
|
Vector3D<T> u=axis.GetNormalized();
|
|
Vector3D<T> rotMatrixRow0, rotMatrixRow1, rotMatrixRow2;
|
|
float sinAngle=(float)sin(M_PI*angle/180);
|
|
float cosAngle=(float)cos(M_PI*angle/180);
|
|
float MinusCosAngle=1.0f-cosAngle;
|
|
rotMatrixRow0.x=(u.x)*(u.x) + cosAngle*(1-(u.x)*(u.x));
|
|
rotMatrixRow0.y=(u.x)*(u.y)*(MinusCosAngle) - sinAngle*u.z;
|
|
rotMatrixRow0.z=(u.x)*(u.z)*(MinusCosAngle) + sinAngle*u.y;
|
|
rotMatrixRow1.x=(u.x)*(u.y)*(MinusCosAngle) + sinAngle*u.z;
|
|
rotMatrixRow1.y=(u.y)*(u.y) + cosAngle*(1-(u.y)*(u.y));
|
|
rotMatrixRow1.z=(u.y)*(u.z)*(MinusCosAngle) - sinAngle*u.x;
|
|
rotMatrixRow2.x=(u.x)*(u.z)*(MinusCosAngle) - sinAngle*u.y;
|
|
rotMatrixRow2.y=(u.y)*(u.z)*(MinusCosAngle) + sinAngle*u.x;
|
|
rotMatrixRow2.z=(u.z)*(u.z) + cosAngle*(1-(u.z)*(u.z));
|
|
return Vector3D<T>( this->DotProduct(rotMatrixRow0),
|
|
this->DotProduct(rotMatrixRow1),
|
|
this->DotProduct(rotMatrixRow2));
|
|
};
|
|
|
|
/**
|
|
* @brief Linar intermolation of the curent Vector
|
|
* @param[in] input
|
|
* @param[in] factor
|
|
* @return the interpolate vector
|
|
*/
|
|
Vector3D<T> LinearInterpolate(const Vector3D<T>& input, float factor) const
|
|
{
|
|
return (*this)*(1.0f-factor) + input*factor;
|
|
};
|
|
|
|
/**
|
|
* @brief Quadratic intermolation of the curent Vector
|
|
* @param[in] v1
|
|
* @param[in] v2
|
|
* @param[in] factor
|
|
* @return the interpolate vector
|
|
*/
|
|
Vector3D<T> QuadraticInterpolate(const Vector3D<T>& v2, const Vector3D<T>& v3, float factor) const
|
|
{
|
|
return (*this)*(1.0f-factor)*(1.0f-factor) + 2*v2*factor*(1.0f-factor) + v3*factor*factor;
|
|
};
|
|
};
|
|
};
|
|
|
|
|
|
|
|
#endif
|