/*!****************************************************************************
@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)
*****************************************************************************/