////////////////////////////////////////////////////////////////////////////// // // Copyright (C) Microsoft Corporation. All Rights Reserved. // // File: d3dx9math.h // Content: D3DX math types and functions // ////////////////////////////////////////////////////////////////////////////// #include "d3dx9.h" #ifndef __D3DX9MATH_H__ #define __D3DX9MATH_H__ #include #if _MSC_VER >= 1200 #pragma warning(push) #endif #pragma warning(disable:4201) // anonymous unions warning //=========================================================================== // // General purpose utilities // //=========================================================================== #define D3DX_PI ((FLOAT) 3.141592654f) #define D3DX_1BYPI ((FLOAT) 0.318309886f) #define D3DXToRadian( degree ) ((degree) * (D3DX_PI / 180.0f)) #define D3DXToDegree( radian ) ((radian) * (180.0f / D3DX_PI)) //=========================================================================== // // 16 bit floating point numbers // //=========================================================================== #define D3DX_16F_DIG 3 // # of decimal digits of precision #define D3DX_16F_EPSILON 4.8875809e-4f // smallest such that 1.0 + epsilon != 1.0 #define D3DX_16F_MANT_DIG 11 // # of bits in mantissa #define D3DX_16F_MAX 6.550400e+004 // max value #define D3DX_16F_MAX_10_EXP 4 // max decimal exponent #define D3DX_16F_MAX_EXP 15 // max binary exponent #define D3DX_16F_MIN 6.1035156e-5f // min positive value #define D3DX_16F_MIN_10_EXP (-4) // min decimal exponent #define D3DX_16F_MIN_EXP (-12) // min binary exponent #define D3DX_16F_RADIX 2 // exponent radix #define D3DX_16F_ROUNDS 1 // addition rounding: near typedef struct D3DXFLOAT16 { #ifdef __cplusplus public: D3DXFLOAT16() {}; D3DXFLOAT16( FLOAT ); D3DXFLOAT16( CONST D3DXFLOAT16& ); // casting operator FLOAT (); // binary operators BOOL operator == ( CONST D3DXFLOAT16& ) const; BOOL operator != ( CONST D3DXFLOAT16& ) const; protected: #endif //__cplusplus WORD value; } D3DXFLOAT16, *LPD3DXFLOAT16; //=========================================================================== // // Vectors // //=========================================================================== //-------------------------- // 2D Vector //-------------------------- typedef struct D3DXVECTOR2 { #ifdef __cplusplus public: D3DXVECTOR2() {}; D3DXVECTOR2( CONST FLOAT * ); D3DXVECTOR2( CONST D3DXFLOAT16 * ); D3DXVECTOR2( FLOAT x, FLOAT y ); // casting operator FLOAT* (); operator CONST FLOAT* () const; // assignment operators D3DXVECTOR2& operator += ( CONST D3DXVECTOR2& ); D3DXVECTOR2& operator -= ( CONST D3DXVECTOR2& ); D3DXVECTOR2& operator *= ( FLOAT ); D3DXVECTOR2& operator /= ( FLOAT ); // unary operators D3DXVECTOR2 operator + () const; D3DXVECTOR2 operator - () const; // binary operators D3DXVECTOR2 operator + ( CONST D3DXVECTOR2& ) const; D3DXVECTOR2 operator - ( CONST D3DXVECTOR2& ) const; D3DXVECTOR2 operator * ( FLOAT ) const; D3DXVECTOR2 operator / ( FLOAT ) const; friend D3DXVECTOR2 operator * ( FLOAT, CONST D3DXVECTOR2& ); BOOL operator == ( CONST D3DXVECTOR2& ) const; BOOL operator != ( CONST D3DXVECTOR2& ) const; public: #endif //__cplusplus FLOAT x, y; } D3DXVECTOR2, *LPD3DXVECTOR2; //-------------------------- // 2D Vector (16 bit) //-------------------------- typedef struct D3DXVECTOR2_16F { #ifdef __cplusplus public: D3DXVECTOR2_16F() {}; D3DXVECTOR2_16F( CONST FLOAT * ); D3DXVECTOR2_16F( CONST D3DXFLOAT16 * ); D3DXVECTOR2_16F( CONST D3DXFLOAT16 &x, CONST D3DXFLOAT16 &y ); // casting operator D3DXFLOAT16* (); operator CONST D3DXFLOAT16* () const; // binary operators BOOL operator == ( CONST D3DXVECTOR2_16F& ) const; BOOL operator != ( CONST D3DXVECTOR2_16F& ) const; public: #endif //__cplusplus D3DXFLOAT16 x, y; } D3DXVECTOR2_16F, *LPD3DXVECTOR2_16F; //-------------------------- // 3D Vector //-------------------------- #ifdef __cplusplus typedef struct D3DXVECTOR3 : public D3DVECTOR { public: D3DXVECTOR3() {}; D3DXVECTOR3( CONST FLOAT * ); D3DXVECTOR3( CONST D3DVECTOR& ); D3DXVECTOR3( CONST D3DXFLOAT16 * ); D3DXVECTOR3( FLOAT x, FLOAT y, FLOAT z ); // casting operator FLOAT* (); operator CONST FLOAT* () const; // assignment operators D3DXVECTOR3& operator += ( CONST D3DXVECTOR3& ); D3DXVECTOR3& operator -= ( CONST D3DXVECTOR3& ); D3DXVECTOR3& operator *= ( FLOAT ); D3DXVECTOR3& operator /= ( FLOAT ); // unary operators D3DXVECTOR3 operator + () const; D3DXVECTOR3 operator - () const; // binary operators D3DXVECTOR3 operator + ( CONST D3DXVECTOR3& ) const; D3DXVECTOR3 operator - ( CONST D3DXVECTOR3& ) const; D3DXVECTOR3 operator * ( FLOAT ) const; D3DXVECTOR3 operator / ( FLOAT ) const; friend D3DXVECTOR3 operator * ( FLOAT, CONST struct D3DXVECTOR3& ); BOOL operator == ( CONST D3DXVECTOR3& ) const; BOOL operator != ( CONST D3DXVECTOR3& ) const; } D3DXVECTOR3, *LPD3DXVECTOR3; #else //!__cplusplus typedef struct _D3DVECTOR D3DXVECTOR3, *LPD3DXVECTOR3; #endif //!__cplusplus //-------------------------- // 3D Vector (16 bit) //-------------------------- typedef struct D3DXVECTOR3_16F { #ifdef __cplusplus public: D3DXVECTOR3_16F() {}; D3DXVECTOR3_16F( CONST FLOAT * ); D3DXVECTOR3_16F( CONST D3DVECTOR& ); D3DXVECTOR3_16F( CONST D3DXFLOAT16 * ); D3DXVECTOR3_16F( CONST D3DXFLOAT16 &x, CONST D3DXFLOAT16 &y, CONST D3DXFLOAT16 &z ); // casting operator D3DXFLOAT16* (); operator CONST D3DXFLOAT16* () const; // binary operators BOOL operator == ( CONST D3DXVECTOR3_16F& ) const; BOOL operator != ( CONST D3DXVECTOR3_16F& ) const; public: #endif //__cplusplus D3DXFLOAT16 x, y, z; } D3DXVECTOR3_16F, *LPD3DXVECTOR3_16F; //-------------------------- // 4D Vector //-------------------------- typedef struct D3DXVECTOR4 { #ifdef __cplusplus public: D3DXVECTOR4() {}; D3DXVECTOR4( CONST FLOAT* ); D3DXVECTOR4( CONST D3DXFLOAT16* ); D3DXVECTOR4( CONST D3DVECTOR& xyz, FLOAT w ); D3DXVECTOR4( FLOAT x, FLOAT y, FLOAT z, FLOAT w ); // casting operator FLOAT* (); operator CONST FLOAT* () const; // assignment operators D3DXVECTOR4& operator += ( CONST D3DXVECTOR4& ); D3DXVECTOR4& operator -= ( CONST D3DXVECTOR4& ); D3DXVECTOR4& operator *= ( FLOAT ); D3DXVECTOR4& operator /= ( FLOAT ); // unary operators D3DXVECTOR4 operator + () const; D3DXVECTOR4 operator - () const; // binary operators D3DXVECTOR4 operator + ( CONST D3DXVECTOR4& ) const; D3DXVECTOR4 operator - ( CONST D3DXVECTOR4& ) const; D3DXVECTOR4 operator * ( FLOAT ) const; D3DXVECTOR4 operator / ( FLOAT ) const; friend D3DXVECTOR4 operator * ( FLOAT, CONST D3DXVECTOR4& ); BOOL operator == ( CONST D3DXVECTOR4& ) const; BOOL operator != ( CONST D3DXVECTOR4& ) const; public: #endif //__cplusplus FLOAT x, y, z, w; } D3DXVECTOR4, *LPD3DXVECTOR4; //-------------------------- // 4D Vector (16 bit) //-------------------------- typedef struct D3DXVECTOR4_16F { #ifdef __cplusplus public: D3DXVECTOR4_16F() {}; D3DXVECTOR4_16F( CONST FLOAT * ); D3DXVECTOR4_16F( CONST D3DXFLOAT16* ); D3DXVECTOR4_16F( CONST D3DXVECTOR3_16F& xyz, CONST D3DXFLOAT16& w ); D3DXVECTOR4_16F( CONST D3DXFLOAT16& x, CONST D3DXFLOAT16& y, CONST D3DXFLOAT16& z, CONST D3DXFLOAT16& w ); // casting operator D3DXFLOAT16* (); operator CONST D3DXFLOAT16* () const; // binary operators BOOL operator == ( CONST D3DXVECTOR4_16F& ) const; BOOL operator != ( CONST D3DXVECTOR4_16F& ) const; public: #endif //__cplusplus D3DXFLOAT16 x, y, z, w; } D3DXVECTOR4_16F, *LPD3DXVECTOR4_16F; //=========================================================================== // // Matrices // //=========================================================================== #ifdef __cplusplus typedef struct D3DXMATRIX : public D3DMATRIX { public: D3DXMATRIX() {}; D3DXMATRIX( CONST FLOAT * ); D3DXMATRIX( CONST D3DMATRIX& ); D3DXMATRIX( CONST D3DXFLOAT16 * ); D3DXMATRIX( FLOAT _11, FLOAT _12, FLOAT _13, FLOAT _14, FLOAT _21, FLOAT _22, FLOAT _23, FLOAT _24, FLOAT _31, FLOAT _32, FLOAT _33, FLOAT _34, FLOAT _41, FLOAT _42, FLOAT _43, FLOAT _44 ); // access grants FLOAT& operator () ( UINT Row, UINT Col ); FLOAT operator () ( UINT Row, UINT Col ) const; // casting operators operator FLOAT* (); operator CONST FLOAT* () const; // assignment operators D3DXMATRIX& operator *= ( CONST D3DXMATRIX& ); D3DXMATRIX& operator += ( CONST D3DXMATRIX& ); D3DXMATRIX& operator -= ( CONST D3DXMATRIX& ); D3DXMATRIX& operator *= ( FLOAT ); D3DXMATRIX& operator /= ( FLOAT ); // unary operators D3DXMATRIX operator + () const; D3DXMATRIX operator - () const; // binary operators D3DXMATRIX operator * ( CONST D3DXMATRIX& ) const; D3DXMATRIX operator + ( CONST D3DXMATRIX& ) const; D3DXMATRIX operator - ( CONST D3DXMATRIX& ) const; D3DXMATRIX operator * ( FLOAT ) const; D3DXMATRIX operator / ( FLOAT ) const; friend D3DXMATRIX operator * ( FLOAT, CONST D3DXMATRIX& ); BOOL operator == ( CONST D3DXMATRIX& ) const; BOOL operator != ( CONST D3DXMATRIX& ) const; } D3DXMATRIX, *LPD3DXMATRIX; #else //!__cplusplus typedef struct _D3DMATRIX D3DXMATRIX, *LPD3DXMATRIX; #endif //!__cplusplus //--------------------------------------------------------------------------- // Aligned Matrices // // This class helps keep matrices 16-byte aligned as preferred by P4 cpus. // It aligns matrices on the stack and on the heap or in global scope. // It does this using __declspec(align(16)) which works on VC7 and on VC 6 // with the processor pack. Unfortunately there is no way to detect the // latter so this is turned on only on VC7. On other compilers this is the // the same as D3DXMATRIX. // // Using this class on a compiler that does not actually do the alignment // can be dangerous since it will not expose bugs that ignore alignment. // E.g if an object of this class in inside a struct or class, and some code // memcopys data in it assuming tight packing. This could break on a compiler // that eventually start aligning the matrix. //--------------------------------------------------------------------------- #ifdef __cplusplus typedef struct _D3DXMATRIXA16 : public D3DXMATRIX { _D3DXMATRIXA16() {} _D3DXMATRIXA16( CONST FLOAT * ); _D3DXMATRIXA16( CONST D3DMATRIX& ); _D3DXMATRIXA16( CONST D3DXFLOAT16 * ); _D3DXMATRIXA16( FLOAT _11, FLOAT _12, FLOAT _13, FLOAT _14, FLOAT _21, FLOAT _22, FLOAT _23, FLOAT _24, FLOAT _31, FLOAT _32, FLOAT _33, FLOAT _34, FLOAT _41, FLOAT _42, FLOAT _43, FLOAT _44 ); // new operators void* operator new ( size_t ); void* operator new[] ( size_t ); // delete operators void operator delete ( void* ); // These are NOT virtual; Do not void operator delete[] ( void* ); // cast to D3DXMATRIX and delete. // assignment operators _D3DXMATRIXA16& operator = ( CONST D3DXMATRIX& ); } _D3DXMATRIXA16; #else //!__cplusplus typedef D3DXMATRIX _D3DXMATRIXA16; #endif //!__cplusplus #if _MSC_VER >= 1300 // VC7 #define D3DX_ALIGN16 __declspec(align(16)) #else #define D3DX_ALIGN16 // Earlier compiler may not understand this, do nothing. #endif typedef D3DX_ALIGN16 _D3DXMATRIXA16 D3DXMATRIXA16, *LPD3DXMATRIXA16; //=========================================================================== // // Quaternions // //=========================================================================== typedef struct D3DXQUATERNION { #ifdef __cplusplus public: D3DXQUATERNION() {} D3DXQUATERNION( CONST FLOAT * ); D3DXQUATERNION( CONST D3DXFLOAT16 * ); D3DXQUATERNION( FLOAT x, FLOAT y, FLOAT z, FLOAT w ); // casting operator FLOAT* (); operator CONST FLOAT* () const; // assignment operators D3DXQUATERNION& operator += ( CONST D3DXQUATERNION& ); D3DXQUATERNION& operator -= ( CONST D3DXQUATERNION& ); D3DXQUATERNION& operator *= ( CONST D3DXQUATERNION& ); D3DXQUATERNION& operator *= ( FLOAT ); D3DXQUATERNION& operator /= ( FLOAT ); // unary operators D3DXQUATERNION operator + () const; D3DXQUATERNION operator - () const; // binary operators D3DXQUATERNION operator + ( CONST D3DXQUATERNION& ) const; D3DXQUATERNION operator - ( CONST D3DXQUATERNION& ) const; D3DXQUATERNION operator * ( CONST D3DXQUATERNION& ) const; D3DXQUATERNION operator * ( FLOAT ) const; D3DXQUATERNION operator / ( FLOAT ) const; friend D3DXQUATERNION operator * (FLOAT, CONST D3DXQUATERNION& ); BOOL operator == ( CONST D3DXQUATERNION& ) const; BOOL operator != ( CONST D3DXQUATERNION& ) const; #endif //__cplusplus FLOAT x, y, z, w; } D3DXQUATERNION, *LPD3DXQUATERNION; //=========================================================================== // // Planes // //=========================================================================== typedef struct D3DXPLANE { #ifdef __cplusplus public: D3DXPLANE() {} D3DXPLANE( CONST FLOAT* ); D3DXPLANE( CONST D3DXFLOAT16* ); D3DXPLANE( FLOAT a, FLOAT b, FLOAT c, FLOAT d ); // casting operator FLOAT* (); operator CONST FLOAT* () const; // assignment operators D3DXPLANE& operator *= ( FLOAT ); D3DXPLANE& operator /= ( FLOAT ); // unary operators D3DXPLANE operator + () const; D3DXPLANE operator - () const; // binary operators D3DXPLANE operator * ( FLOAT ) const; D3DXPLANE operator / ( FLOAT ) const; friend D3DXPLANE operator * ( FLOAT, CONST D3DXPLANE& ); BOOL operator == ( CONST D3DXPLANE& ) const; BOOL operator != ( CONST D3DXPLANE& ) const; #endif //__cplusplus FLOAT a, b, c, d; } D3DXPLANE, *LPD3DXPLANE; //=========================================================================== // // Colors // //=========================================================================== typedef struct D3DXCOLOR { #ifdef __cplusplus public: D3DXCOLOR() {} D3DXCOLOR( DWORD argb ); D3DXCOLOR( CONST FLOAT * ); D3DXCOLOR( CONST D3DXFLOAT16 * ); D3DXCOLOR( CONST D3DCOLORVALUE& ); D3DXCOLOR( FLOAT r, FLOAT g, FLOAT b, FLOAT a ); // casting operator DWORD () const; operator FLOAT* (); operator CONST FLOAT* () const; operator D3DCOLORVALUE* (); operator CONST D3DCOLORVALUE* () const; operator D3DCOLORVALUE& (); operator CONST D3DCOLORVALUE& () const; // assignment operators D3DXCOLOR& operator += ( CONST D3DXCOLOR& ); D3DXCOLOR& operator -= ( CONST D3DXCOLOR& ); D3DXCOLOR& operator *= ( FLOAT ); D3DXCOLOR& operator /= ( FLOAT ); // unary operators D3DXCOLOR operator + () const; D3DXCOLOR operator - () const; // binary operators D3DXCOLOR operator + ( CONST D3DXCOLOR& ) const; D3DXCOLOR operator - ( CONST D3DXCOLOR& ) const; D3DXCOLOR operator * ( FLOAT ) const; D3DXCOLOR operator / ( FLOAT ) const; friend D3DXCOLOR operator * ( FLOAT, CONST D3DXCOLOR& ); BOOL operator == ( CONST D3DXCOLOR& ) const; BOOL operator != ( CONST D3DXCOLOR& ) const; #endif //__cplusplus FLOAT r, g, b, a; } D3DXCOLOR, *LPD3DXCOLOR; //=========================================================================== // // D3DX math functions: // // NOTE: // * All these functions can take the same object as in and out parameters. // // * Out parameters are typically also returned as return values, so that // the output of one function may be used as a parameter to another. // //=========================================================================== //-------------------------- // Float16 //-------------------------- // non-inline #ifdef __cplusplus extern "C" { #endif // Converts an array 32-bit floats to 16-bit floats D3DXFLOAT16* WINAPI D3DXFloat32To16Array ( D3DXFLOAT16 *pOut, CONST FLOAT *pIn, UINT n ); // Converts an array 16-bit floats to 32-bit floats FLOAT* WINAPI D3DXFloat16To32Array ( FLOAT *pOut, CONST D3DXFLOAT16 *pIn, UINT n ); #ifdef __cplusplus } #endif //-------------------------- // 2D Vector //-------------------------- // inline FLOAT D3DXVec2Length ( CONST D3DXVECTOR2 *pV ); FLOAT D3DXVec2LengthSq ( CONST D3DXVECTOR2 *pV ); FLOAT D3DXVec2Dot ( CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 ); // Z component of ((x1,y1,0) cross (x2,y2,0)) FLOAT D3DXVec2CCW ( CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 ); D3DXVECTOR2* D3DXVec2Add ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 ); D3DXVECTOR2* D3DXVec2Subtract ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 ); // Minimize each component. x = min(x1, x2), y = min(y1, y2) D3DXVECTOR2* D3DXVec2Minimize ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 ); // Maximize each component. x = max(x1, x2), y = max(y1, y2) D3DXVECTOR2* D3DXVec2Maximize ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 ); D3DXVECTOR2* D3DXVec2Scale ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV, FLOAT s ); // Linear interpolation. V1 + s(V2-V1) D3DXVECTOR2* D3DXVec2Lerp ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2, FLOAT s ); // non-inline #ifdef __cplusplus extern "C" { #endif D3DXVECTOR2* WINAPI D3DXVec2Normalize ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV ); // Hermite interpolation between position V1, tangent T1 (when s == 0) // and position V2, tangent T2 (when s == 1). D3DXVECTOR2* WINAPI D3DXVec2Hermite ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pT1, CONST D3DXVECTOR2 *pV2, CONST D3DXVECTOR2 *pT2, FLOAT s ); // CatmullRom interpolation between V1 (when s == 0) and V2 (when s == 1) D3DXVECTOR2* WINAPI D3DXVec2CatmullRom ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV0, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2, CONST D3DXVECTOR2 *pV3, FLOAT s ); // Barycentric coordinates. V1 + f(V2-V1) + g(V3-V1) D3DXVECTOR2* WINAPI D3DXVec2BaryCentric ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2, CONST D3DXVECTOR2 *pV3, FLOAT f, FLOAT g); // Transform (x, y, 0, 1) by matrix. D3DXVECTOR4* WINAPI D3DXVec2Transform ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR2 *pV, CONST D3DXMATRIX *pM ); // Transform (x, y, 0, 1) by matrix, project result back into w=1. D3DXVECTOR2* WINAPI D3DXVec2TransformCoord ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV, CONST D3DXMATRIX *pM ); // Transform (x, y, 0, 0) by matrix. D3DXVECTOR2* WINAPI D3DXVec2TransformNormal ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV, CONST D3DXMATRIX *pM ); // Transform Array (x, y, 0, 1) by matrix. D3DXVECTOR4* WINAPI D3DXVec2TransformArray ( D3DXVECTOR4 *pOut, UINT OutStride, CONST D3DXVECTOR2 *pV, UINT VStride, CONST D3DXMATRIX *pM, UINT n); // Transform Array (x, y, 0, 1) by matrix, project result back into w=1. D3DXVECTOR2* WINAPI D3DXVec2TransformCoordArray ( D3DXVECTOR2 *pOut, UINT OutStride, CONST D3DXVECTOR2 *pV, UINT VStride, CONST D3DXMATRIX *pM, UINT n ); // Transform Array (x, y, 0, 0) by matrix. D3DXVECTOR2* WINAPI D3DXVec2TransformNormalArray ( D3DXVECTOR2 *pOut, UINT OutStride, CONST D3DXVECTOR2 *pV, UINT VStride, CONST D3DXMATRIX *pM, UINT n ); #ifdef __cplusplus } #endif //-------------------------- // 3D Vector //-------------------------- // inline FLOAT D3DXVec3Length ( CONST D3DXVECTOR3 *pV ); FLOAT D3DXVec3LengthSq ( CONST D3DXVECTOR3 *pV ); FLOAT D3DXVec3Dot ( CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 ); D3DXVECTOR3* D3DXVec3Cross ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 ); D3DXVECTOR3* D3DXVec3Add ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 ); D3DXVECTOR3* D3DXVec3Subtract ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 ); // Minimize each component. x = min(x1, x2), y = min(y1, y2), ... D3DXVECTOR3* D3DXVec3Minimize ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 ); // Maximize each component. x = max(x1, x2), y = max(y1, y2), ... D3DXVECTOR3* D3DXVec3Maximize ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 ); D3DXVECTOR3* D3DXVec3Scale ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, FLOAT s); // Linear interpolation. V1 + s(V2-V1) D3DXVECTOR3* D3DXVec3Lerp ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2, FLOAT s ); // non-inline #ifdef __cplusplus extern "C" { #endif D3DXVECTOR3* WINAPI D3DXVec3Normalize ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV ); // Hermite interpolation between position V1, tangent T1 (when s == 0) // and position V2, tangent T2 (when s == 1). D3DXVECTOR3* WINAPI D3DXVec3Hermite ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pT1, CONST D3DXVECTOR3 *pV2, CONST D3DXVECTOR3 *pT2, FLOAT s ); // CatmullRom interpolation between V1 (when s == 0) and V2 (when s == 1) D3DXVECTOR3* WINAPI D3DXVec3CatmullRom ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV0, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2, CONST D3DXVECTOR3 *pV3, FLOAT s ); // Barycentric coordinates. V1 + f(V2-V1) + g(V3-V1) D3DXVECTOR3* WINAPI D3DXVec3BaryCentric ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2, CONST D3DXVECTOR3 *pV3, FLOAT f, FLOAT g); // Transform (x, y, z, 1) by matrix. D3DXVECTOR4* WINAPI D3DXVec3Transform ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR3 *pV, CONST D3DXMATRIX *pM ); // Transform (x, y, z, 1) by matrix, project result back into w=1. D3DXVECTOR3* WINAPI D3DXVec3TransformCoord ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, CONST D3DXMATRIX *pM ); // Transform (x, y, z, 0) by matrix. If you transforming a normal by a // non-affine matrix, the matrix you pass to this function should be the // transpose of the inverse of the matrix you would use to transform a coord. D3DXVECTOR3* WINAPI D3DXVec3TransformNormal ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, CONST D3DXMATRIX *pM ); // Transform Array (x, y, z, 1) by matrix. D3DXVECTOR4* WINAPI D3DXVec3TransformArray ( D3DXVECTOR4 *pOut, UINT OutStride, CONST D3DXVECTOR3 *pV, UINT VStride, CONST D3DXMATRIX *pM, UINT n ); // Transform Array (x, y, z, 1) by matrix, project result back into w=1. D3DXVECTOR3* WINAPI D3DXVec3TransformCoordArray ( D3DXVECTOR3 *pOut, UINT OutStride, CONST D3DXVECTOR3 *pV, UINT VStride, CONST D3DXMATRIX *pM, UINT n ); // Transform (x, y, z, 0) by matrix. If you transforming a normal by a // non-affine matrix, the matrix you pass to this function should be the // transpose of the inverse of the matrix you would use to transform a coord. D3DXVECTOR3* WINAPI D3DXVec3TransformNormalArray ( D3DXVECTOR3 *pOut, UINT OutStride, CONST D3DXVECTOR3 *pV, UINT VStride, CONST D3DXMATRIX *pM, UINT n ); // Project vector from object space into screen space D3DXVECTOR3* WINAPI D3DXVec3Project ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, CONST D3DVIEWPORT9 *pViewport, CONST D3DXMATRIX *pProjection, CONST D3DXMATRIX *pView, CONST D3DXMATRIX *pWorld); // Project vector from screen space into object space D3DXVECTOR3* WINAPI D3DXVec3Unproject ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, CONST D3DVIEWPORT9 *pViewport, CONST D3DXMATRIX *pProjection, CONST D3DXMATRIX *pView, CONST D3DXMATRIX *pWorld); // Project vector Array from object space into screen space D3DXVECTOR3* WINAPI D3DXVec3ProjectArray ( D3DXVECTOR3 *pOut, UINT OutStride,CONST D3DXVECTOR3 *pV, UINT VStride,CONST D3DVIEWPORT9 *pViewport, CONST D3DXMATRIX *pProjection, CONST D3DXMATRIX *pView, CONST D3DXMATRIX *pWorld, UINT n); // Project vector Array from screen space into object space D3DXVECTOR3* WINAPI D3DXVec3UnprojectArray ( D3DXVECTOR3 *pOut, UINT OutStride, CONST D3DXVECTOR3 *pV, UINT VStride, CONST D3DVIEWPORT9 *pViewport, CONST D3DXMATRIX *pProjection, CONST D3DXMATRIX *pView, CONST D3DXMATRIX *pWorld, UINT n); #ifdef __cplusplus } #endif //-------------------------- // 4D Vector //-------------------------- // inline FLOAT D3DXVec4Length ( CONST D3DXVECTOR4 *pV ); FLOAT D3DXVec4LengthSq ( CONST D3DXVECTOR4 *pV ); FLOAT D3DXVec4Dot ( CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2 ); D3DXVECTOR4* D3DXVec4Add ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2); D3DXVECTOR4* D3DXVec4Subtract ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2); // Minimize each component. x = min(x1, x2), y = min(y1, y2), ... D3DXVECTOR4* D3DXVec4Minimize ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2); // Maximize each component. x = max(x1, x2), y = max(y1, y2), ... D3DXVECTOR4* D3DXVec4Maximize ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2); D3DXVECTOR4* D3DXVec4Scale ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV, FLOAT s); // Linear interpolation. V1 + s(V2-V1) D3DXVECTOR4* D3DXVec4Lerp ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2, FLOAT s ); // non-inline #ifdef __cplusplus extern "C" { #endif // Cross-product in 4 dimensions. D3DXVECTOR4* WINAPI D3DXVec4Cross ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2, CONST D3DXVECTOR4 *pV3); D3DXVECTOR4* WINAPI D3DXVec4Normalize ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV ); // Hermite interpolation between position V1, tangent T1 (when s == 0) // and position V2, tangent T2 (when s == 1). D3DXVECTOR4* WINAPI D3DXVec4Hermite ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pT1, CONST D3DXVECTOR4 *pV2, CONST D3DXVECTOR4 *pT2, FLOAT s ); // CatmullRom interpolation between V1 (when s == 0) and V2 (when s == 1) D3DXVECTOR4* WINAPI D3DXVec4CatmullRom ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV0, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2, CONST D3DXVECTOR4 *pV3, FLOAT s ); // Barycentric coordinates. V1 + f(V2-V1) + g(V3-V1) D3DXVECTOR4* WINAPI D3DXVec4BaryCentric ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2, CONST D3DXVECTOR4 *pV3, FLOAT f, FLOAT g); // Transform vector by matrix. D3DXVECTOR4* WINAPI D3DXVec4Transform ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV, CONST D3DXMATRIX *pM ); // Transform vector array by matrix. D3DXVECTOR4* WINAPI D3DXVec4TransformArray ( D3DXVECTOR4 *pOut, UINT OutStride, CONST D3DXVECTOR4 *pV, UINT VStride, CONST D3DXMATRIX *pM, UINT n ); #ifdef __cplusplus } #endif //-------------------------- // 4D Matrix //-------------------------- // inline D3DXMATRIX* D3DXMatrixIdentity ( D3DXMATRIX *pOut ); BOOL D3DXMatrixIsIdentity ( CONST D3DXMATRIX *pM ); // non-inline #ifdef __cplusplus extern "C" { #endif FLOAT WINAPI D3DXMatrixDeterminant ( CONST D3DXMATRIX *pM ); HRESULT WINAPI D3DXMatrixDecompose ( D3DXVECTOR3 *pOutScale, D3DXQUATERNION *pOutRotation, D3DXVECTOR3 *pOutTranslation, CONST D3DXMATRIX *pM ); D3DXMATRIX* WINAPI D3DXMatrixTranspose ( D3DXMATRIX *pOut, CONST D3DXMATRIX *pM ); // Matrix multiplication. The result represents the transformation M2 // followed by the transformation M1. (Out = M1 * M2) D3DXMATRIX* WINAPI D3DXMatrixMultiply ( D3DXMATRIX *pOut, CONST D3DXMATRIX *pM1, CONST D3DXMATRIX *pM2 ); // Matrix multiplication, followed by a transpose. (Out = T(M1 * M2)) D3DXMATRIX* WINAPI D3DXMatrixMultiplyTranspose ( D3DXMATRIX *pOut, CONST D3DXMATRIX *pM1, CONST D3DXMATRIX *pM2 ); // Calculate inverse of matrix. Inversion my fail, in which case NULL will // be returned. The determinant of pM is also returned it pfDeterminant // is non-NULL. D3DXMATRIX* WINAPI D3DXMatrixInverse ( D3DXMATRIX *pOut, FLOAT *pDeterminant, CONST D3DXMATRIX *pM ); // Build a matrix which scales by (sx, sy, sz) D3DXMATRIX* WINAPI D3DXMatrixScaling ( D3DXMATRIX *pOut, FLOAT sx, FLOAT sy, FLOAT sz ); // Build a matrix which translates by (x, y, z) D3DXMATRIX* WINAPI D3DXMatrixTranslation ( D3DXMATRIX *pOut, FLOAT x, FLOAT y, FLOAT z ); // Build a matrix which rotates around the X axis D3DXMATRIX* WINAPI D3DXMatrixRotationX ( D3DXMATRIX *pOut, FLOAT Angle ); // Build a matrix which rotates around the Y axis D3DXMATRIX* WINAPI D3DXMatrixRotationY ( D3DXMATRIX *pOut, FLOAT Angle ); // Build a matrix which rotates around the Z axis D3DXMATRIX* WINAPI D3DXMatrixRotationZ ( D3DXMATRIX *pOut, FLOAT Angle ); // Build a matrix which rotates around an arbitrary axis D3DXMATRIX* WINAPI D3DXMatrixRotationAxis ( D3DXMATRIX *pOut, CONST D3DXVECTOR3 *pV, FLOAT Angle ); // Build a matrix from a quaternion D3DXMATRIX* WINAPI D3DXMatrixRotationQuaternion ( D3DXMATRIX *pOut, CONST D3DXQUATERNION *pQ); // Yaw around the Y axis, a pitch around the X axis, // and a roll around the Z axis. D3DXMATRIX* WINAPI D3DXMatrixRotationYawPitchRoll ( D3DXMATRIX *pOut, FLOAT Yaw, FLOAT Pitch, FLOAT Roll ); // Build transformation matrix. NULL arguments are treated as identity. // Mout = Msc-1 * Msr-1 * Ms * Msr * Msc * Mrc-1 * Mr * Mrc * Mt D3DXMATRIX* WINAPI D3DXMatrixTransformation ( D3DXMATRIX *pOut, CONST D3DXVECTOR3 *pScalingCenter, CONST D3DXQUATERNION *pScalingRotation, CONST D3DXVECTOR3 *pScaling, CONST D3DXVECTOR3 *pRotationCenter, CONST D3DXQUATERNION *pRotation, CONST D3DXVECTOR3 *pTranslation); // Build 2D transformation matrix in XY plane. NULL arguments are treated as identity. // Mout = Msc-1 * Msr-1 * Ms * Msr * Msc * Mrc-1 * Mr * Mrc * Mt D3DXMATRIX* WINAPI D3DXMatrixTransformation2D ( D3DXMATRIX *pOut, CONST D3DXVECTOR2* pScalingCenter, FLOAT ScalingRotation, CONST D3DXVECTOR2* pScaling, CONST D3DXVECTOR2* pRotationCenter, FLOAT Rotation, CONST D3DXVECTOR2* pTranslation); // Build affine transformation matrix. NULL arguments are treated as identity. // Mout = Ms * Mrc-1 * Mr * Mrc * Mt D3DXMATRIX* WINAPI D3DXMatrixAffineTransformation ( D3DXMATRIX *pOut, FLOAT Scaling, CONST D3DXVECTOR3 *pRotationCenter, CONST D3DXQUATERNION *pRotation, CONST D3DXVECTOR3 *pTranslation); // Build 2D affine transformation matrix in XY plane. NULL arguments are treated as identity. // Mout = Ms * Mrc-1 * Mr * Mrc * Mt D3DXMATRIX* WINAPI D3DXMatrixAffineTransformation2D ( D3DXMATRIX *pOut, FLOAT Scaling, CONST D3DXVECTOR2* pRotationCenter, FLOAT Rotation, CONST D3DXVECTOR2* pTranslation); // Build a lookat matrix. (right-handed) D3DXMATRIX* WINAPI D3DXMatrixLookAtRH ( D3DXMATRIX *pOut, CONST D3DXVECTOR3 *pEye, CONST D3DXVECTOR3 *pAt, CONST D3DXVECTOR3 *pUp ); // Build a lookat matrix. (left-handed) D3DXMATRIX* WINAPI D3DXMatrixLookAtLH ( D3DXMATRIX *pOut, CONST D3DXVECTOR3 *pEye, CONST D3DXVECTOR3 *pAt, CONST D3DXVECTOR3 *pUp ); // Build a perspective projection matrix. (right-handed) D3DXMATRIX* WINAPI D3DXMatrixPerspectiveRH ( D3DXMATRIX *pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf ); // Build a perspective projection matrix. (left-handed) D3DXMATRIX* WINAPI D3DXMatrixPerspectiveLH ( D3DXMATRIX *pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf ); // Build a perspective projection matrix. (right-handed) D3DXMATRIX* WINAPI D3DXMatrixPerspectiveFovRH ( D3DXMATRIX *pOut, FLOAT fovy, FLOAT Aspect, FLOAT zn, FLOAT zf ); // Build a perspective projection matrix. (left-handed) D3DXMATRIX* WINAPI D3DXMatrixPerspectiveFovLH ( D3DXMATRIX *pOut, FLOAT fovy, FLOAT Aspect, FLOAT zn, FLOAT zf ); // Build a perspective projection matrix. (right-handed) D3DXMATRIX* WINAPI D3DXMatrixPerspectiveOffCenterRH ( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf ); // Build a perspective projection matrix. (left-handed) D3DXMATRIX* WINAPI D3DXMatrixPerspectiveOffCenterLH ( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf ); // Build an ortho projection matrix. (right-handed) D3DXMATRIX* WINAPI D3DXMatrixOrthoRH ( D3DXMATRIX *pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf ); // Build an ortho projection matrix. (left-handed) D3DXMATRIX* WINAPI D3DXMatrixOrthoLH ( D3DXMATRIX *pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf ); // Build an ortho projection matrix. (right-handed) D3DXMATRIX* WINAPI D3DXMatrixOrthoOffCenterRH ( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf ); // Build an ortho projection matrix. (left-handed) D3DXMATRIX* WINAPI D3DXMatrixOrthoOffCenterLH ( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf ); // Build a matrix which flattens geometry into a plane, as if casting // a shadow from a light. D3DXMATRIX* WINAPI D3DXMatrixShadow ( D3DXMATRIX *pOut, CONST D3DXVECTOR4 *pLight, CONST D3DXPLANE *pPlane ); // Build a matrix which reflects the coordinate system about a plane D3DXMATRIX* WINAPI D3DXMatrixReflect ( D3DXMATRIX *pOut, CONST D3DXPLANE *pPlane ); #ifdef __cplusplus } #endif //-------------------------- // Quaternion //-------------------------- // inline FLOAT D3DXQuaternionLength ( CONST D3DXQUATERNION *pQ ); // Length squared, or "norm" FLOAT D3DXQuaternionLengthSq ( CONST D3DXQUATERNION *pQ ); FLOAT D3DXQuaternionDot ( CONST D3DXQUATERNION *pQ1, CONST D3DXQUATERNION *pQ2 ); // (0, 0, 0, 1) D3DXQUATERNION* D3DXQuaternionIdentity ( D3DXQUATERNION *pOut ); BOOL D3DXQuaternionIsIdentity ( CONST D3DXQUATERNION *pQ ); // (-x, -y, -z, w) D3DXQUATERNION* D3DXQuaternionConjugate ( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ ); // non-inline #ifdef __cplusplus extern "C" { #endif // Compute a quaternin's axis and angle of rotation. Expects unit quaternions. void WINAPI D3DXQuaternionToAxisAngle ( CONST D3DXQUATERNION *pQ, D3DXVECTOR3 *pAxis, FLOAT *pAngle ); // Build a quaternion from a rotation matrix. D3DXQUATERNION* WINAPI D3DXQuaternionRotationMatrix ( D3DXQUATERNION *pOut, CONST D3DXMATRIX *pM); // Rotation about arbitrary axis. D3DXQUATERNION* WINAPI D3DXQuaternionRotationAxis ( D3DXQUATERNION *pOut, CONST D3DXVECTOR3 *pV, FLOAT Angle ); // Yaw around the Y axis, a pitch around the X axis, // and a roll around the Z axis. D3DXQUATERNION* WINAPI D3DXQuaternionRotationYawPitchRoll ( D3DXQUATERNION *pOut, FLOAT Yaw, FLOAT Pitch, FLOAT Roll ); // Quaternion multiplication. The result represents the rotation Q2 // followed by the rotation Q1. (Out = Q2 * Q1) D3DXQUATERNION* WINAPI D3DXQuaternionMultiply ( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ1, CONST D3DXQUATERNION *pQ2 ); D3DXQUATERNION* WINAPI D3DXQuaternionNormalize ( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ ); // Conjugate and re-norm D3DXQUATERNION* WINAPI D3DXQuaternionInverse ( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ ); // Expects unit quaternions. // if q = (cos(theta), sin(theta) * v); ln(q) = (0, theta * v) D3DXQUATERNION* WINAPI D3DXQuaternionLn ( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ ); // Expects pure quaternions. (w == 0) w is ignored in calculation. // if q = (0, theta * v); exp(q) = (cos(theta), sin(theta) * v) D3DXQUATERNION* WINAPI D3DXQuaternionExp ( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ ); // Spherical linear interpolation between Q1 (t == 0) and Q2 (t == 1). // Expects unit quaternions. D3DXQUATERNION* WINAPI D3DXQuaternionSlerp ( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ1, CONST D3DXQUATERNION *pQ2, FLOAT t ); // Spherical quadrangle interpolation. // Slerp(Slerp(Q1, C, t), Slerp(A, B, t), 2t(1-t)) D3DXQUATERNION* WINAPI D3DXQuaternionSquad ( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ1, CONST D3DXQUATERNION *pA, CONST D3DXQUATERNION *pB, CONST D3DXQUATERNION *pC, FLOAT t ); // Setup control points for spherical quadrangle interpolation // from Q1 to Q2. The control points are chosen in such a way // to ensure the continuity of tangents with adjacent segments. void WINAPI D3DXQuaternionSquadSetup ( D3DXQUATERNION *pAOut, D3DXQUATERNION *pBOut, D3DXQUATERNION *pCOut, CONST D3DXQUATERNION *pQ0, CONST D3DXQUATERNION *pQ1, CONST D3DXQUATERNION *pQ2, CONST D3DXQUATERNION *pQ3 ); // Barycentric interpolation. // Slerp(Slerp(Q1, Q2, f+g), Slerp(Q1, Q3, f+g), g/(f+g)) D3DXQUATERNION* WINAPI D3DXQuaternionBaryCentric ( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ1, CONST D3DXQUATERNION *pQ2, CONST D3DXQUATERNION *pQ3, FLOAT f, FLOAT g ); #ifdef __cplusplus } #endif //-------------------------- // Plane //-------------------------- // inline // ax + by + cz + dw FLOAT D3DXPlaneDot ( CONST D3DXPLANE *pP, CONST D3DXVECTOR4 *pV); // ax + by + cz + d FLOAT D3DXPlaneDotCoord ( CONST D3DXPLANE *pP, CONST D3DXVECTOR3 *pV); // ax + by + cz FLOAT D3DXPlaneDotNormal ( CONST D3DXPLANE *pP, CONST D3DXVECTOR3 *pV); D3DXPLANE* D3DXPlaneScale (D3DXPLANE *pOut, CONST D3DXPLANE *pP, FLOAT s); // non-inline #ifdef __cplusplus extern "C" { #endif // Normalize plane (so that |a,b,c| == 1) D3DXPLANE* WINAPI D3DXPlaneNormalize ( D3DXPLANE *pOut, CONST D3DXPLANE *pP); // Find the intersection between a plane and a line. If the line is // parallel to the plane, NULL is returned. D3DXVECTOR3* WINAPI D3DXPlaneIntersectLine ( D3DXVECTOR3 *pOut, CONST D3DXPLANE *pP, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2); // Construct a plane from a point and a normal D3DXPLANE* WINAPI D3DXPlaneFromPointNormal ( D3DXPLANE *pOut, CONST D3DXVECTOR3 *pPoint, CONST D3DXVECTOR3 *pNormal); // Construct a plane from 3 points D3DXPLANE* WINAPI D3DXPlaneFromPoints ( D3DXPLANE *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2, CONST D3DXVECTOR3 *pV3); // Transform a plane by a matrix. The vector (a,b,c) must be normal. // M should be the inverse transpose of the transformation desired. D3DXPLANE* WINAPI D3DXPlaneTransform ( D3DXPLANE *pOut, CONST D3DXPLANE *pP, CONST D3DXMATRIX *pM ); // Transform an array of planes by a matrix. The vectors (a,b,c) must be normal. // M should be the inverse transpose of the transformation desired. D3DXPLANE* WINAPI D3DXPlaneTransformArray ( D3DXPLANE *pOut, UINT OutStride, CONST D3DXPLANE *pP, UINT PStride, CONST D3DXMATRIX *pM, UINT n ); #ifdef __cplusplus } #endif //-------------------------- // Color //-------------------------- // inline // (1-r, 1-g, 1-b, a) D3DXCOLOR* D3DXColorNegative (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC); D3DXCOLOR* D3DXColorAdd (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2); D3DXCOLOR* D3DXColorSubtract (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2); D3DXCOLOR* D3DXColorScale (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC, FLOAT s); // (r1*r2, g1*g2, b1*b2, a1*a2) D3DXCOLOR* D3DXColorModulate (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2); // Linear interpolation of r,g,b, and a. C1 + s(C2-C1) D3DXCOLOR* D3DXColorLerp (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2, FLOAT s); // non-inline #ifdef __cplusplus extern "C" { #endif // Interpolate r,g,b between desaturated color and color. // DesaturatedColor + s(Color - DesaturatedColor) D3DXCOLOR* WINAPI D3DXColorAdjustSaturation (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC, FLOAT s); // Interpolate r,g,b between 50% grey and color. Grey + s(Color - Grey) D3DXCOLOR* WINAPI D3DXColorAdjustContrast (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC, FLOAT c); #ifdef __cplusplus } #endif //-------------------------- // Misc //-------------------------- #ifdef __cplusplus extern "C" { #endif // Calculate Fresnel term given the cosine of theta (likely obtained by // taking the dot of two normals), and the refraction index of the material. FLOAT WINAPI D3DXFresnelTerm (FLOAT CosTheta, FLOAT RefractionIndex); #ifdef __cplusplus } #endif //=========================================================================== // // Matrix Stack // //=========================================================================== typedef interface ID3DXMatrixStack ID3DXMatrixStack; typedef interface ID3DXMatrixStack *LPD3DXMATRIXSTACK; // {C7885BA7-F990-4fe7-922D-8515E477DD85} DEFINE_GUID(IID_ID3DXMatrixStack, 0xc7885ba7, 0xf990, 0x4fe7, 0x92, 0x2d, 0x85, 0x15, 0xe4, 0x77, 0xdd, 0x85); #undef INTERFACE #define INTERFACE ID3DXMatrixStack DECLARE_INTERFACE_(ID3DXMatrixStack, IUnknown) { // // IUnknown methods // STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; STDMETHOD_(ULONG,AddRef)(THIS) PURE; STDMETHOD_(ULONG,Release)(THIS) PURE; // // ID3DXMatrixStack methods // // Pops the top of the stack, returns the current top // *after* popping the top. STDMETHOD(Pop)(THIS) PURE; // Pushes the stack by one, duplicating the current matrix. STDMETHOD(Push)(THIS) PURE; // Loads identity in the current matrix. STDMETHOD(LoadIdentity)(THIS) PURE; // Loads the given matrix into the current matrix STDMETHOD(LoadMatrix)(THIS_ CONST D3DXMATRIX* pM ) PURE; // Right-Multiplies the given matrix to the current matrix. // (transformation is about the current world origin) STDMETHOD(MultMatrix)(THIS_ CONST D3DXMATRIX* pM ) PURE; // Left-Multiplies the given matrix to the current matrix // (transformation is about the local origin of the object) STDMETHOD(MultMatrixLocal)(THIS_ CONST D3DXMATRIX* pM ) PURE; // Right multiply the current matrix with the computed rotation // matrix, counterclockwise about the given axis with the given angle. // (rotation is about the current world origin) STDMETHOD(RotateAxis) (THIS_ CONST D3DXVECTOR3* pV, FLOAT Angle) PURE; // Left multiply the current matrix with the computed rotation // matrix, counterclockwise about the given axis with the given angle. // (rotation is about the local origin of the object) STDMETHOD(RotateAxisLocal) (THIS_ CONST D3DXVECTOR3* pV, FLOAT Angle) PURE; // Right multiply the current matrix with the computed rotation // matrix. All angles are counterclockwise. (rotation is about the // current world origin) // The rotation is composed of a yaw around the Y axis, a pitch around // the X axis, and a roll around the Z axis. STDMETHOD(RotateYawPitchRoll) (THIS_ FLOAT Yaw, FLOAT Pitch, FLOAT Roll) PURE; // Left multiply the current matrix with the computed rotation // matrix. All angles are counterclockwise. (rotation is about the // local origin of the object) // The rotation is composed of a yaw around the Y axis, a pitch around // the X axis, and a roll around the Z axis. STDMETHOD(RotateYawPitchRollLocal) (THIS_ FLOAT Yaw, FLOAT Pitch, FLOAT Roll) PURE; // Right multiply the current matrix with the computed scale // matrix. (transformation is about the current world origin) STDMETHOD(Scale)(THIS_ FLOAT x, FLOAT y, FLOAT z) PURE; // Left multiply the current matrix with the computed scale // matrix. (transformation is about the local origin of the object) STDMETHOD(ScaleLocal)(THIS_ FLOAT x, FLOAT y, FLOAT z) PURE; // Right multiply the current matrix with the computed translation // matrix. (transformation is about the current world origin) STDMETHOD(Translate)(THIS_ FLOAT x, FLOAT y, FLOAT z ) PURE; // Left multiply the current matrix with the computed translation // matrix. (transformation is about the local origin of the object) STDMETHOD(TranslateLocal)(THIS_ FLOAT x, FLOAT y, FLOAT z) PURE; // Obtain the current matrix at the top of the stack STDMETHOD_(D3DXMATRIX*, GetTop)(THIS) PURE; }; #ifdef __cplusplus extern "C" { #endif HRESULT WINAPI D3DXCreateMatrixStack( DWORD Flags, LPD3DXMATRIXSTACK* ppStack); #ifdef __cplusplus } #endif //=========================================================================== // // Spherical Harmonic Runtime Routines // // NOTE: // * Most of these functions can take the same object as in and out parameters. // The exceptions are the rotation functions. // // * Out parameters are typically also returned as return values, so that // the output of one function may be used as a parameter to another. // //============================================================================ // non-inline #ifdef __cplusplus extern "C" { #endif //============================================================================ // // Basic Spherical Harmonic math routines // //============================================================================ #define D3DXSH_MINORDER 2 #define D3DXSH_MAXORDER 6 //============================================================================ // // D3DXSHEvalDirection: // -------------------- // Evaluates the Spherical Harmonic basis functions // // Parameters: // pOut // Output SH coefficients - basis function Ylm is stored at l*l + m+l // This is the pointer that is returned. // Order // Order of the SH evaluation, generates Order^2 coefs, degree is Order-1 // pDir // Direction to evaluate in - assumed to be normalized // //============================================================================ FLOAT* WINAPI D3DXSHEvalDirection ( FLOAT *pOut, UINT Order, CONST D3DXVECTOR3 *pDir ); //============================================================================ // // D3DXSHRotate: // -------------------- // Rotates SH vector by a rotation matrix // // Parameters: // pOut // Output SH coefficients - basis function Ylm is stored at l*l + m+l // This is the pointer that is returned (should not alias with pIn.) // Order // Order of the SH evaluation, generates Order^2 coefs, degree is Order-1 // pMatrix // Matrix used for rotation - rotation sub matrix should be orthogonal // and have a unit determinant. // pIn // Input SH coeffs (rotated), incorect results if this is also output. // //============================================================================ FLOAT* WINAPI D3DXSHRotate ( FLOAT *pOut, UINT Order, CONST D3DXMATRIX *pMatrix, CONST FLOAT *pIn ); //============================================================================ // // D3DXSHRotateZ: // -------------------- // Rotates the SH vector in the Z axis by an angle // // Parameters: // pOut // Output SH coefficients - basis function Ylm is stored at l*l + m+l // This is the pointer that is returned (should not alias with pIn.) // Order // Order of the SH evaluation, generates Order^2 coefs, degree is Order-1 // Angle // Angle in radians to rotate around the Z axis. // pIn // Input SH coeffs (rotated), incorect results if this is also output. // //============================================================================ FLOAT* WINAPI D3DXSHRotateZ ( FLOAT *pOut, UINT Order, FLOAT Angle, CONST FLOAT *pIn ); //============================================================================ // // D3DXSHAdd: // -------------------- // Adds two SH vectors, pOut[i] = pA[i] + pB[i]; // // Parameters: // pOut // Output SH coefficients - basis function Ylm is stored at l*l + m+l // This is the pointer that is returned. // Order // Order of the SH evaluation, generates Order^2 coefs, degree is Order-1 // pA // Input SH coeffs. // pB // Input SH coeffs (second vector.) // //============================================================================ FLOAT* WINAPI D3DXSHAdd ( FLOAT *pOut, UINT Order, CONST FLOAT *pA, CONST FLOAT *pB ); //============================================================================ // // D3DXSHScale: // -------------------- // Adds two SH vectors, pOut[i] = pA[i]*Scale; // // Parameters: // pOut // Output SH coefficients - basis function Ylm is stored at l*l + m+l // This is the pointer that is returned. // Order // Order of the SH evaluation, generates Order^2 coefs, degree is Order-1 // pIn // Input SH coeffs. // Scale // Scale factor. // //============================================================================ FLOAT* WINAPI D3DXSHScale ( FLOAT *pOut, UINT Order, CONST FLOAT *pIn, CONST FLOAT Scale ); //============================================================================ // // D3DXSHDot: // -------------------- // Computes the dot product of two SH vectors // // Parameters: // Order // Order of the SH evaluation, generates Order^2 coefs, degree is Order-1 // pA // Input SH coeffs. // pB // Second set of input SH coeffs. // //============================================================================ FLOAT WINAPI D3DXSHDot ( UINT Order, CONST FLOAT *pA, CONST FLOAT *pB ); //============================================================================ // // Basic Spherical Harmonic lighting routines // //============================================================================ //============================================================================ // // D3DXSHEvalDirectionalLight: // -------------------- // Evaluates a directional light and returns spectral SH data. The output // vector is computed so that if the intensity of R/G/B is unit the resulting // exit radiance of a point directly under the light on a diffuse object with // an albedo of 1 would be 1.0. This will compute 3 spectral samples, pROut // has to be specified, while pGout and pBout are optional. // // Parameters: // Order // Order of the SH evaluation, generates Order^2 coefs, degree is Order-1 // pDir // Direction light is coming from (assumed to be normalized.) // RIntensity // Red intensity of light. // GIntensity // Green intensity of light. // BIntensity // Blue intensity of light. // pROut // Output SH vector for Red. // pGOut // Output SH vector for Green (optional.) // pBOut // Output SH vector for Blue (optional.) // //============================================================================ HRESULT WINAPI D3DXSHEvalDirectionalLight ( UINT Order, CONST D3DXVECTOR3 *pDir, FLOAT RIntensity, FLOAT GIntensity, FLOAT BIntensity, FLOAT *pROut, FLOAT *pGOut, FLOAT *pBOut ); //============================================================================ // // D3DXSHEvalSphericalLight: // -------------------- // Evaluates a spherical light and returns spectral SH data. There is no // normalization of the intensity of the light like there is for directional // lights, care has to be taken when specifiying the intensities. This will // compute 3 spectral samples, pROut has to be specified, while pGout and // pBout are optional. // // Parameters: // Order // Order of the SH evaluation, generates Order^2 coefs, degree is Order-1 // pPos // Position of light - reciever is assumed to be at the origin. // Radius // Radius of the spherical light source. // RIntensity // Red intensity of light. // GIntensity // Green intensity of light. // BIntensity // Blue intensity of light. // pROut // Output SH vector for Red. // pGOut // Output SH vector for Green (optional.) // pBOut // Output SH vector for Blue (optional.) // //============================================================================ HRESULT WINAPI D3DXSHEvalSphericalLight ( UINT Order, CONST D3DXVECTOR3 *pPos, FLOAT Radius, FLOAT RIntensity, FLOAT GIntensity, FLOAT BIntensity, FLOAT *pROut, FLOAT *pGOut, FLOAT *pBOut ); //============================================================================ // // D3DXSHEvalConeLight: // -------------------- // Evaluates a light that is a cone of constant intensity and returns spectral // SH data. The output vector is computed so that if the intensity of R/G/B is // unit the resulting exit radiance of a point directly under the light oriented // in the cone direction on a diffuse object with an albedo of 1 would be 1.0. // This will compute 3 spectral samples, pROut has to be specified, while pGout // and pBout are optional. // // Parameters: // Order // Order of the SH evaluation, generates Order^2 coefs, degree is Order-1 // pDir // Direction light is coming from (assumed to be normalized.) // Radius // Radius of cone in radians. // RIntensity // Red intensity of light. // GIntensity // Green intensity of light. // BIntensity // Blue intensity of light. // pROut // Output SH vector for Red. // pGOut // Output SH vector for Green (optional.) // pBOut // Output SH vector for Blue (optional.) // //============================================================================ HRESULT WINAPI D3DXSHEvalConeLight ( UINT Order, CONST D3DXVECTOR3 *pDir, FLOAT Radius, FLOAT RIntensity, FLOAT GIntensity, FLOAT BIntensity, FLOAT *pROut, FLOAT *pGOut, FLOAT *pBOut ); //============================================================================ // // D3DXSHEvalHemisphereLight: // -------------------- // Evaluates a light that is a linear interpolant between two colors over the // sphere. The interpolant is linear along the axis of the two points, not // over the surface of the sphere (ie: if the axis was (0,0,1) it is linear in // Z, not in the azimuthal angle.) The resulting spherical lighting function // is normalized so that a point on a perfectly diffuse surface with no // shadowing and a normal pointed in the direction pDir would result in exit // radiance with a value of 1 if the top color was white and the bottom color // was black. This is a very simple model where Top represents the intensity // of the "sky" and Bottom represents the intensity of the "ground". // // Parameters: // Order // Order of the SH evaluation, generates Order^2 coefs, degree is Order-1 // pDir // Axis of the hemisphere. // Top // Color of the upper hemisphere. // Bottom // Color of the lower hemisphere. // pROut // Output SH vector for Red. // pGOut // Output SH vector for Green // pBOut // Output SH vector for Blue // //============================================================================ HRESULT WINAPI D3DXSHEvalHemisphereLight ( UINT Order, CONST D3DXVECTOR3 *pDir, D3DXCOLOR Top, D3DXCOLOR Bottom, FLOAT *pROut, FLOAT *pGOut, FLOAT *pBOut ); //============================================================================ // // Basic Spherical Harmonic projection routines // //============================================================================ //============================================================================ // // D3DXSHProjectCubeMap: // -------------------- // Projects a function represented on a cube map into spherical harmonics. // // Parameters: // Order // Order of the SH evaluation, generates Order^2 coefs, degree is Order-1 // pCubeMap // CubeMap that is going to be projected into spherical harmonics // pROut // Output SH vector for Red. // pGOut // Output SH vector for Green // pBOut // Output SH vector for Blue // //============================================================================ HRESULT WINAPI D3DXSHProjectCubeMap ( UINT uOrder, LPDIRECT3DCUBETEXTURE9 pCubeMap, FLOAT *pROut, FLOAT *pGOut, FLOAT *pBOut ); #ifdef __cplusplus } #endif #include "d3dx9math.inl" #if _MSC_VER >= 1200 #pragma warning(pop) #else #pragma warning(default:4201) #endif #endif // __D3DX9MATH_H__