HELLO·Android
系统源代码
IT资讯
技术文章
我的收藏
注册
登录
-
我收藏的文章
创建代码块
我的代码块
我的账号
Android 10
|
10.0.0_r6
下载
查看原文件
收藏
根目录
external
swiftshader
third_party
PowerVR_SDK
Tools
PVRTVector.h
/*!**************************************************************************** @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) *****************************************************************************/
C++程序
|
2211行
|
86.28 KB
原始内容
高亮显示
复制内容
×
已收藏
收藏成功,您可以在我收藏的代码页面中查看,其地址为:
https://www.androidos.net.cn/my/collect/code
。
登录后可以享受更多权益
您还没有登录，登录后您可以：
收藏Android系统代码
收藏喜欢的文章
多个平台共享账号
去登录
首次使用？从这里
注册