406 lines
8.9 KiB
C++
406 lines
8.9 KiB
C++
#ifndef _VECTOR3_H
|
|
#define _VECTOR3_H
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
Generic vector3 class. Uses 16 Byte of mem instead of 12 (!)
|
|
|
|
@author
|
|
- RadonLabs GmbH
|
|
|
|
@since
|
|
- 2005.7.06
|
|
@remarks
|
|
- Áö¿Ï Ãß°¡
|
|
*/
|
|
|
|
#include "nmath.h"
|
|
#include <float.h>
|
|
|
|
//------------------------------------------------------------------------------
|
|
class _vector3
|
|
{
|
|
public:
|
|
/// constructor 1
|
|
_vector3();
|
|
/// constructor 2
|
|
_vector3(const float _x, const float _y, const float _z);
|
|
/// constructor 3
|
|
_vector3(const _vector3& vec);
|
|
/// set elements 1
|
|
void set(const float _x, const float _y, const float _z);
|
|
/// set elements 2
|
|
void set(const _vector3& vec);
|
|
/// return length
|
|
float len() const;
|
|
/// return length squared
|
|
float lensquared() const;
|
|
/// normalize
|
|
void norm();
|
|
/// inplace add
|
|
void operator +=(const _vector3& v0);
|
|
/// inplace sub
|
|
void operator -=(const _vector3& v0);
|
|
/// inplace scalar multiplication
|
|
void operator *=(float s);
|
|
/// fuzzy compare, return true/false
|
|
bool isequal(const _vector3& v, float tol) const;
|
|
/// fuzzy compare, returns -1, 0, +1
|
|
int compare(const _vector3& v, float tol) const;
|
|
/// rotate around axis
|
|
void rotate(const _vector3& axis, float angle);
|
|
/// inplace linear interpolation
|
|
void lerp(const _vector3& v0, float lerpVal);
|
|
/// linear interpolation between v0 and v1
|
|
void lerp(const _vector3& v0, const _vector3& v1, float lerpVal);
|
|
/// returns a vector orthogonal to self, not normalized
|
|
_vector3 findortho() const;
|
|
/// saturate components between 0 and 1
|
|
void saturate();
|
|
/// dot product
|
|
float dot(_vector3 v0) const;
|
|
|
|
float x, y, z;
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
_vector3::_vector3() :
|
|
x(0.0f),
|
|
y(0.0f),
|
|
z(0.0f)
|
|
{
|
|
// empty
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
_vector3::_vector3(const float _x, const float _y, const float _z) :
|
|
x(_x),
|
|
y(_y),
|
|
z(_z)
|
|
{
|
|
// empty
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
_vector3::_vector3(const _vector3& vec) :
|
|
x(vec.x),
|
|
y(vec.y),
|
|
z(vec.z)
|
|
{
|
|
// empty
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
void
|
|
_vector3::set(const float _x, const float _y, const float _z)
|
|
{
|
|
x = _x;
|
|
y = _y;
|
|
z = _z;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
void
|
|
_vector3::set(const _vector3& vec)
|
|
{
|
|
x = vec.x;
|
|
y = vec.y;
|
|
z = vec.z;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
float
|
|
_vector3::len() const
|
|
{
|
|
return (float) sqrt(x * x + y * y + z * z);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
float
|
|
_vector3::lensquared() const
|
|
{
|
|
return x * x + y * y + z * z;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
void
|
|
_vector3::norm()
|
|
{
|
|
float l = len();
|
|
if (l > TINY)
|
|
{
|
|
x /= l;
|
|
y /= l;
|
|
z /= l;
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
void
|
|
_vector3::operator +=(const _vector3& v0)
|
|
{
|
|
x += v0.x;
|
|
y += v0.y;
|
|
z += v0.z;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
void
|
|
_vector3::operator -=(const _vector3& v0)
|
|
{
|
|
x -= v0.x;
|
|
y -= v0.y;
|
|
z -= v0.z;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
void
|
|
_vector3::operator *=(float s)
|
|
{
|
|
x *= s;
|
|
y *= s;
|
|
z *= s;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
bool
|
|
_vector3::isequal(const _vector3& v, float tol) const
|
|
{
|
|
if (fabs(v.x - x) > tol) return false;
|
|
else if (fabs(v.y - y) > tol) return false;
|
|
else if (fabs(v.z - z) > tol) return false;
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
int
|
|
_vector3::compare(const _vector3& v, float tol) const
|
|
{
|
|
if (fabs(v.x - x) > tol) return (v.x > x) ? +1 : -1;
|
|
else if (fabs(v.y - y) > tol) return (v.y > y) ? +1 : -1;
|
|
else if (fabs(v.z - z) > tol) return (v.z > z) ? +1 : -1;
|
|
else return 0;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
void
|
|
_vector3::rotate(const _vector3& axis, float angle)
|
|
{
|
|
// rotates this one around given vector. We do
|
|
// rotation with matrices, but these aren't defined yet!
|
|
float rotM[9];
|
|
float sa, ca;
|
|
|
|
sa = (float) sin(angle);
|
|
ca = (float) cos(angle);
|
|
|
|
// build a rotation matrix
|
|
rotM[0] = ca + (1 - ca) * axis.x * axis.x;
|
|
rotM[1] = (1 - ca) * axis.x * axis.y - sa * axis.z;
|
|
rotM[2] = (1 - ca) * axis.z * axis.x + sa * axis.y;
|
|
rotM[3] = (1 - ca) * axis.x * axis.y + sa * axis.z;
|
|
rotM[4] = ca + (1 - ca) * axis.y * axis.y;
|
|
rotM[5] = (1 - ca) * axis.y * axis.z - sa * axis.x;
|
|
rotM[6] = (1 - ca) * axis.z * axis.x - sa * axis.y;
|
|
rotM[7] = (1 - ca) * axis.y * axis.z + sa * axis.x;
|
|
rotM[8] = ca + (1 - ca) * axis.z * axis.z;
|
|
|
|
// "handmade" multiplication
|
|
_vector3 help(rotM[0] * this->x + rotM[1] * this->y + rotM[2] * this->z,
|
|
rotM[3] * this->x + rotM[4] * this->y + rotM[5] * this->z,
|
|
rotM[6] * this->x + rotM[7] * this->y + rotM[8] * this->z);
|
|
*this = help;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
static
|
|
inline
|
|
_vector3 operator +(const _vector3& v0, const _vector3& v1)
|
|
{
|
|
return _vector3(v0.x + v1.x, v0.y + v1.y, v0.z + v1.z);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
static
|
|
inline
|
|
_vector3 operator -(const _vector3& v0, const _vector3& v1)
|
|
{
|
|
return _vector3(v0.x - v1.x, v0.y - v1.y, v0.z - v1.z);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
static
|
|
inline
|
|
_vector3 operator *(const _vector3& v0, const float s)
|
|
{
|
|
return _vector3(v0.x * s, v0.y * s, v0.z * s);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
static
|
|
inline
|
|
_vector3 operator -(const _vector3& v)
|
|
{
|
|
return _vector3(-v.x, -v.y, -v.z);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
static
|
|
inline
|
|
_vector3 operator /(const _vector3& v0, const float s)
|
|
{
|
|
float one_over_s = 1.0f/s;
|
|
return _vector3(v0.x*one_over_s, v0.y*one_over_s, v0.z*one_over_s);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
Dot product.
|
|
*/
|
|
static
|
|
inline
|
|
float operator %(const _vector3& v0, const _vector3& v1)
|
|
{
|
|
return v0.x * v1.x + v0.y * v1.y + v0.z * v1.z;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
Cross product.
|
|
*/
|
|
static
|
|
inline
|
|
_vector3 operator *(const _vector3& v0, const _vector3& v1)
|
|
{
|
|
return _vector3(v0.y * v1.z - v0.z * v1.y,
|
|
v0.z * v1.x - v0.x * v1.z,
|
|
v0.x * v1.y - v0.y * v1.x);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
void
|
|
_vector3::lerp(const _vector3& v0, float lerpVal)
|
|
{
|
|
x = v0.x + ((x - v0.x) * lerpVal);
|
|
y = v0.y + ((y - v0.y) * lerpVal);
|
|
z = v0.z + ((z - v0.z) * lerpVal);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
void
|
|
_vector3::lerp(const _vector3& v0, const _vector3& v1, float lerpVal)
|
|
{
|
|
x = v0.x + ((v1.x - v0.x) * lerpVal);
|
|
y = v0.y + ((v1.y - v0.y) * lerpVal);
|
|
z = v0.z + ((v1.z - v0.z) * lerpVal);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
void
|
|
_vector3::saturate()
|
|
{
|
|
x = n_saturate(x);
|
|
y = n_saturate(y);
|
|
z = n_saturate(z);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
Find a vector that is orthogonal to self. Self should not be (0,0,0).
|
|
Return value is not normalized.
|
|
*/
|
|
inline
|
|
_vector3
|
|
_vector3::findortho() const
|
|
{
|
|
if (0.0 != x)
|
|
{
|
|
return _vector3((-y - z) / x, 1.0, 1.0);
|
|
} else
|
|
if (0.0 != y)
|
|
{
|
|
return _vector3(1.0, (-x - z) / y, 1.0);
|
|
} else
|
|
if (0.0 != z)
|
|
{
|
|
return _vector3(1.0, 1.0, (-x - y) / z);
|
|
} else
|
|
{
|
|
return _vector3(0.0, 0.0, 0.0);
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
Dot product for vector3
|
|
*/
|
|
inline
|
|
float
|
|
_vector3::dot(_vector3 v0) const
|
|
{
|
|
return ( x * v0.x + y * v0.y + z * v0.z );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
#endif
|