/*!****************************************************************************
|
|
@file PVRTMatrix.h
|
@copyright Copyright (c) Imagination Technologies Limited.
|
@brief Vector and Matrix functions for floating and fixed point math.
|
@details The general matrix format used is directly compatible with, for
|
example, both DirectX and OpenGL.
|
|
******************************************************************************/
|
#ifndef _PVRTMATRIX_H_
|
#define _PVRTMATRIX_H_
|
|
#include "PVRTGlobal.h"
|
/****************************************************************************
|
** Defines
|
****************************************************************************/
|
#define MAT00 0
|
#define MAT01 1
|
#define MAT02 2
|
#define MAT03 3
|
#define MAT10 4
|
#define MAT11 5
|
#define MAT12 6
|
#define MAT13 7
|
#define MAT20 8
|
#define MAT21 9
|
#define MAT22 10
|
#define MAT23 11
|
#define MAT30 12
|
#define MAT31 13
|
#define MAT32 14
|
#define MAT33 15
|
|
/****************************************************************************
|
** Typedefs
|
****************************************************************************/
|
/*!***************************************************************************
|
@brief 2D floating point vector
|
*****************************************************************************/
|
typedef struct
|
{
|
float x; /*!< x coordinate */
|
float y; /*!< y coordinate */
|
} PVRTVECTOR2f;
|
|
/*!***************************************************************************
|
@brief 2D fixed point vector
|
*****************************************************************************/
|
typedef struct
|
{
|
int x; /*!< x coordinate */
|
int y; /*!< y coordinate */
|
} PVRTVECTOR2x;
|
|
/*!***************************************************************************
|
@brief 3D floating point vector
|
*****************************************************************************/
|
typedef struct
|
{
|
float x; /*!< x coordinate */
|
float y; /*!< y coordinate */
|
float z; /*!< z coordinate */
|
} PVRTVECTOR3f;
|
|
/*!***************************************************************************
|
@brief 3D fixed point vector
|
*****************************************************************************/
|
typedef struct
|
{
|
int x; /*!< x coordinate */
|
int y; /*!< y coordinate */
|
int z; /*!< z coordinate */
|
} PVRTVECTOR3x;
|
|
/*!***************************************************************************
|
@brief 4D floating point vector
|
*****************************************************************************/
|
typedef struct
|
{
|
float x; /*!< x coordinate */
|
float y; /*!< y coordinate */
|
float z; /*!< z coordinate */
|
float w; /*!< w coordinate */
|
} PVRTVECTOR4f;
|
|
/*!***************************************************************************
|
@brief 4D fixed point vector
|
*****************************************************************************/
|
typedef struct
|
{
|
int x; /*!< x coordinate */
|
int y; /*!< y coordinate */
|
int z; /*!< z coordinate */
|
int w; /*!< w coordinate */
|
} PVRTVECTOR4x;
|
|
/*!***************************************************************************
|
@class PVRTMATRIXf
|
@brief 4x4 floating point matrix
|
*****************************************************************************/
|
class PVRTMATRIXf
|
{
|
public:
|
float* operator [] ( const int Row )
|
{
|
return &f[Row<<2];
|
}
|
float f[16]; /*!< Array of float */
|
};
|
|
/*!***************************************************************************
|
@class PVRTMATRIXx
|
@brief 4x4 fixed point matrix
|
*****************************************************************************/
|
class PVRTMATRIXx
|
{
|
public:
|
int* operator [] ( const int Row )
|
{
|
return &f[Row<<2];
|
}
|
int f[16];
|
};
|
|
/*!***************************************************************************
|
@class PVRTMATRIX3f
|
@brief 3x3 floating point matrix
|
*****************************************************************************/
|
|
class PVRTMATRIX3f
|
{
|
public:
|
float* operator [] ( const int Row )
|
{
|
return &f[Row*3];
|
}
|
float f[9]; /*!< Array of float */
|
};
|
|
/*!***************************************************************************
|
@class PVRTMATRIX3x
|
@brief 3x3 fixed point matrix
|
*****************************************************************************/
|
class PVRTMATRIX3x
|
{
|
public:
|
int* operator [] ( const int Row )
|
{
|
return &f[Row*3];
|
}
|
int f[9];
|
};
|
|
|
/****************************************************************************
|
** Float or fixed
|
****************************************************************************/
|
#ifdef PVRT_FIXED_POINT_ENABLE
|
typedef PVRTVECTOR2x PVRTVECTOR2;
|
typedef PVRTVECTOR3x PVRTVECTOR3;
|
typedef PVRTVECTOR4x PVRTVECTOR4;
|
typedef PVRTMATRIX3x PVRTMATRIX3;
|
typedef PVRTMATRIXx PVRTMATRIX;
|
#define PVRTMatrixIdentity PVRTMatrixIdentityX
|
#define PVRTMatrixMultiply PVRTMatrixMultiplyX
|
#define PVRTMatrixTranslation PVRTMatrixTranslationX
|
#define PVRTMatrixScaling PVRTMatrixScalingX
|
#define PVRTMatrixRotationX PVRTMatrixRotationXX
|
#define PVRTMatrixRotationY PVRTMatrixRotationYX
|
#define PVRTMatrixRotationZ PVRTMatrixRotationZX
|
#define PVRTMatrixTranspose PVRTMatrixTransposeX
|
#define PVRTMatrixInverse PVRTMatrixInverseX
|
#define PVRTMatrixInverseEx PVRTMatrixInverseExX
|
#define PVRTMatrixLookAtLH PVRTMatrixLookAtLHX
|
#define PVRTMatrixLookAtRH PVRTMatrixLookAtRHX
|
#define PVRTMatrixPerspectiveFovLH PVRTMatrixPerspectiveFovLHX
|
#define PVRTMatrixPerspectiveFovRH PVRTMatrixPerspectiveFovRHX
|
#define PVRTMatrixOrthoLH PVRTMatrixOrthoLHX
|
#define PVRTMatrixOrthoRH PVRTMatrixOrthoRHX
|
#define PVRTMatrixVec3Lerp PVRTMatrixVec3LerpX
|
#define PVRTMatrixVec3DotProduct PVRTMatrixVec3DotProductX
|
#define PVRTMatrixVec3CrossProduct PVRTMatrixVec3CrossProductX
|
#define PVRTMatrixVec3Normalize PVRTMatrixVec3NormalizeX
|
#define PVRTMatrixVec3Length PVRTMatrixVec3LengthX
|
#define PVRTMatrixLinearEqSolve PVRTMatrixLinearEqSolveX
|
#else
|
typedef PVRTVECTOR2f PVRTVECTOR2;
|
typedef PVRTVECTOR3f PVRTVECTOR3;
|
typedef PVRTVECTOR4f PVRTVECTOR4;
|
typedef PVRTMATRIX3f PVRTMATRIX3;
|
typedef PVRTMATRIXf PVRTMATRIX;
|
#define PVRTMatrixIdentity PVRTMatrixIdentityF
|
#define PVRTMatrixMultiply PVRTMatrixMultiplyF
|
#define PVRTMatrixTranslation PVRTMatrixTranslationF
|
#define PVRTMatrixScaling PVRTMatrixScalingF
|
#define PVRTMatrixRotationX PVRTMatrixRotationXF
|
#define PVRTMatrixRotationY PVRTMatrixRotationYF
|
#define PVRTMatrixRotationZ PVRTMatrixRotationZF
|
#define PVRTMatrixTranspose PVRTMatrixTransposeF
|
#define PVRTMatrixInverse PVRTMatrixInverseF
|
#define PVRTMatrixInverseEx PVRTMatrixInverseExF
|
#define PVRTMatrixLookAtLH PVRTMatrixLookAtLHF
|
#define PVRTMatrixLookAtRH PVRTMatrixLookAtRHF
|
#define PVRTMatrixPerspectiveFovLH PVRTMatrixPerspectiveFovLHF
|
#define PVRTMatrixPerspectiveFovRH PVRTMatrixPerspectiveFovRHF
|
#define PVRTMatrixOrthoLH PVRTMatrixOrthoLHF
|
#define PVRTMatrixOrthoRH PVRTMatrixOrthoRHF
|
#define PVRTMatrixVec3Lerp PVRTMatrixVec3LerpF
|
#define PVRTMatrixVec3DotProduct PVRTMatrixVec3DotProductF
|
#define PVRTMatrixVec3CrossProduct PVRTMatrixVec3CrossProductF
|
#define PVRTMatrixVec3Normalize PVRTMatrixVec3NormalizeF
|
#define PVRTMatrixVec3Length PVRTMatrixVec3LengthF
|
#define PVRTMatrixLinearEqSolve PVRTMatrixLinearEqSolveF
|
#endif
|
|
/****************************************************************************
|
** Functions
|
****************************************************************************/
|
|
/*!***************************************************************************
|
@fn PVRTMatrixIdentityF
|
@param[out] mOut Set to identity
|
@brief Reset matrix to identity matrix.
|
*****************************************************************************/
|
void PVRTMatrixIdentityF(PVRTMATRIXf &mOut);
|
|
/*!***************************************************************************
|
@fn PVRTMatrixIdentityX
|
@param[out] mOut Set to identity
|
@brief Reset matrix to identity matrix.
|
*****************************************************************************/
|
void PVRTMatrixIdentityX(PVRTMATRIXx &mOut);
|
|
/*!***************************************************************************
|
@fn PVRTMatrixMultiplyF
|
@param[out] mOut Result of mA x mB
|
@param[in] mA First operand
|
@param[in] mB Second operand
|
@brief Multiply mA by mB and assign the result to mOut
|
(mOut = p1 * p2). A copy of the result matrix is done in
|
the function because mOut can be a parameter mA or mB.
|
*****************************************************************************/
|
void PVRTMatrixMultiplyF(
|
PVRTMATRIXf &mOut,
|
const PVRTMATRIXf &mA,
|
const PVRTMATRIXf &mB);
|
/*!***************************************************************************
|
@fn PVRTMatrixMultiplyX
|
@param[out] mOut Result of mA x mB
|
@param[in] mA First operand
|
@param[in] mB Second operand
|
@brief Multiply mA by mB and assign the result to mOut
|
(mOut = p1 * p2). A copy of the result matrix is done in
|
the function because mOut can be a parameter mA or mB.
|
The fixed-point shift could be performed after adding
|
all four intermediate results together however this might
|
cause some overflow issues.
|
*****************************************************************************/
|
void PVRTMatrixMultiplyX(
|
PVRTMATRIXx &mOut,
|
const PVRTMATRIXx &mA,
|
const PVRTMATRIXx &mB);
|
|
/*!***************************************************************************
|
@fn PVRTMatrixTranslationF
|
@param[out] mOut Translation matrix
|
@param[in] fX X component of the translation
|
@param[in] fY Y component of the translation
|
@param[in] fZ Z component of the translation
|
@brief Build a transaltion matrix mOut using fX, fY and fZ.
|
*****************************************************************************/
|
void PVRTMatrixTranslationF(
|
PVRTMATRIXf &mOut,
|
const float fX,
|
const float fY,
|
const float fZ);
|
/*!***************************************************************************
|
@fn PVRTMatrixTranslationX
|
@param[out] mOut Translation matrix
|
@param[in] fX X component of the translation
|
@param[in] fY Y component of the translation
|
@param[in] fZ Z component of the translation
|
@brief Build a transaltion matrix mOut using fX, fY and fZ.
|
*****************************************************************************/
|
void PVRTMatrixTranslationX(
|
PVRTMATRIXx &mOut,
|
const int fX,
|
const int fY,
|
const int fZ);
|
|
/*!***************************************************************************
|
@fn PVRTMatrixScalingF
|
@param[out] mOut Scale matrix
|
@param[in] fX X component of the scaling
|
@param[in] fY Y component of the scaling
|
@param[in] fZ Z component of the scaling
|
@brief Build a scale matrix mOut using fX, fY and fZ.
|
*****************************************************************************/
|
void PVRTMatrixScalingF(
|
PVRTMATRIXf &mOut,
|
const float fX,
|
const float fY,
|
const float fZ);
|
|
/*!***************************************************************************
|
@fn PVRTMatrixScalingX
|
@param[out] mOut Scale matrix
|
@param[in] fX X component of the scaling
|
@param[in] fY Y component of the scaling
|
@param[in] fZ Z component of the scaling
|
@brief Build a scale matrix mOut using fX, fY and fZ.
|
*****************************************************************************/
|
void PVRTMatrixScalingX(
|
PVRTMATRIXx &mOut,
|
const int fX,
|
const int fY,
|
const int fZ);
|
|
/*!***************************************************************************
|
@fn PVRTMatrixRotationXF
|
@param[out] mOut Rotation matrix
|
@param[in] fAngle Angle of the rotation
|
@brief Create an X rotation matrix mOut.
|
*****************************************************************************/
|
void PVRTMatrixRotationXF(
|
PVRTMATRIXf &mOut,
|
const float fAngle);
|
|
/*!***************************************************************************
|
@fn PVRTMatrixRotationXX
|
@param[out] mOut Rotation matrix
|
@param[in] fAngle Angle of the rotation
|
@brief Create an X rotation matrix mOut.
|
*****************************************************************************/
|
void PVRTMatrixRotationXX(
|
PVRTMATRIXx &mOut,
|
const int fAngle);
|
|
/*!***************************************************************************
|
@fn PVRTMatrixRotationYF
|
@param[out] mOut Rotation matrix
|
@param[in] fAngle Angle of the rotation
|
@brief Create an Y rotation matrix mOut.
|
*****************************************************************************/
|
void PVRTMatrixRotationYF(
|
PVRTMATRIXf &mOut,
|
const float fAngle);
|
|
/*!***************************************************************************
|
@fn PVRTMatrixRotationYX
|
@param[out] mOut Rotation matrix
|
@param[in] fAngle Angle of the rotation
|
@brief Create an Y rotation matrix mOut.
|
*****************************************************************************/
|
void PVRTMatrixRotationYX(
|
PVRTMATRIXx &mOut,
|
const int fAngle);
|
|
/*!***************************************************************************
|
@fn PVRTMatrixRotationZF
|
@param[out] mOut Rotation matrix
|
@param[in] fAngle Angle of the rotation
|
@brief Create an Z rotation matrix mOut.
|
*****************************************************************************/
|
void PVRTMatrixRotationZF(
|
PVRTMATRIXf &mOut,
|
const float fAngle);
|
/*!***************************************************************************
|
@fn PVRTMatrixRotationZX
|
@param[out] mOut Rotation matrix
|
@param[in] fAngle Angle of the rotation
|
@brief Create an Z rotation matrix mOut.
|
*****************************************************************************/
|
void PVRTMatrixRotationZX(
|
PVRTMATRIXx &mOut,
|
const int fAngle);
|
|
/*!***************************************************************************
|
@fn PVRTMatrixTransposeF
|
@param[out] mOut Transposed matrix
|
@param[in] mIn Original matrix
|
@brief Compute the transpose matrix of mIn.
|
*****************************************************************************/
|
void PVRTMatrixTransposeF(
|
PVRTMATRIXf &mOut,
|
const PVRTMATRIXf &mIn);
|
/*!***************************************************************************
|
@fn PVRTMatrixTransposeX
|
@param[out] mOut Transposed matrix
|
@param[in] mIn Original matrix
|
@brief Compute the transpose matrix of mIn.
|
*****************************************************************************/
|
void PVRTMatrixTransposeX(
|
PVRTMATRIXx &mOut,
|
const PVRTMATRIXx &mIn);
|
|
/*!***************************************************************************
|
@fn PVRTMatrixInverseF
|
@param[out] mOut Inversed matrix
|
@param[in] mIn Original matrix
|
@brief Compute the inverse matrix of mIn.
|
The matrix must be of the form :
|
A 0
|
C 1
|
Where A is a 3x3 matrix and C is a 1x3 matrix.
|
*****************************************************************************/
|
void PVRTMatrixInverseF(
|
PVRTMATRIXf &mOut,
|
const PVRTMATRIXf &mIn);
|
/*!***************************************************************************
|
@fn PVRTMatrixInverseX
|
@param[out] mOut Inversed matrix
|
@param[in] mIn Original matrix
|
@brief Compute the inverse matrix of mIn.
|
The matrix must be of the form :
|
A 0
|
C 1
|
Where A is a 3x3 matrix and C is a 1x3 matrix.
|
*****************************************************************************/
|
void PVRTMatrixInverseX(
|
PVRTMATRIXx &mOut,
|
const PVRTMATRIXx &mIn);
|
|
/*!***************************************************************************
|
@fn PVRTMatrixInverseExF
|
@param[out] mOut Inversed matrix
|
@param[in] mIn Original matrix
|
@brief Compute the inverse matrix of mIn.
|
Uses a linear equation solver and the knowledge that M.M^-1=I.
|
Use this fn to calculate the inverse of matrices that
|
PVRTMatrixInverse() cannot.
|
*****************************************************************************/
|
void PVRTMatrixInverseExF(
|
PVRTMATRIXf &mOut,
|
const PVRTMATRIXf &mIn);
|
/*!***************************************************************************
|
@fn PVRTMatrixInverseExX
|
@param[out] mOut Inversed matrix
|
@param[in] mIn Original matrix
|
@brief Compute the inverse matrix of mIn.
|
Uses a linear equation solver and the knowledge that M.M^-1=I.
|
Use this fn to calculate the inverse of matrices that
|
PVRTMatrixInverse() cannot.
|
*****************************************************************************/
|
void PVRTMatrixInverseExX(
|
PVRTMATRIXx &mOut,
|
const PVRTMATRIXx &mIn);
|
|
/*!***************************************************************************
|
@fn PVRTMatrixLookAtLHF
|
@param[out] mOut Look-at view matrix
|
@param[in] vEye Position of the camera
|
@param[in] vAt Point the camera is looking at
|
@param[in] vUp Up direction for the camera
|
@brief Create a look-at view matrix.
|
*****************************************************************************/
|
void PVRTMatrixLookAtLHF(
|
PVRTMATRIXf &mOut,
|
const PVRTVECTOR3f &vEye,
|
const PVRTVECTOR3f &vAt,
|
const PVRTVECTOR3f &vUp);
|
/*!***************************************************************************
|
@fn PVRTMatrixLookAtLHX
|
@param[out] mOut Look-at view matrix
|
@param[in] vEye Position of the camera
|
@param[in] vAt Point the camera is looking at
|
@param[in] vUp Up direction for the camera
|
@brief Create a look-at view matrix.
|
*****************************************************************************/
|
void PVRTMatrixLookAtLHX(
|
PVRTMATRIXx &mOut,
|
const PVRTVECTOR3x &vEye,
|
const PVRTVECTOR3x &vAt,
|
const PVRTVECTOR3x &vUp);
|
|
/*!***************************************************************************
|
@fn PVRTMatrixLookAtRHF
|
@param[out] mOut Look-at view matrix
|
@param[in] vEye Position of the camera
|
@param[in] vAt Point the camera is looking at
|
@param[in] vUp Up direction for the camera
|
@brief Create a look-at view matrix.
|
*****************************************************************************/
|
void PVRTMatrixLookAtRHF(
|
PVRTMATRIXf &mOut,
|
const PVRTVECTOR3f &vEye,
|
const PVRTVECTOR3f &vAt,
|
const PVRTVECTOR3f &vUp);
|
/*!***************************************************************************
|
@fn PVRTMatrixLookAtRHX
|
@param[out] mOut Look-at view matrix
|
@param[in] vEye Position of the camera
|
@param[in] vAt Point the camera is looking at
|
@param[in] vUp Up direction for the camera
|
@brief Create a look-at view matrix.
|
*****************************************************************************/
|
void PVRTMatrixLookAtRHX(
|
PVRTMATRIXx &mOut,
|
const PVRTVECTOR3x &vEye,
|
const PVRTVECTOR3x &vAt,
|
const PVRTVECTOR3x &vUp);
|
|
/*!***************************************************************************
|
@fn PVRTMatrixPerspectiveFovLHF
|
@param[out] mOut Perspective matrix
|
@param[in] fFOVy Field of view
|
@param[in] fAspect Aspect ratio
|
@param[in] fNear Near clipping distance
|
@param[in] fFar Far clipping distance
|
@param[in] bRotate Should we rotate it ? (for upright screens)
|
@brief Create a perspective matrix.
|
*****************************************************************************/
|
void PVRTMatrixPerspectiveFovLHF(
|
PVRTMATRIXf &mOut,
|
const float fFOVy,
|
const float fAspect,
|
const float fNear,
|
const float fFar,
|
const bool bRotate = false);
|
/*!***************************************************************************
|
@fn PVRTMatrixPerspectiveFovLHX
|
@param[out] mOut Perspective matrix
|
@param[in] fFOVy Field of view
|
@param[in] fAspect Aspect ratio
|
@param[in] fNear Near clipping distance
|
@param[in] fFar Far clipping distance
|
@param[in] bRotate Should we rotate it ? (for upright screens)
|
@brief Create a perspective matrix.
|
*****************************************************************************/
|
void PVRTMatrixPerspectiveFovLHX(
|
PVRTMATRIXx &mOut,
|
const int fFOVy,
|
const int fAspect,
|
const int fNear,
|
const int fFar,
|
const bool bRotate = false);
|
|
/*!***************************************************************************
|
@fn PVRTMatrixPerspectiveFovRHF
|
@param[out] mOut Perspective matrix
|
@param[in] fFOVy Field of view
|
@param[in] fAspect Aspect ratio
|
@param[in] fNear Near clipping distance
|
@param[in] fFar Far clipping distance
|
@param[in] bRotate Should we rotate it ? (for upright screens)
|
@brief Create a perspective matrix.
|
*****************************************************************************/
|
void PVRTMatrixPerspectiveFovRHF(
|
PVRTMATRIXf &mOut,
|
const float fFOVy,
|
const float fAspect,
|
const float fNear,
|
const float fFar,
|
const bool bRotate = false);
|
/*!***************************************************************************
|
@fn PVRTMatrixPerspectiveFovRHX
|
@param[out] mOut Perspective matrix
|
@param[in] fFOVy Field of view
|
@param[in] fAspect Aspect ratio
|
@param[in] fNear Near clipping distance
|
@param[in] fFar Far clipping distance
|
@param[in] bRotate Should we rotate it ? (for upright screens)
|
@brief Create a perspective matrix.
|
*****************************************************************************/
|
void PVRTMatrixPerspectiveFovRHX(
|
PVRTMATRIXx &mOut,
|
const int fFOVy,
|
const int fAspect,
|
const int fNear,
|
const int fFar,
|
const bool bRotate = false);
|
|
/*!***************************************************************************
|
@fn PVRTMatrixOrthoLHF
|
@param[out] mOut Orthographic matrix
|
@param[in] w Width of the screen
|
@param[in] h Height of the screen
|
@param[in] zn Near clipping distance
|
@param[in] zf Far clipping distance
|
@param[in] bRotate Should we rotate it ? (for upright screens)
|
@brief Create an orthographic matrix.
|
*****************************************************************************/
|
void PVRTMatrixOrthoLHF(
|
PVRTMATRIXf &mOut,
|
const float w,
|
const float h,
|
const float zn,
|
const float zf,
|
const bool bRotate = false);
|
/*!***************************************************************************
|
@fn PVRTMatrixOrthoLHX
|
@param[out] mOut Orthographic matrix
|
@param[in] w Width of the screen
|
@param[in] h Height of the screen
|
@param[in] zn Near clipping distance
|
@param[in] zf Far clipping distance
|
@param[in] bRotate Should we rotate it ? (for upright screens)
|
@brief Create an orthographic matrix.
|
*****************************************************************************/
|
void PVRTMatrixOrthoLHX(
|
PVRTMATRIXx &mOut,
|
const int w,
|
const int h,
|
const int zn,
|
const int zf,
|
const bool bRotate = false);
|
|
/*!***************************************************************************
|
@fn PVRTMatrixOrthoRHF
|
@param[out] mOut Orthographic matrix
|
@param[in] w Width of the screen
|
@param[in] h Height of the screen
|
@param[in] zn Near clipping distance
|
@param[in] zf Far clipping distance
|
@param[in] bRotate Should we rotate it ? (for upright screens)
|
@brief Create an orthographic matrix.
|
*****************************************************************************/
|
void PVRTMatrixOrthoRHF(
|
PVRTMATRIXf &mOut,
|
const float w,
|
const float h,
|
const float zn,
|
const float zf,
|
const bool bRotate = false);
|
/*!***************************************************************************
|
@fn PVRTMatrixOrthoRHX
|
@param[out] mOut Orthographic matrix
|
@param[in] w Width of the screen
|
@param[in] h Height of the screen
|
@param[in] zn Near clipping distance
|
@param[in] zf Far clipping distance
|
@param[in] bRotate Should we rotate it ? (for upright screens)
|
@brief Create an orthographic matrix.
|
*****************************************************************************/
|
void PVRTMatrixOrthoRHX(
|
PVRTMATRIXx &mOut,
|
const int w,
|
const int h,
|
const int zn,
|
const int zf,
|
const bool bRotate = false);
|
|
/*!***************************************************************************
|
@fn PVRTMatrixVec3LerpF
|
@param[out] vOut Result of the interpolation
|
@param[in] v1 First vector to interpolate from
|
@param[in] v2 Second vector to interpolate form
|
@param[in] s Coefficient of interpolation
|
@brief This function performs the linear interpolation based on
|
the following formula: V1 + s(V2-V1).
|
*****************************************************************************/
|
void PVRTMatrixVec3LerpF(
|
PVRTVECTOR3f &vOut,
|
const PVRTVECTOR3f &v1,
|
const PVRTVECTOR3f &v2,
|
const float s);
|
/*!***************************************************************************
|
@fn PVRTMatrixVec3LerpX
|
@param[out] vOut Result of the interpolation
|
@param[in] v1 First vector to interpolate from
|
@param[in] v2 Second vector to interpolate form
|
@param[in] s Coefficient of interpolation
|
@brief This function performs the linear interpolation based on
|
the following formula: V1 + s(V2-V1).
|
*****************************************************************************/
|
void PVRTMatrixVec3LerpX(
|
PVRTVECTOR3x &vOut,
|
const PVRTVECTOR3x &v1,
|
const PVRTVECTOR3x &v2,
|
const int s);
|
|
/*!***************************************************************************
|
@fn PVRTMatrixVec3DotProductF
|
@param[in] v1 First vector
|
@param[in] v2 Second vector
|
@return Dot product of the two vectors.
|
@brief This function performs the dot product of the two
|
supplied vectors.
|
*****************************************************************************/
|
float PVRTMatrixVec3DotProductF(
|
const PVRTVECTOR3f &v1,
|
const PVRTVECTOR3f &v2);
|
/*!***************************************************************************
|
@fn PVRTMatrixVec3DotProductX
|
@param[in] v1 First vector
|
@param[in] v2 Second vector
|
@return Dot product of the two vectors.
|
@brief This function performs the dot product of the two
|
supplied vectors.
|
A single >> 16 shift could be applied to the final accumulated
|
result however this runs the risk of overflow between the
|
results of the intermediate additions.
|
*****************************************************************************/
|
int PVRTMatrixVec3DotProductX(
|
const PVRTVECTOR3x &v1,
|
const PVRTVECTOR3x &v2);
|
|
/*!***************************************************************************
|
@fn PVRTMatrixVec3CrossProductF
|
@param[out] vOut Cross product of the two vectors
|
@param[in] v1 First vector
|
@param[in] v2 Second vector
|
@brief This function performs the cross product of the two
|
supplied vectors.
|
*****************************************************************************/
|
void PVRTMatrixVec3CrossProductF(
|
PVRTVECTOR3f &vOut,
|
const PVRTVECTOR3f &v1,
|
const PVRTVECTOR3f &v2);
|
/*!***************************************************************************
|
@fn PVRTMatrixVec3CrossProductX
|
@param[out] vOut Cross product of the two vectors
|
@param[in] v1 First vector
|
@param[in] v2 Second vector
|
@brief This function performs the cross product of the two
|
supplied vectors.
|
*****************************************************************************/
|
void PVRTMatrixVec3CrossProductX(
|
PVRTVECTOR3x &vOut,
|
const PVRTVECTOR3x &v1,
|
const PVRTVECTOR3x &v2);
|
|
/*!***************************************************************************
|
@fn PVRTMatrixVec3NormalizeF
|
@param[out] vOut Normalized vector
|
@param[in] vIn Vector to normalize
|
@brief Normalizes the supplied vector.
|
*****************************************************************************/
|
void PVRTMatrixVec3NormalizeF(
|
PVRTVECTOR3f &vOut,
|
const PVRTVECTOR3f &vIn);
|
/*!***************************************************************************
|
@fn PVRTMatrixVec3NormalizeX
|
@param[out] vOut Normalized vector
|
@param[in] vIn Vector to normalize
|
@brief Normalizes the supplied vector.
|
The square root function is currently still performed
|
in floating-point.
|
Original vector is scaled down prior to be normalized in
|
order to avoid overflow issues.
|
*****************************************************************************/
|
void PVRTMatrixVec3NormalizeX(
|
PVRTVECTOR3x &vOut,
|
const PVRTVECTOR3x &vIn);
|
/*!***************************************************************************
|
@fn PVRTMatrixVec3LengthF
|
@param[in] vIn Vector to get the length of
|
@return The length of the vector
|
@brief Gets the length of the supplied vector.
|
*****************************************************************************/
|
float PVRTMatrixVec3LengthF(
|
const PVRTVECTOR3f &vIn);
|
/*!***************************************************************************
|
@fn PVRTMatrixVec3LengthX
|
@param[in] vIn Vector to get the length of
|
@return The length of the vector
|
@brief Gets the length of the supplied vector
|
*****************************************************************************/
|
int PVRTMatrixVec3LengthX(
|
const PVRTVECTOR3x &vIn);
|
/*!***************************************************************************
|
@fn PVRTMatrixLinearEqSolveF
|
@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 PVRTMatrixLinearEqSolveF(
|
float * const pRes,
|
float ** const pSrc,
|
const int nCnt);
|
/*!***************************************************************************
|
@fn PVRTMatrixLinearEqSolveX
|
@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 PVRTMatrixLinearEqSolveX(
|
int * const pRes,
|
int ** const pSrc,
|
const int nCnt);
|
|
#endif
|
|
/*****************************************************************************
|
End of file (PVRTMatrix.h)
|
*****************************************************************************/
|
