- Main Page
- Namespaces
- Files

- File List

# vecx.hpp

    00001
    00002 // OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
    00004 // Created : 2007-02-21
    00005 // Updated : 2007-02-21
    00006 // Licence : This source is under MIT License
    00007 // File    : glm/gtx/vecx.h
    00009 // Dependency:
    00010 // - GLM core
    00012
    00013 #ifndef glm_gtx_vecx
    00014 #define glm_gtx_vecx
    00015
    00016 namespace glm{
    00017 namespace detail{
    00018
    00019         template <int N>
    00020     class _bvecxGTX
    00021     {
    00022         private:
    00023                 bool data[N];
    00024
    00025         public:
    00026                 typedef bool value_type;
    00027                 typedef int size_type;
    00028                 static const size_type value_size;
    00029                 static const size_type col_size;
    00030                 static const size_type row_size;
    00031
    00032         // Common constructors
    00033             _bvecxGTX();
    00034         _bvecxGTX(const _bvecxGTX& v);
    00035
    00036                 // Accesses
    00037         bool& operator[](int i);
    00038         bool operator[](int i) const;
    00039         operator bool*();
    00040             operator const bool*() const;
    00041
    00042         // Bool constructors
    00043         explicit _bvecxGTX(const bool a);
    00044
    00045         // Operators
    00046         _bvecxGTX<N>& operator=(const _bvecxGTX<N>& v);
    00047             _bvecxGTX<N> operator! () const;
    00048     };
    00049
    00050     template <int N, typename T = float>
    00051     class _xvecxGTX
    00052     {
    00053         private:
    00054                 T data[N];
    00055
    00056         public:
    00057                 typedef T value_type;
    00058                 typedef int size_type;
    00059                 static const size_type value_size;
    00060
    00061         // Common constructors
    00062             _xvecxGTX();
    00063         _xvecxGTX(const _xvecxGTX<N, T>& v);
    00064
    00065                 // Accesses
    00066         T& operator[](int i);
    00067         T operator[](int i) const;
    00068         operator T*();
    00069             operator const T*() const;
    00070
    00071         // T constructors
    00072         explicit _xvecxGTX(const T x);
    00073
    00074         // Unary updatable operators
    00075         _xvecxGTX<N, T>& operator= (const _xvecxGTX<N, T>& v);
    00076             _xvecxGTX<N, T>& operator+=(const T s);
    00077             _xvecxGTX<N, T>& operator+=(const _xvecxGTX<N, T>& v);
    00078             _xvecxGTX<N, T>& operator-=(const T s);
    00079             _xvecxGTX<N, T>& operator-=(const _xvecxGTX<N, T>& v);
    00080             _xvecxGTX<N, T>& operator*=(const T s);
    00081             _xvecxGTX<N, T>& operator*=(const _xvecxGTX<N, T>& v);
    00082             _xvecxGTX<N, T>& operator/=(const T s);
    00083             _xvecxGTX<N, T>& operator/=(const _xvecxGTX<N, T>& v);
    00084             _xvecxGTX<N, T>& operator++();
    00085         _xvecxGTX<N, T>& operator--();
    00086     };
    00087
    00088     // Binary operators
    00089     template <int N, typename T>
    00090         detail::_xvecxGTX<N, T> operator+ (const detail::_xvecxGTX<N, T>& v, const T s);
    00091
    00092     template <int N, typename T>
    00093     detail::_xvecxGTX<N, T> operator+ (const T s, const detail::_xvecxGTX<N, T>& v);
    00094
    00095     template <int N, typename T>
    00096     detail::_xvecxGTX<N, T> operator+ (const detail::_xvecxGTX<N, T>& v1, const detail::_xvecxGTX<N, T>& v2);
    00097
    00098     template <int N, typename T>
    00099         detail::_xvecxGTX<N, T> operator- (const detail::_xvecxGTX<N, T>& v, const T s);
    00100
    00101     template <int N, typename T>
    00102     detail::_xvecxGTX<N, T> operator- (const T s, const detail::_xvecxGTX<N, T>& v);
    00103
    00104     template <int N, typename T>
    00105     detail::_xvecxGTX<N, T> operator- (const detail::_xvecxGTX<N, T>& v1, const detail::_xvecxGTX<N, T>& v2);
    00106
    00107     template <int N, typename T>
    00108     detail::_xvecxGTX<N, T> operator* (const detail::_xvecxGTX<N, T>& v, const T s);
    00109
    00110     template <int N, typename T>
    00111     detail::_xvecxGTX<N, T> operator* (const T s, const detail::_xvecxGTX<N, T>& v);
    00112
    00113     template <int N, typename T>
    00114     detail::_xvecxGTX<N, T> operator* (const detail::_xvecxGTX<N, T>& v1, const detail::_xvecxGTX<N, T>& v2);
    00115
    00116     template <int N, typename T>
    00117     detail::_xvecxGTX<N, T> operator/ (const detail::_xvecxGTX<N, T>& v, const T s);
    00118
    00119     template <int N, typename T>
    00120     detail::_xvecxGTX<N, T> operator/ (const T s, const detail::_xvecxGTX<N, T>& v);
    00121
    00122     template <int N, typename T>
    00123     detail::_xvecxGTX<N, T> operator/ (const detail::_xvecxGTX<N, T>& v1, const detail::_xvecxGTX<N, T>& v2);
    00124
    00125     // Unary constant operators
    00126     template <int N, typename T>
    00127     const detail::_xvecxGTX<N, T> operator- (const detail::_xvecxGTX<N, T>& v);
    00128
    00129     template <int N, typename T>
    00130     const detail::_xvecxGTX<N, T> operator-- (const detail::_xvecxGTX<N, T>& v, int);
    00131
    00132     template <int N, typename T>
    00133     const detail::_xvecxGTX<N, T> operator++ (const detail::_xvecxGTX<N, T>& v, int);
    00134
    00135 }//namespace detail
    00136
    00137         namespace gtx
    00138     {
    00140         namespace vecx
    00141         {
    00142                         template<typename T, int N>
    00143                         struct vec
    00144                         {
    00145                                 typedef detail::_xvecxGTX<N, T> type;
    00146                         };
    00147
    00148                         // Trigonometric Functions
    00149                         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)
    00150                         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)
    00151                         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)
    00152                         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)
    00153                         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)
    00154                         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)
    00155                         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)
    00156                         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)
    00157                         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)
    00158
    00159                         // Exponential Functions
    00160                         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)
    00161                         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)
    00162                         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)
    00163                         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)
    00164                         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)
    00165                         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)
    00166                         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)
    00167
    00168                         // Common Functions
    00169                         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)
    00170                         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)
    00171                         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)
    00172                         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)
    00173                         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)
    00174                         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)
    00175                         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)
    00176                         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)
    00177                         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)
    00178                         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)
    00179                         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)
    00180                         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)
    00181                         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)
    00182                         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)
    00183                         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)
    00184                         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)
    00185
    00186                         // Geometric Functions
    00187                         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)
    00188                         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)
    00189                         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)
    00190                         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)
    00191                         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)
    00192                         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)
    00193                         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)
    00194
    00195                         // Vector Relational Functions
    00196                         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)
    00197                         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)
    00198                         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)
    00199                         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)
    00200                         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)
    00201                         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)
    00202                         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)
    00203                         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)
    00204                         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)
    00205                         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)
    00206                         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)
    00207         }
    00208     }
    00209 }
    00210
    00211 #define GLM_GTX_vecx namespace gtx::vecx
    00212 #ifndef GLM_GTX_GLOBAL
    00213 namespace glm {using GLM_GTX_vecx;}
    00214 #endif//GLM_GTX_GLOBAL
    00215
    00216 #include "vecx.inl"
    00217
    00218 #endif//glm_gtx_vecx