| /*!**************************************************************************** |
| |
| @file PVRTVector.h |
| @copyright Copyright (c) Imagination Technologies Limited. |
| @brief Vector and matrix mathematics library |
| |
| ******************************************************************************/ |
| #ifndef __PVRTVECTOR_H__ |
| #define __PVRTVECTOR_H__ |
| |
| #include "assert.h" |
| #include "PVRTGlobal.h" |
| #include "PVRTFixedPoint.h" |
| #include "PVRTMatrix.h" |
| #include <string.h> |
| #include <math.h> |
| |
| /*!*************************************************************************** |
| ** Forward Declarations for vector and matrix structs |
| ****************************************************************************/ |
| struct PVRTVec4; |
| struct PVRTVec3; |
| struct PVRTMat3; |
| struct PVRTMat4; |
| |
| /*!*************************************************************************** |
| @fn PVRTLinearEqSolve |
| @param[in] pSrc 2D array of floats. 4 Eq linear problem is 5x4 |
| matrix, constants in first column |
| @param[in] nCnt Number of equations to solve |
| @param[out] pRes Result |
| @brief Solves 'nCnt' simultaneous equations of 'nCnt' variables. |
| pRes should be an array large enough to contain the |
| results: the values of the 'nCnt' variables. |
| This fn recursively uses Gaussian Elimination. |
| *****************************************************************************/ |
| void PVRTLinearEqSolve(VERTTYPE * const pRes, VERTTYPE ** const pSrc, const int nCnt); |
| |
| /*!*************************************************************************** |
| @struct PVRTVec2 |
| @brief 2 component vector |
| *****************************************************************************/ |
| struct PVRTVec2 |
| { |
| VERTTYPE x, y; |
| /*!*************************************************************************** |
| ** Constructors |
| ****************************************************************************/ |
| /*!*************************************************************************** |
| @brief Blank constructor. |
| *****************************************************************************/ |
| PVRTVec2() : x(0), y(0) {} |
| /*!*************************************************************************** |
| @brief Simple constructor from 2 values. |
| @param[in] fX X component of vector |
| @param[in] fY Y component of vector |
| *****************************************************************************/ |
| PVRTVec2(VERTTYPE fX, VERTTYPE fY) : x(fX), y(fY) {} |
| /*!*************************************************************************** |
| @brief Constructor from a single value. |
| @param[in] fValue A component value |
| *****************************************************************************/ |
| PVRTVec2(VERTTYPE fValue) : x(fValue), y(fValue) {} |
| /*!*************************************************************************** |
| @brief Constructor from an array |
| @param[in] pVec An array |
| *****************************************************************************/ |
| PVRTVec2(const VERTTYPE* pVec) : x(pVec[0]), y(pVec[1]) {} |
| /*!*************************************************************************** |
| @brief Constructor from a Vec3 |
| @param[in] v3Vec A Vec3 |
| *****************************************************************************/ |
| PVRTVec2(const PVRTVec3& v3Vec); |
| /*!*************************************************************************** |
| ** Operators |
| ****************************************************************************/ |
| /*!*************************************************************************** |
| @brief componentwise addition operator for two Vec2s |
| @param[in] rhs Another Vec2 |
| @return result of addition |
| *****************************************************************************/ |
| PVRTVec2 operator+(const PVRTVec2& rhs) const |
| { |
| PVRTVec2 out(*this); |
| return out += rhs; |
| } |
| /*!*************************************************************************** |
| @brief componentwise subtraction operator for two Vec2s |
| @param[in] rhs Another vec2 |
| @return result of subtraction |
| ****************************************************************************/ |
| PVRTVec2 operator-(const PVRTVec2& rhs) const |
| { |
| PVRTVec2 out(*this); |
| return out -= rhs; |
| } |
| |
| /*!*************************************************************************** |
| @brief Componentwise addition and assignment operator for two Vec2s |
| @param[in] rhs Another vec2 |
| @return result of addition |
| ****************************************************************************/ |
| PVRTVec2& operator+=(const PVRTVec2& rhs) |
| { |
| x += rhs.x; |
| y += rhs.y; |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @brief Componentwise subtraction and assignment operator for two Vec2s |
| @param[in] rhs Another vec2 |
| @return Result of subtraction |
| ****************************************************************************/ |
| PVRTVec2& operator-=(const PVRTVec2& rhs) |
| { |
| x -= rhs.x; |
| y -= rhs.y; |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @brief Negation operator for a Vec2 |
| @param[in] rhs Another vec2 |
| @return Result of negation |
| ****************************************************************************/ |
| friend PVRTVec2 operator- (const PVRTVec2& rhs) { return PVRTVec2(-rhs.x, -rhs.y); } |
| |
| /*!*************************************************************************** |
| @brief Multiplication operator for a Vec2 |
| @param[in] lhs Scalar |
| @param[in] rhs A Vec2 |
| @return result of multiplication |
| ****************************************************************************/ |
| friend PVRTVec2 operator*(const VERTTYPE lhs, const PVRTVec2& rhs) |
| { |
| PVRTVec2 out(lhs); |
| return out *= rhs; |
| } |
| |
| /*!*************************************************************************** |
| @brief Division operator for scalar and Vec2 |
| @param[in] lhs scalar |
| @param[in] rhs a Vec2 |
| @return Result of division |
| ****************************************************************************/ |
| friend PVRTVec2 operator/(const VERTTYPE lhs, const PVRTVec2& rhs) |
| { |
| PVRTVec2 out(lhs); |
| return out /= rhs; |
| } |
| |
| /*!************************************************************************** |
| @brief Componentwise multiplication by scalar for Vec2* |
| @param[in] rhs A scalar |
| @return Result of multiplication |
| ****************************************************************************/ |
| PVRTVec2 operator*(const VERTTYPE& rhs) const |
| { |
| PVRTVec2 out(*this); |
| return out *= rhs; |
| } |
| |
| /*!*************************************************************************** |
| @brief Componentwise multiplication and assignment by scalar for Vec2 |
| @param[in] rhs A scalar |
| @return Result of multiplication and assignment |
| ****************************************************************************/ |
| PVRTVec2& operator*=(const VERTTYPE& rhs) |
| { |
| x = VERTTYPEMUL(x, rhs); |
| y = VERTTYPEMUL(y, rhs); |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @brief Componentwise multiplication and assignment by Vec2 for Vec2 |
| @param[in] rhs A Vec2 |
| @return Result of multiplication and assignment |
| ****************************************************************************/ |
| PVRTVec2& operator*=(const PVRTVec2& rhs) |
| { |
| x = VERTTYPEMUL(x, rhs.x); |
| y = VERTTYPEMUL(y, rhs.y); |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @brief componentwise division by scalar for Vec2 |
| @param[in] rhs a scalar |
| @return result of division |
| ****************************************************************************/ |
| PVRTVec2 operator/(const VERTTYPE& rhs) const |
| { |
| PVRTVec2 out(*this); |
| return out /= rhs; |
| } |
| |
| /*!*************************************************************************** |
| @brief componentwise division and assignment by scalar for Vec2 |
| @param[in] rhs a scalar |
| @return result of division and assignment |
| ****************************************************************************/ |
| PVRTVec2& operator/=(const VERTTYPE& rhs) |
| { |
| x = VERTTYPEDIV(x, rhs); |
| y = VERTTYPEDIV(y, rhs); |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @brief componentwise division and assignment by Vec2 for Vec2 |
| @param[in] rhs a Vec2 |
| @return result of division and assignment |
| ****************************************************************************/ |
| PVRTVec2& operator/=(const PVRTVec2& rhs) |
| { |
| x = VERTTYPEDIV(x, rhs.x); |
| y = VERTTYPEDIV(y, rhs.y); |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @brief PVRTVec2 equality operator |
| @param[in] rhs A single value |
| @return true if the two vectors are equal |
| ****************************************************************************/ |
| bool operator==(const PVRTVec2& rhs) const |
| { |
| return ((x == rhs.x) && (y == rhs.y)); |
| } |
| |
| /*!*************************************************************************** |
| @brief PVRTVec2 inequality operator |
| @param[in] rhs A single value |
| @return true if the two vectors are not equal |
| ****************************************************************************/ |
| bool operator!=(const PVRTVec2& rhs) const |
| { |
| return ((x != rhs.x) || (y != rhs.y)); |
| } |
| |
| // FUNCTIONS |
| /*!*************************************************************************** |
| @brief calculates the square of the magnitude of the vector |
| @return The square of the magnitude of the vector |
| ****************************************************************************/ |
| VERTTYPE lenSqr() const |
| { |
| return VERTTYPEMUL(x,x)+VERTTYPEMUL(y,y); |
| } |
| |
| /*!*************************************************************************** |
| @fn length |
| @return the of the magnitude of the vector |
| @brief calculates the magnitude of the vector |
| ****************************************************************************/ |
| VERTTYPE length() const |
| { |
| return (VERTTYPE) f2vt(sqrt(vt2f(x)*vt2f(x) + vt2f(y)*vt2f(y))); |
| } |
| |
| /*!*************************************************************************** |
| @fn normalize |
| @return the normalized value of the vector |
| @brief normalizes the vector |
| ****************************************************************************/ |
| PVRTVec2 normalize() |
| { |
| return *this /= length(); |
| } |
| |
| /*!*************************************************************************** |
| @fn normalized |
| @return returns the normalized value of the vector |
| @brief returns a normalized vector of the same direction as this |
| vector |
| ****************************************************************************/ |
| PVRTVec2 normalized() const |
| { |
| PVRTVec2 out(*this); |
| return out.normalize(); |
| } |
| |
| /*!*************************************************************************** |
| @fn rotated90 |
| @return returns the vector rotated 90° |
| @brief returns the vector rotated 90° |
| ****************************************************************************/ |
| PVRTVec2 rotated90() const |
| { |
| return PVRTVec2(-y, x); |
| } |
| |
| /*!*************************************************************************** |
| @fn dot |
| @param[in] rhs A single value |
| @return scalar product |
| @brief calculate the scalar product of two Vec3s |
| ****************************************************************************/ |
| VERTTYPE dot(const PVRTVec2& rhs) const |
| { |
| return VERTTYPEMUL(x, rhs.x) + VERTTYPEMUL(y, rhs.y); |
| } |
| |
| /*!*************************************************************************** |
| @fn ptr |
| @return pointer |
| @brief returns a pointer to memory containing the values of the |
| Vec3 |
| ****************************************************************************/ |
| VERTTYPE *ptr() { return (VERTTYPE*)this; } |
| }; |
| |
| /*!*************************************************************************** |
| @struct PVRTVec3 |
| @brief 3 component vector |
| ****************************************************************************/ |
| struct PVRTVec3 : public PVRTVECTOR3 |
| { |
| /*!*************************************************************************** |
| ** Constructors |
| ****************************************************************************/ |
| /*!*************************************************************************** |
| @brief Blank constructor. |
| *****************************************************************************/ |
| PVRTVec3() |
| { |
| x = y = z = 0; |
| } |
| /*!*************************************************************************** |
| @brief Simple constructor from 3 values. |
| @param[in] fX X component of vector |
| @param[in] fY Y component of vector |
| @param[in] fZ Z component of vector |
| *****************************************************************************/ |
| PVRTVec3(VERTTYPE fX, VERTTYPE fY, VERTTYPE fZ) |
| { |
| x = fX; y = fY; z = fZ; |
| } |
| /*!*************************************************************************** |
| @brief Constructor from a single value. |
| @param[in] fValue A component value |
| *****************************************************************************/ |
| PVRTVec3(const VERTTYPE fValue) |
| { |
| x = fValue; y = fValue; z = fValue; |
| } |
| /*!*************************************************************************** |
| @brief Constructor from an array |
| @param[in] pVec An array |
| *****************************************************************************/ |
| PVRTVec3(const VERTTYPE* pVec) |
| { |
| x = (*pVec++); y = (*pVec++); z = *pVec; |
| } |
| /*!*************************************************************************** |
| @brief Constructor from a PVRTVec4 |
| @param[in] v4Vec A PVRTVec4 |
| *****************************************************************************/ |
| PVRTVec3(const PVRTVec4& v4Vec); |
| /*!*************************************************************************** |
| ** Operators |
| ****************************************************************************/ |
| /*!*************************************************************************** |
| @brief componentwise addition operator for two PVRTVec3s |
| @param[in] rhs Another PVRTVec3 |
| @return result of addition |
| *****************************************************************************/ |
| PVRTVec3 operator+(const PVRTVec3& rhs) const |
| { |
| PVRTVec3 out; |
| out.x = x+rhs.x; |
| out.y = y+rhs.y; |
| out.z = z+rhs.z; |
| return out; |
| } |
| /*!*************************************************************************** |
| @brief Componentwise subtraction operator for two PVRTVec3s |
| @param[in] rhs Another PVRTVec3 |
| @return result of subtraction |
| ****************************************************************************/ |
| PVRTVec3 operator-(const PVRTVec3& rhs) const |
| { |
| PVRTVec3 out; |
| out.x = x-rhs.x; |
| out.y = y-rhs.y; |
| out.z = z-rhs.z; |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @brief Componentwise addition and assignement operator for two PVRTVec3s |
| @param[in] rhs Another PVRTVec3 |
| @return Result of addition |
| ****************************************************************************/ |
| PVRTVec3& operator+=(const PVRTVec3& rhs) |
| { |
| x +=rhs.x; |
| y +=rhs.y; |
| z +=rhs.z; |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @brief Componentwise subtraction and assignement operator for two PVRTVec3s |
| @param[in] rhs Another PVRTVec3 |
| @return Result of subtraction |
| ****************************************************************************/ |
| PVRTVec3& operator-=(const PVRTVec3& rhs) |
| { |
| x -=rhs.x; |
| y -=rhs.y; |
| z -=rhs.z; |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @brief Negation operator for a PVRTVec3 |
| @param[in] rhs Another PVRTVec3 |
| @return Result of negation |
| ****************************************************************************/ |
| friend PVRTVec3 operator - (const PVRTVec3& rhs) { return PVRTVec3(rhs) *= f2vt(-1); } |
| |
| /*!*************************************************************************** |
| @brief multiplication operator for a PVRTVec3 |
| @param[in] lhs Single value |
| @param[in] rhs A PVRTVec3 |
| @return Result of multiplication |
| ****************************************************************************/ |
| friend PVRTVec3 operator*(const VERTTYPE lhs, const PVRTVec3& rhs) |
| { |
| PVRTVec3 out; |
| out.x = VERTTYPEMUL(lhs,rhs.x); |
| out.y = VERTTYPEMUL(lhs,rhs.y); |
| out.z = VERTTYPEMUL(lhs,rhs.z); |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @brief Negation operator for a PVRTVec3 |
| @param[in] lhs Single value |
| @param[in] rhs A PVRTVec3 |
| @return result of negation |
| ****************************************************************************/ |
| friend PVRTVec3 operator/(const VERTTYPE lhs, const PVRTVec3& rhs) |
| { |
| PVRTVec3 out; |
| out.x = VERTTYPEDIV(lhs,rhs.x); |
| out.y = VERTTYPEDIV(lhs,rhs.y); |
| out.z = VERTTYPEDIV(lhs,rhs.z); |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @brief Matrix multiplication operator PVRTVec3 and PVRTMat3 |
| @param[in] rhs A PVRTMat3 |
| @return Result of multiplication |
| ****************************************************************************/ |
| PVRTVec3 operator*(const PVRTMat3& rhs) const; |
| |
| /*!*************************************************************************** |
| @brief Matrix multiplication and assignment operator for PVRTVec3 and PVRTMat3 |
| @param[in] rhs A PVRTMat3 |
| @return Result of multiplication and assignment |
| ****************************************************************************/ |
| PVRTVec3& operator*=(const PVRTMat3& rhs); |
| |
| /*!*************************************************************************** |
| @brief Componentwise multiplication by single dimension value for PVRTVec3 |
| @param[in] rhs A single value |
| @return Result of multiplication |
| ****************************************************************************/ |
| PVRTVec3 operator*(const VERTTYPE& rhs) const |
| { |
| PVRTVec3 out; |
| out.x = VERTTYPEMUL(x,rhs); |
| out.y = VERTTYPEMUL(y,rhs); |
| out.z = VERTTYPEMUL(z,rhs); |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @brief Componentwise multiplication and assignement by single |
| dimension value for PVRTVec3 |
| @param[in] rhs A single value |
| @return Result of multiplication and assignment |
| ****************************************************************************/ |
| PVRTVec3& operator*=(const VERTTYPE& rhs) |
| { |
| x = VERTTYPEMUL(x,rhs); |
| y = VERTTYPEMUL(y,rhs); |
| z = VERTTYPEMUL(z,rhs); |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @brief Componentwise division by single dimension value for PVRTVec3 |
| @param[in] rhs A single value |
| @return Result of division |
| ****************************************************************************/ |
| PVRTVec3 operator/(const VERTTYPE& rhs) const |
| { |
| PVRTVec3 out; |
| out.x = VERTTYPEDIV(x,rhs); |
| out.y = VERTTYPEDIV(y,rhs); |
| out.z = VERTTYPEDIV(z,rhs); |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @brief Componentwise division and assignement by single |
| dimension value for PVRTVec3 |
| @param[in] rhs A single value |
| @return Result of division and assignment |
| ****************************************************************************/ |
| PVRTVec3& operator/=(const VERTTYPE& rhs) |
| { |
| x = VERTTYPEDIV(x,rhs); |
| y = VERTTYPEDIV(y,rhs); |
| z = VERTTYPEDIV(z,rhs); |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @brief PVRTVec3 equality operator |
| @param[in] rhs A single value |
| @return true if the two vectors are equal |
| ****************************************************************************/ |
| bool operator==(const PVRTVec3& rhs) const |
| { |
| return ((x == rhs.x) && (y == rhs.y) && (z == rhs.z)); |
| } |
| |
| /*!*************************************************************************** |
| @brief PVRTVec3 inequality operator |
| @param[in] rhs A single value |
| @return true if the two vectors are not equal |
| ****************************************************************************/ |
| bool operator!=(const PVRTVec3& rhs) const |
| { |
| return ((x != rhs.x) || (y != rhs.y) || (z != rhs.z)); |
| } |
| // FUNCTIONS |
| /*!*************************************************************************** |
| @fn lenSqr |
| @return the square of the magnitude of the vector |
| @brief calculates the square of the magnitude of the vector |
| ****************************************************************************/ |
| VERTTYPE lenSqr() const |
| { |
| return VERTTYPEMUL(x,x)+VERTTYPEMUL(y,y)+VERTTYPEMUL(z,z); |
| } |
| |
| /*!*************************************************************************** |
| @fn length |
| @return the of the magnitude of the vector |
| @brief calculates the magnitude of the vector |
| ****************************************************************************/ |
| VERTTYPE length() const |
| { |
| return (VERTTYPE) f2vt(sqrt(vt2f(x)*vt2f(x) + vt2f(y)*vt2f(y) + vt2f(z)*vt2f(z))); |
| } |
| |
| /*!*************************************************************************** |
| @fn normalize |
| @return the normalized value of the vector |
| @brief normalizes the vector |
| ****************************************************************************/ |
| PVRTVec3 normalize() |
| { |
| #if defined(PVRT_FIXED_POINT_ENABLE) |
| // Scale vector by uniform value |
| int n = PVRTABS(x) + PVRTABS(y) + PVRTABS(z); |
| x = VERTTYPEDIV(x, n); |
| y = VERTTYPEDIV(y, n); |
| z = VERTTYPEDIV(z, n); |
| |
| // Calculate x2+y2+z2/sqrt(x2+y2+z2) |
| int f = dot(*this); |
| f = VERTTYPEDIV(PVRTF2X(1.0f), PVRTF2X(sqrt(PVRTX2F(f)))); |
| |
| // Multiply vector components by f |
| x = PVRTXMUL(x, f); |
| y = PVRTXMUL(y, f); |
| z = PVRTXMUL(z, f); |
| #else |
| VERTTYPE len = length(); |
| x =VERTTYPEDIV(x,len); |
| y =VERTTYPEDIV(y,len); |
| z =VERTTYPEDIV(z,len); |
| #endif |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @fn normalized |
| @return returns the normalized value of the vector |
| @brief returns a normalized vector of the same direction as this |
| vector |
| ****************************************************************************/ |
| PVRTVec3 normalized() const |
| { |
| PVRTVec3 out; |
| #if defined(PVRT_FIXED_POINT_ENABLE) |
| // Scale vector by uniform value |
| int n = PVRTABS(x) + PVRTABS(y) + PVRTABS(z); |
| out.x = VERTTYPEDIV(x, n); |
| out.y = VERTTYPEDIV(y, n); |
| out.z = VERTTYPEDIV(z, n); |
| |
| // Calculate x2+y2+z2/sqrt(x2+y2+z2) |
| int f = out.dot(out); |
| f = VERTTYPEDIV(PVRTF2X(1.0f), PVRTF2X(sqrt(PVRTX2F(f)))); |
| |
| // Multiply vector components by f |
| out.x = PVRTXMUL(out.x, f); |
| out.y = PVRTXMUL(out.y, f); |
| out.z = PVRTXMUL(out.z, f); |
| #else |
| VERTTYPE len = length(); |
| out.x =VERTTYPEDIV(x,len); |
| out.y =VERTTYPEDIV(y,len); |
| out.z =VERTTYPEDIV(z,len); |
| #endif |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @fn dot |
| @param[in] rhs A single value |
| @return scalar product |
| @brief calculate the scalar product of two PVRTVec3s |
| ****************************************************************************/ |
| VERTTYPE dot(const PVRTVec3& rhs) const |
| { |
| return VERTTYPEMUL(x,rhs.x)+VERTTYPEMUL(y,rhs.y)+VERTTYPEMUL(z,rhs.z); |
| } |
| |
| /*!*************************************************************************** |
| @fn cross |
| @return returns three-dimensional vector |
| @brief calculate the cross product of two PVRTVec3s |
| ****************************************************************************/ |
| PVRTVec3 cross(const PVRTVec3& rhs) const |
| { |
| PVRTVec3 out; |
| out.x = VERTTYPEMUL(y,rhs.z)-VERTTYPEMUL(z,rhs.y); |
| out.y = VERTTYPEMUL(z,rhs.x)-VERTTYPEMUL(x,rhs.z); |
| out.z = VERTTYPEMUL(x,rhs.y)-VERTTYPEMUL(y,rhs.x); |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @fn ptr |
| @return pointer |
| @brief returns a pointer to memory containing the values of the |
| PVRTVec3 |
| ****************************************************************************/ |
| VERTTYPE *ptr() { return (VERTTYPE*)this; } |
| }; |
| |
| /*!*************************************************************************** |
| @struct PVRTVec4 |
| @brief 4 component vector |
| ****************************************************************************/ |
| struct PVRTVec4 : public PVRTVECTOR4 |
| { |
| /*!*************************************************************************** |
| ** Constructors |
| ****************************************************************************/ |
| /*!*************************************************************************** |
| @brief Blank constructor. |
| *****************************************************************************/ |
| PVRTVec4(){} |
| |
| /*!*************************************************************************** |
| @brief Blank constructor. |
| *****************************************************************************/ |
| PVRTVec4(const VERTTYPE vec) |
| { |
| x = vec; y = vec; z = vec; w = vec; |
| } |
| |
| /*!*************************************************************************** |
| @brief Constructs a PVRTVec4 from 4 separate values |
| @param[in] fX Value of x component |
| @param[in] fY Value of y component |
| @param[in] fZ Value of z component |
| @param[in] fW Value of w component |
| ****************************************************************************/ |
| PVRTVec4(VERTTYPE fX, VERTTYPE fY, VERTTYPE fZ, VERTTYPE fW) |
| { |
| x = fX; y = fY; z = fZ; w = fW; |
| } |
| |
| /*!*************************************************************************** |
| @param[in] vec3 a PVRTVec3 |
| @param[in] fW Value of w component |
| @brief Constructs a PVRTVec4 from a vec3 and a w component |
| ****************************************************************************/ |
| PVRTVec4(const PVRTVec3& vec3, VERTTYPE fW) |
| { |
| x = vec3.x; y = vec3.y; z = vec3.z; w = fW; |
| } |
| |
| /*!*************************************************************************** |
| @brief Constructs a vec4 from a vec3 and a w component |
| @param[in] fX value of x component |
| @param[in] vec3 a PVRTVec3 |
| ****************************************************************************/ |
| PVRTVec4(VERTTYPE fX, const PVRTVec3& vec3) |
| { |
| x = fX; y = vec3.x; z = vec3.y; w = vec3.z; |
| } |
| |
| /*!*************************************************************************** |
| @brief Constructs a PVRTVec4 from a pointer to an array of four values |
| @param[in] pVec a pointer to an array of four values |
| ****************************************************************************/ |
| PVRTVec4(const VERTTYPE* pVec) |
| { |
| x = (*pVec++); y = (*pVec++); z= (*pVec++); w = *pVec; |
| } |
| |
| /*!*************************************************************************** |
| ** PVRTVec4 Operators |
| ****************************************************************************/ |
| /*!*************************************************************************** |
| @brief Addition operator for PVRTVec4 |
| @param[in] rhs Another PVRTVec4 |
| @return result of addition |
| ****************************************************************************/ |
| PVRTVec4 operator+(const PVRTVec4& rhs) const |
| { |
| PVRTVec4 out; |
| out.x = x+rhs.x; |
| out.y = y+rhs.y; |
| out.z = z+rhs.z; |
| out.w = w+rhs.w; |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @brief Subtraction operator for PVRTVec4 |
| @param[in] rhs Another PVRTVec4 |
| @return result of subtraction |
| ****************************************************************************/ |
| PVRTVec4 operator-(const PVRTVec4& rhs) const |
| { |
| PVRTVec4 out; |
| out.x = x-rhs.x; |
| out.y = y-rhs.y; |
| out.z = z-rhs.z; |
| out.w = w-rhs.w; |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @brief Addition and assignment operator for PVRTVec4 |
| @param[in] rhs Another PVRTVec4 |
| @return result of addition and assignment |
| ****************************************************************************/ |
| PVRTVec4& operator+=(const PVRTVec4& rhs) |
| { |
| x +=rhs.x; |
| y +=rhs.y; |
| z +=rhs.z; |
| w +=rhs.w; |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @brief Subtraction and assignment operator for PVRTVec4 |
| @param[in] rhs Another PVRTVec4 |
| @return result of subtraction and assignment |
| ****************************************************************************/ |
| PVRTVec4& operator-=(const PVRTVec4& rhs) |
| { |
| x -=rhs.x; |
| y -=rhs.y; |
| z -=rhs.z; |
| w -=rhs.w; |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @brief Matrix multiplication for PVRTVec4 and PVRTMat4 |
| @param[in] rhs A PVRTMat4 |
| @return result of multiplication |
| ****************************************************************************/ |
| PVRTVec4 operator*(const PVRTMat4& rhs) const; |
| |
| /*!*************************************************************************** |
| @brief Matrix multiplication and assignment for PVRTVec4 and PVRTMat4 |
| @param[in] rhs A PVRTMat4 |
| @return result of multiplication and assignement |
| ****************************************************************************/ |
| PVRTVec4& operator*=(const PVRTMat4& rhs); |
| |
| /*!*************************************************************************** |
| @brief Componentwise multiplication of a PVRTVec4 by a single value |
| @param[in] rhs A single dimension value |
| @return result of multiplication |
| ****************************************************************************/ |
| PVRTVec4 operator*(const VERTTYPE& rhs) const |
| { |
| PVRTVec4 out; |
| out.x = VERTTYPEMUL(x,rhs); |
| out.y = VERTTYPEMUL(y,rhs); |
| out.z = VERTTYPEMUL(z,rhs); |
| out.w = VERTTYPEMUL(w,rhs); |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @brief componentwise multiplication and assignment of a PVRTVec4 by |
| a single value |
| @param[in] rhs A single dimension value |
| @return result of multiplication and assignment |
| ****************************************************************************/ |
| PVRTVec4& operator*=(const VERTTYPE& rhs) |
| { |
| x = VERTTYPEMUL(x,rhs); |
| y = VERTTYPEMUL(y,rhs); |
| z = VERTTYPEMUL(z,rhs); |
| w = VERTTYPEMUL(w,rhs); |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @brief componentwise division of a PVRTVec4 by a single value |
| @param[in] rhs A single dimension value |
| @return result of division |
| ****************************************************************************/ |
| PVRTVec4 operator/(const VERTTYPE& rhs) const |
| { |
| PVRTVec4 out; |
| out.x = VERTTYPEDIV(x,rhs); |
| out.y = VERTTYPEDIV(y,rhs); |
| out.z = VERTTYPEDIV(z,rhs); |
| out.w = VERTTYPEDIV(w,rhs); |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @brief componentwise division and assignment of a PVRTVec4 by |
| a single value |
| @param[in] rhs a single dimension value |
| @return result of division and assignment |
| ****************************************************************************/ |
| PVRTVec4& operator/=(const VERTTYPE& rhs) |
| { |
| x = VERTTYPEDIV(x,rhs); |
| y = VERTTYPEDIV(y,rhs); |
| z = VERTTYPEDIV(z,rhs); |
| w = VERTTYPEDIV(w,rhs); |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @brief componentwise multiplication of a PVRTVec4 by |
| a single value |
| @param[in] lhs a single dimension value |
| @param[in] rhs a PVRTVec4 |
| @return result of muliplication |
| ****************************************************************************/ |
| friend PVRTVec4 operator*(const VERTTYPE lhs, const PVRTVec4& rhs) |
| { |
| PVRTVec4 out; |
| out.x = VERTTYPEMUL(lhs,rhs.x); |
| out.y = VERTTYPEMUL(lhs,rhs.y); |
| out.z = VERTTYPEMUL(lhs,rhs.z); |
| out.w = VERTTYPEMUL(lhs,rhs.w); |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @brief PVRTVec4 equality operator |
| @param[in] rhs A single value |
| @return true if the two vectors are equal |
| ****************************************************************************/ |
| bool operator==(const PVRTVec4& rhs) const |
| { |
| return ((x == rhs.x) && (y == rhs.y) && (z == rhs.z) && (w == rhs.w)); |
| } |
| |
| /*!*************************************************************************** |
| @brief PVRTVec4 inequality operator |
| @param[in] rhs A single value |
| @return true if the two vectors are not equal |
| ****************************************************************************/ |
| bool operator!=(const PVRTVec4& rhs) const |
| { |
| return ((x != rhs.x) || (y != rhs.y) || (z != rhs.z) || (w != rhs.w)); |
| } |
| /*!*************************************************************************** |
| ** Functions |
| ****************************************************************************/ |
| /*!*************************************************************************** |
| @fn lenSqr |
| @return square of the magnitude of the vector |
| @brief calculates the square of the magnitude of the vector |
| ****************************************************************************/ |
| VERTTYPE lenSqr() const |
| { |
| return VERTTYPEMUL(x,x)+VERTTYPEMUL(y,y)+VERTTYPEMUL(z,z)+VERTTYPEMUL(w,w); |
| } |
| |
| /*!*************************************************************************** |
| @fn length |
| @return the magnitude of the vector |
| @brief calculates the magnitude of the vector |
| ****************************************************************************/ |
| VERTTYPE length() const |
| { |
| return (VERTTYPE) f2vt(sqrt(vt2f(x)*vt2f(x) + vt2f(y)*vt2f(y) + vt2f(z)*vt2f(z) + vt2f(w)*vt2f(w))); |
| } |
| |
| /*!*************************************************************************** |
| @fn normalize |
| @return normalized vector |
| @brief calculates the normalized value of a PVRTVec4 |
| ****************************************************************************/ |
| PVRTVec4 normalize() |
| { |
| VERTTYPE len = length(); |
| x =VERTTYPEDIV(x,len); |
| y =VERTTYPEDIV(y,len); |
| z =VERTTYPEDIV(z,len); |
| w =VERTTYPEDIV(w,len); |
| return *this; |
| } |
| /*!*************************************************************************** |
| @fn normalized |
| @return normalized vector |
| @brief returns a normalized vector of the same direction as this |
| vector |
| ****************************************************************************/ |
| PVRTVec4 normalized() const |
| { |
| PVRTVec4 out; |
| VERTTYPE len = length(); |
| out.x =VERTTYPEDIV(x,len); |
| out.y =VERTTYPEDIV(y,len); |
| out.z =VERTTYPEDIV(z,len); |
| out.w =VERTTYPEDIV(w,len); |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @fn dot |
| @return scalar product |
| @brief returns a normalized vector of the same direction as this |
| vector |
| ****************************************************************************/ |
| VERTTYPE dot(const PVRTVec4& rhs) const |
| { |
| return VERTTYPEMUL(x,rhs.x)+VERTTYPEMUL(y,rhs.y)+VERTTYPEMUL(z,rhs.z)+VERTTYPEMUL(w,rhs.w); |
| } |
| |
| /*!*************************************************************************** |
| @fn ptr |
| @return pointer to vector values |
| @brief returns a pointer to memory containing the values of the |
| PVRTVec3 |
| ****************************************************************************/ |
| VERTTYPE *ptr() { return (VERTTYPE*)this; } |
| }; |
| |
| /*!*************************************************************************** |
| @struct PVRTMat3 |
| @brief 3x3 Matrix |
| ****************************************************************************/ |
| struct PVRTMat3 : public PVRTMATRIX3 |
| { |
| /*!*************************************************************************** |
| ** Constructors |
| ****************************************************************************/ |
| /*!*************************************************************************** |
| @brief Blank constructor. |
| *****************************************************************************/ |
| PVRTMat3(){} |
| /*!*************************************************************************** |
| @brief Constructor from array. |
| @param[in] pMat An array of values for the matrix |
| *****************************************************************************/ |
| PVRTMat3(const VERTTYPE* pMat) |
| { |
| VERTTYPE* ptr = f; |
| for(int i=0;i<9;i++) |
| { |
| (*ptr++)=(*pMat++); |
| } |
| } |
| |
| /*!*************************************************************************** |
| @brief Constructor from distinct values. |
| @param[in] m0 m0 matrix value |
| @param[in] m1 m1 matrix value |
| @param[in] m2 m2 matrix value |
| @param[in] m3 m3 matrix value |
| @param[in] m4 m4 matrix value |
| @param[in] m5 m5 matrix value |
| @param[in] m6 m6 matrix value |
| @param[in] m7 m7 matrix value |
| @param[in] m8 m8 matrix value |
| *****************************************************************************/ |
| PVRTMat3(VERTTYPE m0,VERTTYPE m1,VERTTYPE m2, |
| VERTTYPE m3,VERTTYPE m4,VERTTYPE m5, |
| VERTTYPE m6,VERTTYPE m7,VERTTYPE m8) |
| { |
| f[0]=m0;f[1]=m1;f[2]=m2; |
| f[3]=m3;f[4]=m4;f[5]=m5; |
| f[6]=m6;f[7]=m7;f[8]=m8; |
| } |
| |
| /*!*************************************************************************** |
| @brief Constructor from 4x4 matrix - uses top left values |
| @param[in] mat - a PVRTMat4 |
| *****************************************************************************/ |
| PVRTMat3(const PVRTMat4& mat); |
| |
| /**************************************************************************** |
| ** PVRTMat3 OPERATORS |
| ****************************************************************************/ |
| /*!*************************************************************************** |
| @brief Returns the value of the element at the specified row and column |
| of the PVRTMat3 |
| @param[in] row row of matrix |
| @param[in] column column of matrix |
| @return value of element |
| *****************************************************************************/ |
| VERTTYPE& operator()(const int row, const int column) |
| { |
| return f[column*3+row]; |
| } |
| /*!*************************************************************************** |
| @brief Returns the value of the element at the specified row and column |
| of the PVRTMat3 |
| @param[in] row row of matrix |
| @param[in] column column of matrix |
| @return value of element |
| *****************************************************************************/ |
| const VERTTYPE& operator()(const int row, const int column) const |
| { |
| return f[column*3+row]; |
| } |
| |
| /*!*************************************************************************** |
| @brief Matrix multiplication of two 3x3 matrices. |
| @param[in] rhs Another PVRTMat3 |
| @return result of multiplication |
| *****************************************************************************/ |
| PVRTMat3 operator*(const PVRTMat3& rhs) const |
| { |
| PVRTMat3 out; |
| // col 1 |
| out.f[0] = VERTTYPEMUL(f[0],rhs.f[0])+VERTTYPEMUL(f[3],rhs.f[1])+VERTTYPEMUL(f[6],rhs.f[2]); |
| out.f[1] = VERTTYPEMUL(f[1],rhs.f[0])+VERTTYPEMUL(f[4],rhs.f[1])+VERTTYPEMUL(f[7],rhs.f[2]); |
| out.f[2] = VERTTYPEMUL(f[2],rhs.f[0])+VERTTYPEMUL(f[5],rhs.f[1])+VERTTYPEMUL(f[8],rhs.f[2]); |
| |
| // col 2 |
| out.f[3] = VERTTYPEMUL(f[0],rhs.f[3])+VERTTYPEMUL(f[3],rhs.f[4])+VERTTYPEMUL(f[6],rhs.f[5]); |
| out.f[4] = VERTTYPEMUL(f[1],rhs.f[3])+VERTTYPEMUL(f[4],rhs.f[4])+VERTTYPEMUL(f[7],rhs.f[5]); |
| out.f[5] = VERTTYPEMUL(f[2],rhs.f[3])+VERTTYPEMUL(f[5],rhs.f[4])+VERTTYPEMUL(f[8],rhs.f[5]); |
| |
| // col3 |
| out.f[6] = VERTTYPEMUL(f[0],rhs.f[6])+VERTTYPEMUL(f[3],rhs.f[7])+VERTTYPEMUL(f[6],rhs.f[8]); |
| out.f[7] = VERTTYPEMUL(f[1],rhs.f[6])+VERTTYPEMUL(f[4],rhs.f[7])+VERTTYPEMUL(f[7],rhs.f[8]); |
| out.f[8] = VERTTYPEMUL(f[2],rhs.f[6])+VERTTYPEMUL(f[5],rhs.f[7])+VERTTYPEMUL(f[8],rhs.f[8]); |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @brief element by element addition operator. |
| @param[in] rhs Another PVRTMat3 |
| @return result of addition |
| *****************************************************************************/ |
| PVRTMat3 operator+(const PVRTMat3& rhs) const |
| { |
| PVRTMat3 out; |
| VERTTYPE const *lptr = f, *rptr = rhs.f; |
| VERTTYPE *outptr = out.f; |
| for(int i=0;i<9;i++) |
| { |
| (*outptr++) = (*lptr++) + (*rptr++); |
| } |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @brief element by element subtraction operator. |
| @param[in] rhs Another PVRTMat3 |
| @return result of subtraction |
| *****************************************************************************/ |
| PVRTMat3 operator-(const PVRTMat3& rhs) const |
| { |
| PVRTMat3 out; |
| VERTTYPE const *lptr = f, *rptr = rhs.f; |
| VERTTYPE *outptr = out.f; |
| for(int i=0;i<9;i++) |
| { |
| (*outptr++) = (*lptr++) - (*rptr++); |
| } |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @brief Element by element addition and assignment operator. |
| @param[in] rhs Another PVRTMat3 |
| @return Result of addition and assignment |
| *****************************************************************************/ |
| PVRTMat3& operator+=(const PVRTMat3& rhs) |
| { |
| VERTTYPE *lptr = f; |
| VERTTYPE const *rptr = rhs.f; |
| for(int i=0;i<9;i++) |
| { |
| (*lptr++) += (*rptr++); |
| } |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @brief element by element subtraction and assignment operator. |
| @param[in] rhs Another PVRTMat3 |
| @return result of subtraction and assignment |
| *****************************************************************************/ |
| PVRTMat3& operator-=(const PVRTMat3& rhs) |
| { |
| VERTTYPE *lptr = f; |
| VERTTYPE const *rptr = rhs.f; |
| for(int i=0;i<9;i++) |
| { |
| (*lptr++) -= (*rptr++); |
| } |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @brief Matrix multiplication and assignment of two 3x3 matrices. |
| @param[in] rhs Another PVRTMat3 |
| @return result of multiplication and assignment |
| *****************************************************************************/ |
| PVRTMat3& operator*=(const PVRTMat3& rhs) |
| { |
| PVRTMat3 out; |
| // col 1 |
| out.f[0] = VERTTYPEMUL(f[0],rhs.f[0])+VERTTYPEMUL(f[3],rhs.f[1])+VERTTYPEMUL(f[6],rhs.f[2]); |
| out.f[1] = VERTTYPEMUL(f[1],rhs.f[0])+VERTTYPEMUL(f[4],rhs.f[1])+VERTTYPEMUL(f[7],rhs.f[2]); |
| out.f[2] = VERTTYPEMUL(f[2],rhs.f[0])+VERTTYPEMUL(f[5],rhs.f[1])+VERTTYPEMUL(f[8],rhs.f[2]); |
| |
| // col 2 |
| out.f[3] = VERTTYPEMUL(f[0],rhs.f[3])+VERTTYPEMUL(f[3],rhs.f[4])+VERTTYPEMUL(f[6],rhs.f[5]); |
| out.f[4] = VERTTYPEMUL(f[1],rhs.f[3])+VERTTYPEMUL(f[4],rhs.f[4])+VERTTYPEMUL(f[7],rhs.f[5]); |
| out.f[5] = VERTTYPEMUL(f[2],rhs.f[3])+VERTTYPEMUL(f[5],rhs.f[4])+VERTTYPEMUL(f[8],rhs.f[5]); |
| |
| // col3 |
| out.f[6] = VERTTYPEMUL(f[0],rhs.f[6])+VERTTYPEMUL(f[3],rhs.f[7])+VERTTYPEMUL(f[6],rhs.f[8]); |
| out.f[7] = VERTTYPEMUL(f[1],rhs.f[6])+VERTTYPEMUL(f[4],rhs.f[7])+VERTTYPEMUL(f[7],rhs.f[8]); |
| out.f[8] = VERTTYPEMUL(f[2],rhs.f[6])+VERTTYPEMUL(f[5],rhs.f[7])+VERTTYPEMUL(f[8],rhs.f[8]); |
| *this = out; |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @brief Element multiplication by a single value. |
| @param[in] rhs A single value |
| @return Result of multiplication and assignment |
| *****************************************************************************/ |
| PVRTMat3& operator*(const VERTTYPE rhs) |
| { |
| for (int i=0; i<9; ++i) |
| { |
| f[i]*=rhs; |
| } |
| return *this; |
| } |
| /*!*************************************************************************** |
| @brief Element multiplication and assignment by a single value. |
| @param[in] rhs A single value |
| @return result of multiplication and assignment |
| *****************************************************************************/ |
| PVRTMat3& operator*=(const VERTTYPE rhs) |
| { |
| for (int i=0; i<9; ++i) |
| { |
| f[i]*=rhs; |
| } |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @brief Matrix multiplication of 3x3 matrix and vec3 |
| @param[in] rhs Another PVRTVec3 |
| @return result of multiplication |
| *****************************************************************************/ |
| PVRTVec3 operator*(const PVRTVec3& rhs) const |
| { |
| PVRTVec3 out; |
| out.x = VERTTYPEMUL(rhs.x,f[0])+VERTTYPEMUL(rhs.y,f[3])+VERTTYPEMUL(rhs.z,f[6]); |
| out.y = VERTTYPEMUL(rhs.x,f[1])+VERTTYPEMUL(rhs.y,f[4])+VERTTYPEMUL(rhs.z,f[7]); |
| out.z = VERTTYPEMUL(rhs.x,f[2])+VERTTYPEMUL(rhs.y,f[5])+VERTTYPEMUL(rhs.z,f[8]); |
| |
| return out; |
| } |
| |
| |
| // FUNCTIONS |
| /*!*************************************************************************** |
| ** Functions |
| *****************************************************************************/ |
| /*!*************************************************************************** |
| @fn determinant |
| @return result of multiplication |
| @brief Matrix multiplication and assignment of 3x3 matrix and vec3 |
| *****************************************************************************/ |
| VERTTYPE determinant() const |
| { |
| return VERTTYPEMUL(f[0],(VERTTYPEMUL(f[4],f[8])-VERTTYPEMUL(f[7],f[5]))) |
| - VERTTYPEMUL(f[3],(VERTTYPEMUL(f[1],f[8])-VERTTYPEMUL(f[7],f[2]))) |
| + VERTTYPEMUL(f[6],(VERTTYPEMUL(f[1],f[5])-VERTTYPEMUL(f[4],f[2]))); |
| } |
| |
| /*!*************************************************************************** |
| @fn inverse |
| @return inverse mat3 |
| @brief Calculates multiplicative inverse of this matrix |
| *****************************************************************************/ |
| PVRTMat3 inverse() const |
| { |
| PVRTMat3 out; |
| |
| |
| VERTTYPE recDet = determinant(); |
| _ASSERT(recDet!=0); |
| recDet = VERTTYPEDIV(f2vt(1.0f),recDet); |
| |
| //TODO: deal with singular matrices with more than just an assert |
| |
| // inverse is 1/det * adjoint of M |
| |
| // adjoint is transpose of cofactor matrix |
| |
| // do transpose and cofactors in one step |
| |
| out.f[0] = VERTTYPEMUL(f[4],f[8]) - VERTTYPEMUL(f[5],f[7]); |
| out.f[1] = VERTTYPEMUL(f[2],f[7]) - VERTTYPEMUL(f[1],f[8]); |
| out.f[2] = VERTTYPEMUL(f[1],f[5]) - VERTTYPEMUL(f[2],f[4]); |
| |
| out.f[3] = VERTTYPEMUL(f[5],f[6]) - VERTTYPEMUL(f[3],f[8]); |
| out.f[4] = VERTTYPEMUL(f[0],f[8]) - VERTTYPEMUL(f[2],f[6]); |
| out.f[5] = VERTTYPEMUL(f[2],f[3]) - VERTTYPEMUL(f[0],f[5]); |
| |
| out.f[6] = VERTTYPEMUL(f[3],f[7]) - VERTTYPEMUL(f[4],f[6]); |
| out.f[7] = VERTTYPEMUL(f[1],f[6]) - VERTTYPEMUL(f[0],f[7]); |
| out.f[8] = VERTTYPEMUL(f[0],f[4]) - VERTTYPEMUL(f[1],f[3]); |
| |
| out *= recDet; |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @fn transpose |
| @return transpose 3x3 matrix |
| @brief Calculates the transpose of this matrix |
| *****************************************************************************/ |
| PVRTMat3 transpose() const |
| { |
| PVRTMat3 out; |
| out.f[0] = f[0]; out.f[3] = f[1]; out.f[6] = f[2]; |
| out.f[1] = f[3]; out.f[4] = f[4]; out.f[7] = f[5]; |
| out.f[2] = f[6]; out.f[5] = f[7]; out.f[8] = f[8]; |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @fn ptr |
| @return pointer to an array of the elements of this PVRTMat3 |
| @brief Calculates transpose of this matrix |
| *****************************************************************************/ |
| VERTTYPE *ptr() { return (VERTTYPE*)&f; } |
| |
| /*!*************************************************************************** |
| ** Static factory functions |
| *****************************************************************************/ |
| /*!*************************************************************************** |
| @fn Identity |
| @return a PVRTMat3 representation of the 3x3 identity matrix |
| @brief Generates an identity matrix |
| *****************************************************************************/ |
| static PVRTMat3 Identity() |
| { |
| PVRTMat3 out; |
| out.f[0] = 1;out.f[1] = 0;out.f[2] = 0; |
| out.f[3] = 0;out.f[4] = 1;out.f[5] = 0; |
| out.f[6] = 0;out.f[7] = 0;out.f[8] = 1; |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @fn RotationX |
| @return a PVRTMat3 corresponding to the requested rotation |
| @brief Calculates a matrix corresponding to a rotation of angle |
| degrees about the X axis |
| *****************************************************************************/ |
| static PVRTMat3 RotationX(VERTTYPE angle); |
| |
| /*!*************************************************************************** |
| @fn RotationY |
| @return a PVRTMat3 corresponding to the requested rotation |
| @brief Calculates a matrix corresponding to a rotation of angle |
| degrees about the Y axis |
| *****************************************************************************/ |
| static PVRTMat3 RotationY(VERTTYPE angle); |
| |
| /*!*************************************************************************** |
| @fn RotationZ |
| @return a PVRTMat3 corresponding to the requested rotation |
| @brief Calculates a matrix corresponding to a rotation of angle |
| degrees about the Z axis |
| *****************************************************************************/ |
| static PVRTMat3 RotationZ(VERTTYPE angle); |
| |
| /*!*************************************************************************** |
| @fn Rotation2D |
| @return a PVRTMat3 corresponding to the requested rotation |
| @brief Calculates a matrix corresponding to a rotation of angle |
| degrees about the Z axis |
| *****************************************************************************/ |
| static PVRTMat3 Rotation2D(VERTTYPE angle) |
| { |
| return RotationZ(angle); |
| } |
| |
| /*!*************************************************************************** |
| @fn Scale |
| @return a PVRTMat3 corresponding to the requested scaling transformation |
| @brief Calculates a matrix corresponding to scaling of fx, fy and fz |
| times in each axis. |
| *****************************************************************************/ |
| static PVRTMat3 Scale(const VERTTYPE fx,const VERTTYPE fy,const VERTTYPE fz) |
| { |
| return PVRTMat3(fx,0,0, |
| 0,fy,0, |
| 0,0,fz); |
| } |
| |
| /*!*************************************************************************** |
| @fn Scale2D |
| @return a PVRTMat3 corresponding to the requested scaling transformation |
| @brief Calculates a matrix corresponding to scaling of fx, fy and fz |
| times in each axis. |
| *****************************************************************************/ |
| static PVRTMat3 Scale2D(const VERTTYPE fx,const VERTTYPE fy) |
| { |
| return PVRTMat3(fx,0,0, |
| 0,fy,0, |
| 0,0,f2vt(1)); |
| } |
| |
| /*!*************************************************************************** |
| @fn Translation2D |
| @return a PVRTMat3 corresponding to the requested translation |
| @brief Calculates a matrix corresponding to a transformation |
| of tx and ty times in each axis. |
| *****************************************************************************/ |
| static PVRTMat3 Translation2D(const VERTTYPE tx, const VERTTYPE ty) |
| { |
| return PVRTMat3( f2vt(1), 0, 0, |
| 0, f2vt(1), 0, |
| tx, ty, f2vt(1)); |
| } |
| |
| }; |
| |
| /*!*************************************************************************** |
| @struct PVRTMat4 |
| @brief 4x4 Matrix |
| ****************************************************************************/ |
| struct PVRTMat4 : public PVRTMATRIX |
| { |
| /*!*************************************************************************** |
| ** Constructors |
| ****************************************************************************/ |
| /*!*************************************************************************** |
| @brief Blank constructor. |
| *****************************************************************************/ |
| PVRTMat4(){} |
| /*!*************************************************************************** |
| @brief Constructor from array. |
| @param[in] m0 m0 matrix value |
| @param[in] m1 m1 matrix value |
| @param[in] m2 m2 matrix value |
| @param[in] m3 m3 matrix value |
| @param[in] m4 m4 matrix value |
| @param[in] m5 m5 matrix value |
| @param[in] m6 m6 matrix value |
| @param[in] m7 m7 matrix value |
| @param[in] m8 m8 matrix value |
| @param[in] m9 m9 matrix value |
| @param[in] m10 m10 matrix value |
| @param[in] m11 m11 matrix value |
| @param[in] m12 m12 matrix value |
| @param[in] m13 m13 matrix value |
| @param[in] m14 m14 matrix value |
| @param[in] m15 m15 matrix value |
| *****************************************************************************/ |
| PVRTMat4(VERTTYPE m0,VERTTYPE m1,VERTTYPE m2,VERTTYPE m3, |
| VERTTYPE m4,VERTTYPE m5,VERTTYPE m6,VERTTYPE m7, |
| VERTTYPE m8,VERTTYPE m9,VERTTYPE m10,VERTTYPE m11, |
| VERTTYPE m12,VERTTYPE m13,VERTTYPE m14,VERTTYPE m15) |
| { |
| f[0]=m0;f[1]=m1;f[2]=m2;f[3]=m3; |
| f[4]=m4;f[5]=m5;f[6]=m6;f[7]=m7; |
| f[8]=m8;f[9]=m9;f[10]=m10;f[11]=m11; |
| f[12]=m12;f[13]=m13;f[14]=m14;f[15]=m15; |
| } |
| /*!*************************************************************************** |
| @brief Constructor from distinct values. |
| @param[in] mat A pointer to an array of 16 VERTTYPEs |
| *****************************************************************************/ |
| PVRTMat4(const VERTTYPE* mat) |
| { |
| VERTTYPE* ptr = f; |
| for(int i=0;i<16;i++) |
| { |
| (*ptr++)=(*mat++); |
| } |
| } |
| |
| /**************************************************************************** |
| ** PVRTMat4 OPERATORS |
| ****************************************************************************/ |
| /*!*************************************************************************** |
| @brief Returns value of the element at row r and colun c of the |
| PVRTMat4 |
| @param[in] r - row of matrix |
| @param[in] c - column of matrix |
| @return value of element |
| *****************************************************************************/ |
| VERTTYPE& operator()(const int r, const int c) |
| { |
| return f[c*4+r]; |
| } |
| |
| /*!*************************************************************************** |
| @brief Returns value of the element at row r and colun c of the |
| PVRTMat4 |
| @param[in] r - row of matrix |
| @param[in] c - column of matrix |
| @return value of element |
| *****************************************************************************/ |
| const VERTTYPE& operator()(const int r, const int c) const |
| { |
| return f[c*4+r]; |
| } |
| |
| /*!*************************************************************************** |
| @brief Matrix multiplication of two 4x4 matrices. |
| @param[in] rhs another PVRTMat4 |
| @return result of multiplication |
| *****************************************************************************/ |
| PVRTMat4 operator*(const PVRTMat4& rhs) const; |
| |
| /*!*************************************************************************** |
| @brief element by element addition operator. |
| @param[in] rhs another PVRTMat4 |
| @return result of addition |
| *****************************************************************************/ |
| PVRTMat4 operator+(const PVRTMat4& rhs) const |
| { |
| PVRTMat4 out; |
| VERTTYPE const *lptr = f, *rptr = rhs.f; |
| VERTTYPE *outptr = out.f; |
| for(int i=0;i<16;i++) |
| { |
| (*outptr++) = (*lptr++) + (*rptr++); |
| } |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @brief element by element subtraction operator. |
| @param[in] rhs another PVRTMat4 |
| @return result of subtraction |
| *****************************************************************************/ |
| PVRTMat4 operator-(const PVRTMat4& rhs) const |
| { |
| PVRTMat4 out; |
| for(int i=0;i<16;i++) |
| { |
| out.f[i] = f[i]-rhs.f[i]; |
| } |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @brief element by element addition and assignment operator. |
| @param[in] rhs another PVRTMat4 |
| @return result of addition and assignment |
| *****************************************************************************/ |
| PVRTMat4& operator+=(const PVRTMat4& rhs) |
| { |
| VERTTYPE *lptr = f; |
| VERTTYPE const *rptr = rhs.f; |
| for(int i=0;i<16;i++) |
| { |
| (*lptr++) += (*rptr++); |
| } |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @brief element by element subtraction and assignment operator. |
| @param[in] rhs another PVRTMat4 |
| @return result of subtraction and assignment |
| *****************************************************************************/ |
| PVRTMat4& operator-=(const PVRTMat4& rhs) |
| { |
| VERTTYPE *lptr = f; |
| VERTTYPE const *rptr = rhs.f; |
| for(int i=0;i<16;i++) |
| { |
| (*lptr++) -= (*rptr++); |
| } |
| return *this; |
| } |
| |
| |
| /*!*************************************************************************** |
| @brief Matrix multiplication and assignment of two 4x4 matrices. |
| @param[in] rhs another PVRTMat4 |
| @return result of multiplication and assignment |
| *****************************************************************************/ |
| PVRTMat4& operator*=(const PVRTMat4& rhs) |
| { |
| PVRTMat4 result; |
| // col 0 |
| result.f[0] = VERTTYPEMUL(f[0],rhs.f[0])+VERTTYPEMUL(f[4],rhs.f[1])+VERTTYPEMUL(f[8],rhs.f[2])+VERTTYPEMUL(f[12],rhs.f[3]); |
| result.f[1] = VERTTYPEMUL(f[1],rhs.f[0])+VERTTYPEMUL(f[5],rhs.f[1])+VERTTYPEMUL(f[9],rhs.f[2])+VERTTYPEMUL(f[13],rhs.f[3]); |
| result.f[2] = VERTTYPEMUL(f[2],rhs.f[0])+VERTTYPEMUL(f[6],rhs.f[1])+VERTTYPEMUL(f[10],rhs.f[2])+VERTTYPEMUL(f[14],rhs.f[3]); |
| result.f[3] = VERTTYPEMUL(f[3],rhs.f[0])+VERTTYPEMUL(f[7],rhs.f[1])+VERTTYPEMUL(f[11],rhs.f[2])+VERTTYPEMUL(f[15],rhs.f[3]); |
| |
| // col 1 |
| result.f[4] = VERTTYPEMUL(f[0],rhs.f[4])+VERTTYPEMUL(f[4],rhs.f[5])+VERTTYPEMUL(f[8],rhs.f[6])+VERTTYPEMUL(f[12],rhs.f[7]); |
| result.f[5] = VERTTYPEMUL(f[1],rhs.f[4])+VERTTYPEMUL(f[5],rhs.f[5])+VERTTYPEMUL(f[9],rhs.f[6])+VERTTYPEMUL(f[13],rhs.f[7]); |
| result.f[6] = VERTTYPEMUL(f[2],rhs.f[4])+VERTTYPEMUL(f[6],rhs.f[5])+VERTTYPEMUL(f[10],rhs.f[6])+VERTTYPEMUL(f[14],rhs.f[7]); |
| result.f[7] = VERTTYPEMUL(f[3],rhs.f[4])+VERTTYPEMUL(f[7],rhs.f[5])+VERTTYPEMUL(f[11],rhs.f[6])+VERTTYPEMUL(f[15],rhs.f[7]); |
| |
| // col 2 |
| result.f[8] = VERTTYPEMUL(f[0],rhs.f[8])+VERTTYPEMUL(f[4],rhs.f[9])+VERTTYPEMUL(f[8],rhs.f[10])+VERTTYPEMUL(f[12],rhs.f[11]); |
| result.f[9] = VERTTYPEMUL(f[1],rhs.f[8])+VERTTYPEMUL(f[5],rhs.f[9])+VERTTYPEMUL(f[9],rhs.f[10])+VERTTYPEMUL(f[13],rhs.f[11]); |
| result.f[10] = VERTTYPEMUL(f[2],rhs.f[8])+VERTTYPEMUL(f[6],rhs.f[9])+VERTTYPEMUL(f[10],rhs.f[10])+VERTTYPEMUL(f[14],rhs.f[11]); |
| result.f[11] = VERTTYPEMUL(f[3],rhs.f[8])+VERTTYPEMUL(f[7],rhs.f[9])+VERTTYPEMUL(f[11],rhs.f[10])+VERTTYPEMUL(f[15],rhs.f[11]); |
| |
| // col 3 |
| result.f[12] = VERTTYPEMUL(f[0],rhs.f[12])+VERTTYPEMUL(f[4],rhs.f[13])+VERTTYPEMUL(f[8],rhs.f[14])+VERTTYPEMUL(f[12],rhs.f[15]); |
| result.f[13] = VERTTYPEMUL(f[1],rhs.f[12])+VERTTYPEMUL(f[5],rhs.f[13])+VERTTYPEMUL(f[9],rhs.f[14])+VERTTYPEMUL(f[13],rhs.f[15]); |
| result.f[14] = VERTTYPEMUL(f[2],rhs.f[12])+VERTTYPEMUL(f[6],rhs.f[13])+VERTTYPEMUL(f[10],rhs.f[14])+VERTTYPEMUL(f[14],rhs.f[15]); |
| result.f[15] = VERTTYPEMUL(f[3],rhs.f[12])+VERTTYPEMUL(f[7],rhs.f[13])+VERTTYPEMUL(f[11],rhs.f[14])+VERTTYPEMUL(f[15],rhs.f[15]); |
| |
| *this = result; |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @brief element multiplication by a single value. |
| @param[in] rhs A single value |
| @return result of multiplication and assignment |
| *****************************************************************************/ |
| PVRTMat4& operator*(const VERTTYPE rhs) |
| { |
| for (int i=0; i<16; ++i) |
| { |
| f[i]*=rhs; |
| } |
| return *this; |
| } |
| /*!*************************************************************************** |
| @brief element multiplication and assignment by a single value. |
| @param[in] rhs A single value |
| @return result of multiplication and assignment |
| *****************************************************************************/ |
| PVRTMat4& operator*=(const VERTTYPE rhs) |
| { |
| for (int i=0; i<16; ++i) |
| { |
| f[i]*=rhs; |
| } |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @brief element assignment operator. |
| @param[in] rhs another PVRTMat4 |
| @return result of assignment |
| *****************************************************************************/ |
| PVRTMat4& operator=(const PVRTMat4& rhs) |
| { |
| for (int i=0; i<16; ++i) |
| { |
| f[i] =rhs.f[i]; |
| } |
| return *this; |
| } |
| /*!*************************************************************************** |
| @brief Matrix multiplication of 4x4 matrix and vec3 |
| @param[in] rhs a PVRTVec4 |
| @return result of multiplication |
| *****************************************************************************/ |
| PVRTVec4 operator*(const PVRTVec4& rhs) const |
| { |
| PVRTVec4 out; |
| out.x = VERTTYPEMUL(rhs.x,f[0])+VERTTYPEMUL(rhs.y,f[4])+VERTTYPEMUL(rhs.z,f[8])+VERTTYPEMUL(rhs.w,f[12]); |
| out.y = VERTTYPEMUL(rhs.x,f[1])+VERTTYPEMUL(rhs.y,f[5])+VERTTYPEMUL(rhs.z,f[9])+VERTTYPEMUL(rhs.w,f[13]); |
| out.z = VERTTYPEMUL(rhs.x,f[2])+VERTTYPEMUL(rhs.y,f[6])+VERTTYPEMUL(rhs.z,f[10])+VERTTYPEMUL(rhs.w,f[14]); |
| out.w = VERTTYPEMUL(rhs.x,f[3])+VERTTYPEMUL(rhs.y,f[7])+VERTTYPEMUL(rhs.z,f[11])+VERTTYPEMUL(rhs.w,f[15]); |
| |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @brief Matrix multiplication and assignment of 4x4 matrix and vec3 |
| @param[in] rhs a PVRTVec4 |
| @return result of multiplication and assignment |
| *****************************************************************************/ |
| PVRTVec4 operator*=(const PVRTVec4& rhs) const |
| { |
| PVRTVec4 out; |
| out.x = VERTTYPEMUL(rhs.x,f[0])+VERTTYPEMUL(rhs.y,f[4])+VERTTYPEMUL(rhs.z,f[8])+VERTTYPEMUL(rhs.w,f[12]); |
| out.y = VERTTYPEMUL(rhs.x,f[1])+VERTTYPEMUL(rhs.y,f[5])+VERTTYPEMUL(rhs.z,f[9])+VERTTYPEMUL(rhs.w,f[13]); |
| out.z = VERTTYPEMUL(rhs.x,f[2])+VERTTYPEMUL(rhs.y,f[6])+VERTTYPEMUL(rhs.z,f[10])+VERTTYPEMUL(rhs.w,f[14]); |
| out.w = VERTTYPEMUL(rhs.x,f[3])+VERTTYPEMUL(rhs.y,f[7])+VERTTYPEMUL(rhs.z,f[11])+VERTTYPEMUL(rhs.w,f[15]); |
| |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @brief Calculates multiplicative inverse of this matrix |
| The matrix must be of the form : |
| A 0 |
| C 1 |
| Where A is a 3x3 matrix and C is a 1x3 matrix. |
| @return inverse mat4 |
| *****************************************************************************/ |
| PVRTMat4 inverse() const; |
| |
| /*!*************************************************************************** |
| @fn inverseEx |
| @return inverse mat4 |
| @brief Calculates multiplicative inverse of this matrix |
| Uses a linear equation solver and the knowledge that M.M^-1=I. |
| Use this fn to calculate the inverse of matrices that |
| inverse() cannot. |
| *****************************************************************************/ |
| PVRTMat4 inverseEx() const |
| { |
| PVRTMat4 out; |
| VERTTYPE *ppRows[4]; |
| VERTTYPE pRes[4]; |
| VERTTYPE pIn[20]; |
| int i, j; |
| |
| for(i = 0; i < 4; ++i) |
| ppRows[i] = &pIn[i * 5]; |
| |
| /* Solve 4 sets of 4 linear equations */ |
| for(i = 0; i < 4; ++i) |
| { |
| for(j = 0; j < 4; ++j) |
| { |
| ppRows[j][0] = PVRTMat4::Identity().f[i + 4 * j]; |
| memcpy(&ppRows[j][1], &f[j * 4], 4 * sizeof(VERTTYPE)); |
| } |
| |
| PVRTLinearEqSolve(pRes, (VERTTYPE**)ppRows, 4); |
| |
| for(j = 0; j < 4; ++j) |
| { |
| out.f[i + 4 * j] = pRes[j]; |
| } |
| } |
| |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @fn transpose |
| @return transpose mat4 |
| @brief Calculates transpose of this matrix |
| *****************************************************************************/ |
| PVRTMat4 transpose() const |
| { |
| PVRTMat4 out; |
| out.f[0] = f[0]; out.f[1] = f[4]; out.f[2] = f[8]; out.f[3] = f[12]; |
| out.f[4] = f[1]; out.f[5] = f[5]; out.f[6] = f[9]; out.f[7] = f[13]; |
| out.f[8] = f[2]; out.f[9] = f[6]; out.f[10] = f[10]; out.f[11] = f[14]; |
| out.f[12] = f[3]; out.f[13] = f[7]; out.f[14] = f[11]; out.f[15] = f[15]; |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @brief Alters the translation component of the transformation matrix. |
| @param[in] tx Distance of translation in x axis |
| @param[in] ty Distance of translation in y axis |
| @param[in] tz Distance of translation in z axis |
| @return Returns this |
| *****************************************************************************/ |
| PVRTMat4& postTranslate(VERTTYPE tx, VERTTYPE ty, VERTTYPE tz) |
| { |
| f[12] += VERTTYPEMUL(tx,f[0])+VERTTYPEMUL(ty,f[4])+VERTTYPEMUL(tz,f[8]); |
| f[13] += VERTTYPEMUL(tx,f[1])+VERTTYPEMUL(ty,f[5])+VERTTYPEMUL(tz,f[9]); |
| f[14] += VERTTYPEMUL(tx,f[2])+VERTTYPEMUL(ty,f[6])+VERTTYPEMUL(tz,f[10]); |
| f[15] += VERTTYPEMUL(tx,f[3])+VERTTYPEMUL(ty,f[7])+VERTTYPEMUL(tz,f[11]); |
| |
| // col(3) += tx * col(0) + ty * col(1) + tz * col(2); |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @brief Alters the translation component of the transformation matrix. |
| @param[in] tvec Translation vector |
| @return Returns this |
| *****************************************************************************/ |
| PVRTMat4& postTranslate(const PVRTVec3& tvec) |
| { |
| return postTranslate(tvec.x, tvec.y, tvec.z); |
| } |
| |
| /*!*************************************************************************** |
| @brief Translates the matrix from the passed parameters |
| @param[in] tx Distance of translation in x axis |
| @param[in] ty Distance of translation in y axis |
| @param[in] tz Distance of translation in z axis |
| @return Returns this |
| *****************************************************************************/ |
| PVRTMat4& preTranslate(VERTTYPE tx, VERTTYPE ty, VERTTYPE tz) |
| { |
| f[0]+=VERTTYPEMUL(f[3],tx); f[4]+=VERTTYPEMUL(f[7],tx); f[8]+=VERTTYPEMUL(f[11],tx); f[12]+=VERTTYPEMUL(f[15],tx); |
| f[1]+=VERTTYPEMUL(f[3],ty); f[5]+=VERTTYPEMUL(f[7],ty); f[9]+=VERTTYPEMUL(f[11],ty); f[13]+=VERTTYPEMUL(f[15],ty); |
| f[2]+=VERTTYPEMUL(f[3],tz); f[6]+=VERTTYPEMUL(f[7],tz); f[10]+=VERTTYPEMUL(f[11],tz); f[14]+=VERTTYPEMUL(f[15],tz); |
| |
| // row(0) += tx * row(3); |
| // row(1) += ty * row(3); |
| // row(2) += tz * row(3); |
| return *this; |
| } |
| |
| /*!*************************************************************************** |
| @brief Translates the matrix from the passed parameters |
| @param[in] tvec Translation vector |
| @return Returns the translation defined by the passed parameters |
| *****************************************************************************/ |
| PVRTMat4& preTranslate(const PVRTVec3& tvec) |
| { |
| return preTranslate(tvec.x, tvec.y, tvec.z); |
| } |
| /*!*************************************************************************** |
| @brief Calculates transpose of this matrix |
| @return pointer to an array of the elements of this PVRTMat4 |
| *****************************************************************************/ |
| VERTTYPE *ptr() { return (VERTTYPE*)&f; } |
| |
| /*!*************************************************************************** |
| ** Static factory functions |
| *****************************************************************************/ |
| /*!*************************************************************************** |
| @brief Generates an identity matrix |
| @return a PVRTMat4 representation of the 4x4 identity matrix |
| *****************************************************************************/ |
| static PVRTMat4 Identity() |
| { |
| PVRTMat4 out; |
| out.f[0] = f2vt(1);out.f[1] = 0;out.f[2] = 0;out.f[3] = 0; |
| out.f[4] = 0;out.f[5] = f2vt(1);out.f[6] = 0;out.f[7] = 0; |
| out.f[8] = 0;out.f[9] = 0;out.f[10] = f2vt(1);out.f[11] = 0; |
| out.f[12] = 0;out.f[13] = 0;out.f[14] = 0;out.f[15] = f2vt(1); |
| return out; |
| } |
| |
| /*!*************************************************************************** |
| @fn RotationX |
| @return a PVRTMat3 corresponding to the requested rotation |
| @brief Calculates a matrix corresponding to a rotation of angle |
| degrees about the X axis |
| *****************************************************************************/ |
| static PVRTMat4 RotationX(VERTTYPE angle); |
| /*!*************************************************************************** |
| @fn RotationY |
| @return a PVRTMat3 corresponding to the requested rotation |
| @brief Calculates a matrix corresponding to a rotation of angle |
| degrees about the Y axis |
| *****************************************************************************/ |
| static PVRTMat4 RotationY(VERTTYPE angle); |
| /*!*************************************************************************** |
| @fn RotationZ |
| @return a PVRTMat3 corresponding to the requested rotation |
| @brief Calculates a matrix corresponding to a rotation of angle |
| degrees about the Z axis |
| *****************************************************************************/ |
| static PVRTMat4 RotationZ(VERTTYPE angle); |
| |
| /*!*************************************************************************** |
| @brief Calculates a matrix corresponding to scaling of fx, fy and fz |
| times in each axis. |
| @return a PVRTMat3 corresponding to the requested scaling transformation |
| *****************************************************************************/ |
| static PVRTMat4 Scale(const VERTTYPE fx,const VERTTYPE fy,const VERTTYPE fz) |
| { |
| return PVRTMat4(fx,0,0,0, |
| 0,fy,0,0, |
| 0,0,fz,0, |
| 0,0,0,f2vt(1)); |
| } |
| |
| /*!*************************************************************************** |
| @brief Calculates a matrix corresponding to scaling of the given vector. |
| @return a PVRTMat3 corresponding to the requested scaling transformation |
| *****************************************************************************/ |
| static PVRTMat4 Scale(const PVRTVec3& vec) |
| { |
| return Scale(vec.x, vec.y, vec.z); |
| } |
| |
| /*!*************************************************************************** |
| @brief Calculates a 4x4 matrix corresponding to a transformation |
| of tx, ty and tz distance in each axis. |
| @return a PVRTMat4 corresponding to the requested translation |
| *****************************************************************************/ |
| static PVRTMat4 Translation(const VERTTYPE tx, const VERTTYPE ty, const VERTTYPE tz) |
| { |
| return PVRTMat4(f2vt(1),0,0,0, |
| 0,f2vt(1),0,0, |
| 0,0,f2vt(1),0, |
| tx,ty,tz,f2vt(1)); |
| } |
| |
| /*!*************************************************************************** |
| @brief Calculates a 4x4 matrix corresponding to a transformation |
| of tx, ty and tz distance in each axis as taken from the |
| given vector. |
| @return a PVRTMat4 corresponding to the requested translation |
| *****************************************************************************/ |
| |
| static PVRTMat4 Translation(const PVRTVec3& vec) |
| { |
| return Translation(vec.x, vec.y, vec.z); |
| } |
| |
| /*!*************************************************************************** |
| ** Clipspace enum |
| ** Determines whether clip space Z ranges from -1 to 1 (OGL) or from 0 to 1 (D3D) |
| *****************************************************************************/ |
| enum eClipspace { OGL, D3D }; |
| |
| /*!*************************************************************************** |
| @brief Translates the matrix from the passed parameters |
| @param[in] left Left view plane |
| @param[in] top Top view plane |
| @param[in] right Right view plane |
| @param[in] bottom Bottom view plane |
| @param[in] nearPlane The near rendering plane |
| @param[in] farPlane The far rendering plane |
| @param[in] cs Which clipspace convention is being used |
| @param[in] bRotate Is the viewport in portrait or landscape mode |
| @return Returns the orthogonal projection matrix defined by the passed parameters |
| *****************************************************************************/ |
| static PVRTMat4 Ortho(VERTTYPE left, VERTTYPE top, VERTTYPE right, |
| VERTTYPE bottom, VERTTYPE nearPlane, VERTTYPE farPlane, const eClipspace cs, bool bRotate = false) |
| { |
| VERTTYPE rcplmr = VERTTYPEDIV(VERTTYPE(1),(left - right)); |
| VERTTYPE rcpbmt = VERTTYPEDIV(VERTTYPE(1),(bottom - top)); |
| VERTTYPE rcpnmf = VERTTYPEDIV(VERTTYPE(1),(nearPlane - farPlane)); |
| |
| PVRTMat4 result; |
| |
| if (bRotate) |
| { |
| result.f[0]=0; result.f[4]=VERTTYPEMUL(2,rcplmr); result.f[8]=0; result.f[12]=VERTTYPEMUL(-(right+left),rcplmr); |
| result.f[1]=VERTTYPEMUL(-2,rcpbmt); result.f[5]=0; result.f[9]=0; result.f[13]=VERTTYPEMUL((top+bottom),rcpbmt); |
| } |
| else |
| { |
| result.f[0]=VERTTYPEMUL(-2,rcplmr); result.f[4]=0; result.f[8]=0; result.f[12]=VERTTYPEMUL(right+left,rcplmr); |
| result.f[1]=0; result.f[5]=VERTTYPEMUL(-2,rcpbmt); result.f[9]=0; result.f[13]=VERTTYPEMUL((top+bottom),rcpbmt); |
| } |
| if (cs == D3D) |
| { |
| result.f[2]=0; result.f[6]=0; result.f[10]=-rcpnmf; result.f[14]=VERTTYPEMUL(nearPlane,rcpnmf); |
| } |
| else |
| { |
| result.f[2]=0; result.f[6]=0; result.f[10]=VERTTYPEMUL(-2,rcpnmf); result.f[14]=VERTTYPEMUL(nearPlane + farPlane,rcpnmf); |
| } |
| result.f[3]=0; result.f[7]=0; result.f[11]=0; result.f[15]=1; |
| |
| return result; |
| } |
| |
| /*!*************************************************************************** |
| @fn LookAtRH |
| @param[in] vEye position of 'camera' |
| @param[in] vAt target that camera points at |
| @param[in] vUp up vector for camera |
| @return Returns the view matrix defined by the passed parameters |
| @brief Create a look-at view matrix for a right hand coordinate |
| system |
| *****************************************************************************/ |
| static PVRTMat4 LookAtRH(const PVRTVec3& vEye, const PVRTVec3& vAt, const PVRTVec3& vUp) |
| { return LookAt(vEye, vAt, vUp, true); } |
| /*!*************************************************************************** |
| @fn LookAtLH |
| @param[in] vEye position of 'camera' |
| @param[in] vAt target that camera points at |
| @param[in] vUp up vector for camera |
| @return Returns the view matrix defined by the passed parameters |
| @brief Create a look-at view matrix for a left hand coordinate |
| system |
| *****************************************************************************/ |
| static PVRTMat4 LookAtLH(const PVRTVec3& vEye, const PVRTVec3& vAt, const PVRTVec3& vUp) |
| { return LookAt(vEye, vAt, vUp, false); } |
| |
| /*!*************************************************************************** |
| @brief Create a perspective matrix for a right hand coordinate |
| system |
| @param[in] width width of viewplane |
| @param[in] height height of viewplane |
| @param[in] nearPlane near clipping distance |
| @param[in] farPlane far clipping distance |
| @param[in] cs cs which clipspace convention is being used |
| @param[in] bRotate is the viewport in portrait or landscape mode |
| @return Perspective matrix |
| *****************************************************************************/ |
| static PVRTMat4 PerspectiveRH(VERTTYPE width, VERTTYPE height, VERTTYPE nearPlane, |
| VERTTYPE farPlane, const eClipspace cs, bool bRotate = false) |
| { return Perspective(width, height, nearPlane, farPlane, cs, true, bRotate); } |
| |
| /*!*************************************************************************** |
| @brief Create a perspective matrix for a left hand coordinate |
| system |
| @param[in] width width of viewplane |
| @param[in] height height of viewplane |
| @param[in] nearPlane near clipping distance |
| @param[in] farPlane far clipping distance |
| @param[in] cs cs which clipspace convention is being used |
| @param[in] bRotate is the viewport in portrait or landscape mode |
| @return Perspective matrix |
| *****************************************************************************/ |
| static PVRTMat4 PerspectiveLH(VERTTYPE width, VERTTYPE height, VERTTYPE nearPlane, VERTTYPE farPlane, const eClipspace cs, bool bRotate = false) |
| { return Perspective(width, height, nearPlane, farPlane, cs, false, bRotate); } |
| |
| /*!*************************************************************************** |
| @brief Create a perspective matrix for a right hand coordinate |
| system |
| @param[in] width width of viewplane |
| @param[in] height height of viewplane |
| @param[in] nearPlane near clipping distance |
| @param[in] cs cs which clipspace convention is being used |
| @param[in] bRotate is the viewport in portrait or landscape mode |
| @return Perspective matrix |
| *****************************************************************************/ |
| static PVRTMat4 PerspectiveFloatDepthRH(VERTTYPE width, VERTTYPE height, VERTTYPE nearPlane, const eClipspace cs, bool bRotate = false) |
| { return PerspectiveFloatDepth(width, height, nearPlane, cs, true, bRotate); } |
| |
| /*!*************************************************************************** |
| @brief Create a perspective matrix for a left hand coordinate |
| system |
| @param[in] width width of viewplane |
| @param[in] height height of viewplane |
| @param[in] nearPlane near clipping distance |
| @param[in] cs cs which clipspace convention is being used |
| @param[in] bRotate is the viewport in portrait or landscape mode |
| @return Perspective matrix |
| *****************************************************************************/ |
| static PVRTMat4 PerspectiveFloatDepthLH(VERTTYPE width, VERTTYPE height, VERTTYPE nearPlane, const eClipspace cs, bool bRotate = false) |
| { return PerspectiveFloatDepth(width, height, nearPlane, cs, false, bRotate); } |
| |
| /*!*************************************************************************** |
| @brief Create a perspective matrix for a right hand coordinate |
| system |
| @param[in] fovy angle of view (vertical) |
| @param[in] aspect aspect ratio of view |
| @param[in] nearPlane near clipping distance |
| @param[in] farPlane far clipping distance |
| @param[in] cs cs which clipspace convention is being used |
| @param[in] bRotate is the viewport in portrait or landscape mode |
| @return Perspective matrix |
| *****************************************************************************/ |
| static PVRTMat4 PerspectiveFovRH(VERTTYPE fovy, VERTTYPE aspect, VERTTYPE nearPlane, VERTTYPE farPlane, const eClipspace cs, bool bRotate = false) |
| { return PerspectiveFov(fovy, aspect, nearPlane, farPlane, cs, true, bRotate); } |
| /*!*************************************************************************** |
| @brief Create a perspective matrix for a left hand coordinate |
| system |
| @param[in] fovy angle of view (vertical) |
| @param[in] aspect aspect ratio of view |
| @param[in] nearPlane near clipping distance |
| @param[in] farPlane far clipping distance |
| @param[in] cs cs which clipspace convention is being used |
| @param[in] bRotate is the viewport in portrait or landscape mode |
| @return Perspective matrix |
| *****************************************************************************/ |
| static PVRTMat4 PerspectiveFovLH(VERTTYPE fovy, VERTTYPE aspect, VERTTYPE nearPlane, VERTTYPE farPlane, const eClipspace cs, bool bRotate = false) |
| { return PerspectiveFov(fovy, aspect, nearPlane, farPlane, cs, false, bRotate); } |
| |
| /*!*************************************************************************** |
| @brief Create a perspective matrix for a right hand coordinate |
| system |
| @param[in] fovy angle of view (vertical) |
| @param[in] aspect aspect ratio of view |
| @param[in] nearPlane near clipping distance |
| @param[in] cs cs which clipspace convention is being used |
| @param[in] bRotate is the viewport in portrait or landscape mode |
| @return Perspective matrix |
| *****************************************************************************/ |
| static PVRTMat4 PerspectiveFovFloatDepthRH(VERTTYPE fovy, VERTTYPE aspect, VERTTYPE nearPlane, const eClipspace cs, bool bRotate = false) |
| { return PerspectiveFovFloatDepth(fovy, aspect, nearPlane, cs, true, bRotate); } |
| /*!*************************************************************************** |
| @brief Create a perspective matrix for a left hand coordinate |
| system |
| @param[in] fovy angle of view (vertical) |
| @param[in] aspect aspect ratio of view |
| @param[in] nearPlane near clipping distance |
| @param[in] cs cs which clipspace convention is being used |
| @param[in] bRotate is the viewport in portrait or landscape mode |
| @return Perspective matrix |
| *****************************************************************************/ |
| static PVRTMat4 PerspectiveFovFloatDepthLH(VERTTYPE fovy, VERTTYPE aspect, VERTTYPE nearPlane, const eClipspace cs, bool bRotate = false) |
| { return PerspectiveFovFloatDepth(fovy, aspect, nearPlane, cs, false, bRotate); } |
| |
| /*!*************************************************************************** |
| @brief Create a look-at view matrix |
| @param[in] vEye Position of 'camera' |
| @param[in] vAt Target that camera points at |
| @param[in] vUp Up vector for camera |
| @param[in] bRightHanded Handedness of coordinate system |
| @return Returns the view matrix defined by the passed parameters |
| *****************************************************************************/ |
| static PVRTMat4 LookAt(const PVRTVec3& vEye, const PVRTVec3& vAt, const PVRTVec3& vUp, bool bRightHanded) |
| { |
| PVRTVec3 vForward, vUpNorm, vSide; |
| PVRTMat4 result; |
| |
| vForward = (bRightHanded) ? vEye - vAt : vAt - vEye; |
| |
| vForward.normalize(); |
| vSide = vUp.cross( vForward); |
| vSide = vSide.normalized(); |
| vUpNorm = vForward.cross(vSide); |
| vUpNorm = vUpNorm.normalized(); |
| |
| result.f[0]=vSide.x; result.f[4]=vSide.y; result.f[8]=vSide.z; result.f[12]=0; |
| result.f[1]=vUpNorm.x; result.f[5]=vUpNorm.y; result.f[9]=vUpNorm.z; result.f[13]=0; |
| result.f[2]=vForward.x; result.f[6]=vForward.y; result.f[10]=vForward.z; result.f[14]=0; |
| result.f[3]=0; result.f[7]=0; result.f[11]=0; result.f[15]=f2vt(1); |
| |
| |
| result.postTranslate(-vEye); |
| return result; |
| } |
| |
| /*!*************************************************************************** |
| @brief Create a perspective matrix |
| @param[in] width Width of viewplane |
| @param[in] height Height of viewplane |
| @param[in] nearPlane Near clipping distance |
| @param[in] farPlane Far clipping distance |
| @param[in] cs Which clipspace convention is being used |
| @param[in] bRightHanded Handedness of coordinate system |
| @param[in] bRotate Is the viewport in portrait or landscape mode |
| @return Perspective matrix |
| *****************************************************************************/ |
| static PVRTMat4 Perspective( |
| VERTTYPE width, VERTTYPE height, |
| VERTTYPE nearPlane, VERTTYPE farPlane, |
| const eClipspace cs, |
| bool bRightHanded, |
| bool bRotate = false) |
| { |
| VERTTYPE n2 = VERTTYPEMUL(f2vt(2),nearPlane); |
| VERTTYPE rcpnmf = VERTTYPEDIV(f2vt(1),(nearPlane - farPlane)); |
| |
| PVRTMat4 result; |
| if (bRotate) |
| { |
| result.f[0] = 0; result.f[4]=VERTTYPEDIV(-n2,width); result.f[8]=0; result.f[12]=0; |
| result.f[1] = VERTTYPEDIV(n2,height); result.f[5]=0; result.f[9]=0; result.f[13]=0; |
| } |
| else |
| { |
| result.f[0] = VERTTYPEDIV(n2,width); result.f[4]=0; result.f[8]=0; result.f[12]=0; |
| result.f[1] = 0; result.f[5]=VERTTYPEDIV(n2,height); result.f[9]=0; result.f[13]=0; |
| } |
| if (cs == D3D) |
| { |
| result.f[2] = 0; result.f[6]=0; result.f[10]=VERTTYPEMUL(farPlane,rcpnmf); result.f[14]=VERTTYPEMUL(VERTTYPEMUL(farPlane,rcpnmf),nearPlane); |
| } |
| else |
| { |
| result.f[2] = 0; result.f[6]=0; result.f[10]=VERTTYPEMUL(farPlane+nearPlane,rcpnmf); result.f[14]=VERTTYPEMUL(VERTTYPEMUL(farPlane,rcpnmf),n2); |
| } |
| result.f[3] = 0; result.f[7]=0; result.f[11]=f2vt(-1); result.f[15]=0; |
| |
| if (!bRightHanded) |
| { |
| result.f[10] = VERTTYPEMUL(result.f[10], f2vt(-1)); |
| result.f[11] = f2vt(1); |
| } |
| |
| return result; |
| } |
| |
| /*!*************************************************************************** |
| @brief Perspective calculation where far plane is assumed to be at an infinite distance and the screen |
| space Z is inverted |
| @param[in] width Width of viewplane |
| @param[in] height Height of viewplane |
| @param[in] nearPlane Near clipping distance |
| @param[in] cs Which clipspace convention is being used |
| @param[in] bRightHanded Handedness of coordinate system |
| @param[in] bRotate Is the viewport in portrait or landscape mode |
| @return Perspective matrix |
| *****************************************************************************/ |
| static PVRTMat4 PerspectiveFloatDepth( |
| VERTTYPE width, VERTTYPE height, |
| VERTTYPE nearPlane, |
| const eClipspace cs, |
| bool bRightHanded, |
| bool bRotate = false) |
| { |
| VERTTYPE n2 = VERTTYPEMUL(2,nearPlane); |
| |
| PVRTMat4 result; |
| if (bRotate) |
| { |
| result.f[0] = 0; result.f[4]=VERTTYPEDIV(-n2,width); result.f[8]=0; result.f[12]=0; |
| result.f[1] = VERTTYPEDIV(n2,height); result.f[5]=0; result.f[9]=0; result.f[13]=0; |
| } |
| else |
| { |
| result.f[0] = VERTTYPEDIV(n2,width); result.f[4]=0; result.f[8]=0; result.f[12]=0; |
| result.f[1] = 0; result.f[5]=VERTTYPEDIV(n2,height); result.f[9]=0; result.f[13]=0; |
| } |
| if (cs == D3D) |
| { |
| result.f[2] = 0; result.f[6]=0; result.f[10]=0; result.f[14]=nearPlane; |
| } |
| else |
| { |
| result.f[2] = 0; result.f[6]=0; result.f[10]=(bRightHanded?(VERTTYPE)1:(VERTTYPE)-1); result.f[14]=n2; |
| } |
| result.f[3] = (VERTTYPE)0; result.f[7]=(VERTTYPE)0; result.f[11]= (bRightHanded?(VERTTYPE)-1:(VERTTYPE)1); result.f[15]=(VERTTYPE)0; |
| |
| return result; |
| } |
| |
| /*!*************************************************************************** |
| @brief Perspective calculation where field of view is used instead of near plane dimensions |
| @param[in] fovy Angle of view (vertical) |
| @param[in] aspect Aspect ratio of view |
| @param[in] nearPlane Near clipping distance |
| @param[in] farPlane Far clipping distance |
| @param[in] cs Which clipspace convention is being used |
| @param[in] bRightHanded Handedness of coordinate system |
| @param[in] bRotate Is the viewport in portrait or landscape mode |
| @return Perspective matrix |
| *****************************************************************************/ |
| static PVRTMat4 PerspectiveFov( |
| VERTTYPE fovy, VERTTYPE aspect, |
| VERTTYPE nearPlane, VERTTYPE farPlane, |
| const eClipspace cs, |
| bool bRightHanded, |
| bool bRotate = false) |
| { |
| VERTTYPE height = VERTTYPEMUL(VERTTYPEMUL(f2vt(2.0f),nearPlane),PVRTTAN(VERTTYPEMUL(fovy,f2vt(0.5f)))); |
| if (bRotate) return Perspective(height, VERTTYPEDIV(height,aspect), nearPlane, farPlane, cs, bRightHanded, bRotate); |
| return Perspective(VERTTYPEMUL(height,aspect), height, nearPlane, farPlane, cs, bRightHanded, bRotate); |
| } |
| |
| /*!*************************************************************************** |
| @brief Perspective calculation where field of view is used instead of near plane dimensions |
| and far plane is assumed to be at an infinite distance with inverted Z range |
| @param[in] fovy Angle of view (vertical) |
| @param[in] aspect Aspect ratio of view |
| @param[in] nearPlane Near clipping distance |
| @param[in] cs Which clipspace convention is being used |
| @param[in] bRightHanded Handedness of coordinate system |
| @param[in] bRotate Is the viewport in portrait or landscape mode |
| @return Perspective matrix |
| *****************************************************************************/ |
| static PVRTMat4 PerspectiveFovFloatDepth( |
| VERTTYPE fovy, VERTTYPE aspect, |
| VERTTYPE nearPlane, |
| const eClipspace cs, |
| bool bRightHanded, |
| bool bRotate = false) |
| { |
| VERTTYPE height = VERTTYPEMUL(VERTTYPEMUL(2,nearPlane), PVRTTAN(VERTTYPEMUL(fovy,0.5))); |
| if (bRotate) return PerspectiveFloatDepth(height, VERTTYPEDIV(height,aspect), nearPlane, cs, bRightHanded, bRotate); |
| return PerspectiveFloatDepth(VERTTYPEMUL(height,aspect), height, nearPlane, cs, bRightHanded, bRotate); |
| } |
| }; |
| |
| #endif /*__PVRTVECTOR_H__*/ |
| |
| /***************************************************************************** |
| End of file (PVRTVector.h) |
| *****************************************************************************/ |
| |