216 lines
16 KiB
C++
216 lines
16 KiB
C++
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Created : 2007-02-21
|
|
// Updated : 2007-02-21
|
|
// Licence : This source is under MIT License
|
|
// File : glm/gtx/vecx.hpp
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Dependency:
|
|
// - GLM core
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef glm_gtx_vecx
|
|
#define glm_gtx_vecx
|
|
|
|
namespace glm{
|
|
namespace detail{
|
|
|
|
template <int N>
|
|
class _bvecxGTX
|
|
{
|
|
private:
|
|
bool data[N];
|
|
|
|
public:
|
|
typedef bool value_type;
|
|
typedef int size_type;
|
|
static const size_type value_size;
|
|
static const size_type col_size;
|
|
static const size_type row_size;
|
|
|
|
// Common constructors
|
|
_bvecxGTX();
|
|
_bvecxGTX(const _bvecxGTX& v);
|
|
|
|
// Accesses
|
|
bool& operator[](int i);
|
|
bool operator[](int i) const;
|
|
operator bool*();
|
|
operator const bool*() const;
|
|
|
|
// Bool constructors
|
|
explicit _bvecxGTX(const bool a);
|
|
|
|
// Operators
|
|
_bvecxGTX<N>& operator=(const _bvecxGTX<N>& v);
|
|
_bvecxGTX<N> operator! () const;
|
|
};
|
|
|
|
template <int N, typename T = float>
|
|
class _xvecxGTX
|
|
{
|
|
private:
|
|
T data[N];
|
|
|
|
public:
|
|
typedef T value_type;
|
|
typedef int size_type;
|
|
static const size_type value_size;
|
|
|
|
// Common constructors
|
|
_xvecxGTX();
|
|
_xvecxGTX(const _xvecxGTX<N, T>& v);
|
|
|
|
// Accesses
|
|
T& operator[](int i);
|
|
T operator[](int i) const;
|
|
operator T*();
|
|
operator const T*() const;
|
|
|
|
// T constructors
|
|
explicit _xvecxGTX(const T x);
|
|
|
|
// Unary updatable operators
|
|
_xvecxGTX<N, T>& operator= (const _xvecxGTX<N, T>& v);
|
|
_xvecxGTX<N, T>& operator+=(const T s);
|
|
_xvecxGTX<N, T>& operator+=(const _xvecxGTX<N, T>& v);
|
|
_xvecxGTX<N, T>& operator-=(const T s);
|
|
_xvecxGTX<N, T>& operator-=(const _xvecxGTX<N, T>& v);
|
|
_xvecxGTX<N, T>& operator*=(const T s);
|
|
_xvecxGTX<N, T>& operator*=(const _xvecxGTX<N, T>& v);
|
|
_xvecxGTX<N, T>& operator/=(const T s);
|
|
_xvecxGTX<N, T>& operator/=(const _xvecxGTX<N, T>& v);
|
|
_xvecxGTX<N, T>& operator++();
|
|
_xvecxGTX<N, T>& operator--();
|
|
};
|
|
|
|
// Binary operators
|
|
template <int N, typename T>
|
|
detail::_xvecxGTX<N, T> operator+ (const detail::_xvecxGTX<N, T>& v, const T s);
|
|
|
|
template <int N, typename T>
|
|
detail::_xvecxGTX<N, T> operator+ (const T s, const detail::_xvecxGTX<N, T>& v);
|
|
|
|
template <int N, typename T>
|
|
detail::_xvecxGTX<N, T> operator+ (const detail::_xvecxGTX<N, T>& v1, const detail::_xvecxGTX<N, T>& v2);
|
|
|
|
template <int N, typename T>
|
|
detail::_xvecxGTX<N, T> operator- (const detail::_xvecxGTX<N, T>& v, const T s);
|
|
|
|
template <int N, typename T>
|
|
detail::_xvecxGTX<N, T> operator- (const T s, const detail::_xvecxGTX<N, T>& v);
|
|
|
|
template <int N, typename T>
|
|
detail::_xvecxGTX<N, T> operator- (const detail::_xvecxGTX<N, T>& v1, const detail::_xvecxGTX<N, T>& v2);
|
|
|
|
template <int N, typename T>
|
|
detail::_xvecxGTX<N, T> operator* (const detail::_xvecxGTX<N, T>& v, const T s);
|
|
|
|
template <int N, typename T>
|
|
detail::_xvecxGTX<N, T> operator* (const T s, const detail::_xvecxGTX<N, T>& v);
|
|
|
|
template <int N, typename T>
|
|
detail::_xvecxGTX<N, T> operator* (const detail::_xvecxGTX<N, T>& v1, const detail::_xvecxGTX<N, T>& v2);
|
|
|
|
template <int N, typename T>
|
|
detail::_xvecxGTX<N, T> operator/ (const detail::_xvecxGTX<N, T>& v, const T s);
|
|
|
|
template <int N, typename T>
|
|
detail::_xvecxGTX<N, T> operator/ (const T s, const detail::_xvecxGTX<N, T>& v);
|
|
|
|
template <int N, typename T>
|
|
detail::_xvecxGTX<N, T> operator/ (const detail::_xvecxGTX<N, T>& v1, const detail::_xvecxGTX<N, T>& v2);
|
|
|
|
// Unary constant operators
|
|
template <int N, typename T>
|
|
const detail::_xvecxGTX<N, T> operator- (const detail::_xvecxGTX<N, T>& v);
|
|
|
|
template <int N, typename T>
|
|
const detail::_xvecxGTX<N, T> operator-- (const detail::_xvecxGTX<N, T>& v, int);
|
|
|
|
template <int N, typename T>
|
|
const detail::_xvecxGTX<N, T> operator++ (const detail::_xvecxGTX<N, T>& v, int);
|
|
|
|
}//namespace detail
|
|
|
|
namespace gtx
|
|
{
|
|
//! GLM_GTX_vecx extension: - Work in progress - Add custom size vectors
|
|
namespace vecx
|
|
{
|
|
template<typename T, int N>
|
|
struct vec
|
|
{
|
|
typedef detail::_xvecxGTX<N, T> type;
|
|
};
|
|
|
|
// Trigonometric Functions
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> radiansGTX(const detail::_xvecxGTX<N, T>& degrees); //< \brief Converts degrees to radians and returns the result. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> degreesGTX(const detail::_xvecxGTX<N, T>& radians); //< \brief Converts radians to degrees and returns the result. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> sinGTX(const detail::_xvecxGTX<N, T>& angle); //< \brief The standard trigonometric sine function. The values returned by this function will range from [-1, 1]. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> cosGTX(const detail::_xvecxGTX<N, T>& angle); //< \brief The standard trigonometric cosine function. The values returned by this function will range from [-1, 1]. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> tanGTX(const detail::_xvecxGTX<N, T>& angle); //< \brief The standard trigonometric tangent function. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> asinGTX(const detail::_xvecxGTX<N, T>& x); //< \brief Arc sine. Returns an angle whose sine is x. The range of values returned by this function is [-PI/2, PI/2]. Results are undefined if |x| > 1. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> acosGTX(const detail::_xvecxGTX<N, T>& x); //< \brief Arc cosine. Returns an angle whose sine is x. The range of values returned by this function is [0, PI]. Results are undefined if |x| > 1. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> atanGTX(const detail::_xvecxGTX<N, T>& y, const detail::_xvecxGTX<N, T>& x); //< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> atanGTX(const detail::_xvecxGTX<N, T>& y_over_x); //< \brief Arc tangent. Returns an angle whose tangent is y_over_x. The range of values returned by this function is [-PI/2, PI/2]. (From GLM_GTX_vecx extension)
|
|
|
|
// Exponential Functions
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> powGTX(const detail::_xvecxGTX<N, T>& x, const detail::_xvecxGTX<N, T>& y); //< \brief Returns x raised to the y power. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> expGTX(const detail::_xvecxGTX<N, T>& x); //< \brief Returns the natural exponentiation of x, i.e., e^x. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> logGTX(const detail::_xvecxGTX<N, T>& x); //< \brief Returns the natural logarithm of x, i.e., returns the value y which satisfies the equation x = e^y. Results are undefined if x <= 0. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> exp2GTX(const detail::_xvecxGTX<N, T>& x); //< \brief Returns 2 raised to the x power. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> log2GTX(const detail::_xvecxGTX<N, T>& x); //< \brief Returns the base 2 log of x, i.e., returns the value y, which satisfies the equation x = 2 ^ y. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> sqrtGTX(const detail::_xvecxGTX<N, T>& x); //< \brief Returns the positive square root of x. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> inversesqrtGTX(const detail::_xvecxGTX<N, T>& x); //< \brief Returns the reciprocal of the positive square root of x. (From GLM_GTX_vecx extension)
|
|
|
|
// Common Functions
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> absGTX(const detail::_xvecxGTX<N, T>& x); //< \brief Returns x if x >= 0; otherwise, it returns -x. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> floorGTX(const detail::_xvecxGTX<N, T>& x); //< \brief Returns a value equal to the nearest integer that is less then or equal to x. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> ceilGTX(const detail::_xvecxGTX<N, T>& x); //< \brief Returns a value equal to the nearest integer that is greater than or equal to x. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> fractGTX(const detail::_xvecxGTX<N, T>& x); //< \brief Return x - floor(x). (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> modGTX(const detail::_xvecxGTX<N, T>& x, T y); //< \brief Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> modGTX(const detail::_xvecxGTX<N, T>& x, const detail::_xvecxGTX<N, T>& y); //< \brief Modulus. Returns x - y * floor(x / y) for each component in x using the corresponding component of y. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> minGTX(const detail::_xvecxGTX<N, T>& x, T y); //< \brief Returns y if y < x; otherwise, it returns x. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> minGTX(const detail::_xvecxGTX<N, T>& x, const detail::_xvecxGTX<N, T>& y); //< \brief Returns minimum of each component of x compared with the floating-point value y. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> maxGTX(const detail::_xvecxGTX<N, T>& x, T y); //< \brief Returns y if x < y; otherwise, it returns x. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> maxGTX(const detail::_xvecxGTX<N, T>& x, const detail::_xvecxGTX<N, T>& y); //< \brief Returns maximum of each component of x compared with the floating-point value y. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> clampGTX(const detail::_xvecxGTX<N, T>& x, T minVal, T maxVal); //< \brief Returns min(max(x, minVal), maxVal) for each component in x using the floating-point values minVal and maxVal. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> clampGTX(const detail::_xvecxGTX<N, T>& x, const detail::_xvecxGTX<N, T>& minVal, const detail::_xvecxGTX<N, T>& maxVal); //< \brief Returns the component-wise result of min(max(x, minVal), maxVal). (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> stepGTX(T edge, const detail::_xvecxGTX<N, T>& x); //< \brief Returns 0.0 if x <= edge; otherwise, it returns 1.0. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> stepGTX(const detail::_xvecxGTX<N, T>& edge, const detail::_xvecxGTX<N, T>& x); //< \brief Returns 0.0 if x <= edge; otherwise, it returns 1.0. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> smoothstepGTX(T edge0, T edge1, const detail::_xvecxGTX<N, T>& x); //< \brief Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and performs smooth Hermite interpolation between 0 and 1 when edge0 < x, edge1. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> smoothstepGTX(const detail::_xvecxGTX<N, T>& edge0, const detail::_xvecxGTX<N, T>& edge1, const detail::_xvecxGTX<N, T>& x);//< \brief Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and performs smooth Hermite interpolation between 0 and 1 when edge0 < x, edge1. (From GLM_GTX_vecx extension)
|
|
|
|
// Geometric Functions
|
|
template <int N, typename T> T lengthGTX(const detail::_xvecxGTX<N, T>& x); //< \brief Returns the length of x, i.e., sqrt(x * x). (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> T distanceGTX(const detail::_xvecxGTX<N, T>& p0, const detail::_xvecxGTX<N, T>& p1); //< \brief Returns the distance betwwen p0 and p1, i.e., length(p0 - p1). (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> T dotGTX(const detail::_xvecxGTX<N, T>& x, const detail::_xvecxGTX<N, T>& y); //< \brief Returns the dot product of x and y, i.e., result = x[0] * y[0] + x[1] * y[1]. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> normalizeGTX(const detail::_xvecxGTX<N, T>& x); //< \brief Returns a vector in the same direction as x but with length of 1. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> faceforwardGTX(const detail::_xvecxGTX<N, T>& Norm, const detail::_xvecxGTX<N, T>& I, const detail::_xvecxGTX<N, T>& Nref); //< \brief If dot(Nref, I) < 0.0, return N, otherwise, return -N. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> reflectGTX(const detail::_xvecxGTX<N, T>& I, const detail::_xvecxGTX<N, T>& N); //< \brief For the incident vector I and surface orientation N, returns the reflection direction : result = I - 2.0 * dot(N, I) * N. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_xvecxGTX<N, T> refractGTX(const detail::_xvecxGTX<N, T>& I, const detail::_xvecxGTX<N, T>& N, T eta); //< \brief For the incident vector I and surface normal N, and the ratio of indices of refraction eta, return the refraction vector. (From GLM_GTX_vecx extension)
|
|
|
|
// Vector Relational Functions
|
|
template <int N, typename T> detail::_bvecxGTX<N> lessThanGTX(const detail::_xvecxGTX<N, T>& x, const detail::_xvecxGTX<N, T>& y); //< \brief Returns the component-wise compare of x < y. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_bvecxGTX<N> lessThanEqualGTX(const detail::_xvecxGTX<N, T>& x, const detail::_xvecxGTX<N, T>& y); //< \brief Returns the component-wise compare of x <= y. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_bvecxGTX<N> greaterThanGTX(const detail::_xvecxGTX<N, T>& x, const detail::_xvecxGTX<N, T>& y); //< \brief Returns the component-wise compare of x > y. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_bvecxGTX<N> greaterThanEqualGTX(const detail::_xvecxGTX<N, T>& x, const detail::_xvecxGTX<N, T>& y); //< \brief Returns the component-wise compare of x >= y. (From GLM_GTX_vecx extension)
|
|
template <int N> detail::_bvecxGTX<N> equalGTX(const detail::_bvecxGTX<N>& x, const detail::_bvecxGTX<N>& y); //< \brief Returns the component-wise compare of x == y. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_bvecxGTX<N> equalGTX(const detail::_xvecxGTX<N, T>& x, const detail::_xvecxGTX<N, T>& y); //< \brief Returns the component-wise compare of x == y. (From GLM_GTX_vecx extension)
|
|
template <int N> detail::_bvecxGTX<N> notEqualGTX(const detail::_bvecxGTX<N>& x, const detail::_bvecxGTX<N>& y); //< \brief Returns the component-wise compare of x != y. (From GLM_GTX_vecx extension)
|
|
template <int N, typename T> detail::_bvecxGTX<N> notEqualGTX(const detail::_xvecxGTX<N, T>& x, const detail::_xvecxGTX<N, T>& y); //< \brief Returns the component-wise compare of x != y. (From GLM_GTX_vecx extension)
|
|
template <int N> bool anyGTX(const detail::_bvecxGTX<N>& x); //< \brief Returns true if any component of x is true. (From GLM_GTX_vecx extension)
|
|
template <int N> bool allGTX(const detail::_bvecxGTX<N>& x); //< \brief Returns true if all component of x is true. (From GLM_GTX_vecx extension)
|
|
template <int N> detail::_bvecxGTX<N> notGTX(const detail::_bvecxGTX<N>& v); //< \brief Returns the component-wise logical complement of x. (From GLM_GTX_vecx extension)
|
|
}
|
|
}
|
|
}
|
|
|
|
#include "vecx.inl"
|
|
|
|
namespace glm{using namespace gtx::vecx;}
|
|
|
|
#endif//glm_gtx_vecx
|