d3dx10math.h

Go to the documentation of this file.

//
// Copyright (C) Microsoft Corporation. All Rights Reserved.
//
// File: D3DX10math.h
// Content: D3DX10 math types and functions
//

#include "d3dx10.h"

// D3DX10 and D3DX9 math look the same. You can include either one into your project.
// We are intentionally using the header define from D3DX9 math to prevent double-inclusion.
#ifndef __D3DX9MATH_H__
#define __D3DX9MATH_H__

#include <math.h>
#if _MSC_VER >= 1200
#pragma warning(push)
#endif
#pragma warning(disable:4201) // anonymous unions warning

//===========================================================================
//
// Type definitions from D3D9
//
//===========================================================================

#ifndef D3DVECTOR_DEFINED
typedef struct _D3DVECTOR {
 float x;
 float y;
 float z;
} D3DVECTOR;
#define D3DVECTOR_DEFINED
#endif

#ifndef D3DMATRIX_DEFINED
typedef struct _D3DMATRIX {
 union {
 struct {
 float _11, _12, _13, _14;
 float _21, _22, _23, _24;
 float _31, _32, _33, _34;
 float _41, _42, _43, _44;

 };
 float m[4][4];
 };
} D3DMATRIX;
#define D3DMATRIX_DEFINED
#endif

//===========================================================================
//
// General purpose utilities
//
//===========================================================================
#define D3DX_PI (3.14159265358979323846)
#define D3DX_1BYPI ( 1.0 / D3DX_PI )

#define D3DXToRadian( degree ) ((degree) * (D3DX_PI / 180.0))
#define D3DXToDegree( radian ) ((radian) * (180.0 / 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 (-14) // min binary exponent
#define D3DX_16F_RADIX 2 // exponent radix
#define D3DX_16F_ROUNDS 1 // addition rounding: near
#define D3DX_16F_SIGN_MASK 0x8000
#define D3DX_16F_EXP_MASK 0x7C00
#define D3DX_16F_FRAC_MASK 0x03FF

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 
typedef struct _D3DVECTOR D3DXVECTOR3, *LPD3DXVECTOR3;
#endif 



//--------------------------
// 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 
typedef struct _D3DMATRIX D3DXMATRIX, *LPD3DXMATRIX;
#endif 


//---------------------------------------------------------------------------
// 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 
typedef D3DXMATRIX _D3DXMATRIXA16;
#endif 



#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( UINT argb );
 D3DXCOLOR( CONST FLOAT * );
 D3DXCOLOR( CONST D3DXFLOAT16 * );
 D3DXCOLOR( FLOAT r, FLOAT g, FLOAT b, FLOAT a );

 // casting
 operator UINT () const;

 operator FLOAT* ();
 operator CONST FLOAT* () 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
 ( __out_ecount(n) FLOAT *pOut, __in_ecount(n) 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 D3D10_VIEWPORT *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 D3D10_VIEWPORT *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 D3D10_VIEWPORT *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 D3D10_VIEWPORT *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( 
 UINT Flags, 
 LPD3DXMATRIXSTACK* ppStack);

#ifdef __cplusplus
}
#endif

// 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
 ( __out_ecount(Order*Order) 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
 ( __out_ecount(Order*Order) 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
 ( __out_ecount(Order*Order) 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 );

//============================================================================
//
// D3DXSHMultiply[O]:
// --------------------
// Computes the product of two functions represented using SH (f and g), where:
// pOut[i] = int(y_i(s) * f(s) * g(s)), where y_i(s) is the ith SH basis
// function, f(s) and g(s) are SH functions (sum_i(y_i(s)*c_i)). The order O
// determines the lengths of the arrays, where there should always be O^2 
// coefficients. In general the product of two SH functions of order O generates
// and SH function of order 2*O - 1, but we truncate the result. This means
// that the product commutes (f*g == g*f) but doesn't associate 
// (f*(g*h) != (f*g)*h.
//
// Parameters:
// pOut
// Output SH coefficients - basis function Ylm is stored at l*l + m+l
// This is the pointer that is returned.
// pF
// Input SH coeffs for first function.
// pG
// Second set of input SH coeffs.
//
//============================================================================

__out_ecount(4) FLOAT* WINAPI D3DXSHMultiply2(__out_ecount(4) FLOAT *pOut,__in_ecount(4) CONST FLOAT *pF,__in_ecount(4) CONST FLOAT *pG);
__out_ecount(9) FLOAT* WINAPI D3DXSHMultiply3(__out_ecount(9) FLOAT *pOut,__in_ecount(9) CONST FLOAT *pF,__in_ecount(9) CONST FLOAT *pG);
__out_ecount(16) FLOAT* WINAPI D3DXSHMultiply4(__out_ecount(16) FLOAT *pOut,__in_ecount(16) CONST FLOAT *pF,__in_ecount(16) CONST FLOAT *pG);
__out_ecount(25) FLOAT* WINAPI D3DXSHMultiply5(__out_ecount(25) FLOAT *pOut,__in_ecount(25) CONST FLOAT *pF,__in_ecount(25) CONST FLOAT *pG);
__out_ecount(36) FLOAT* WINAPI D3DXSHMultiply6(__out_ecount(36) FLOAT *pOut,__in_ecount(36) CONST FLOAT *pF,__in_ecount(36) CONST FLOAT *pG);


//============================================================================
//
// 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,
 __out_ecount_opt(Order*Order) FLOAT *pROut, 
 __out_ecount_opt(Order*Order) FLOAT *pGOut, 
 __out_ecount_opt(Order*Order) 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,
 __out_ecount_opt(Order*Order) FLOAT *pROut, 
 __out_ecount_opt(Order*Order) FLOAT *pGOut, 
 __out_ecount_opt(Order*Order) 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,
 __out_ecount_opt(Order*Order) FLOAT *pROut, 
 __out_ecount_opt(Order*Order) FLOAT *pGOut, 
 __out_ecount_opt(Order*Order) 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,
 __out_ecount_opt(Order*Order) FLOAT *pROut, 
 __out_ecount_opt(Order*Order) FLOAT *pGOut, 
 __out_ecount_opt(Order*Order) FLOAT *pBOut );

// Math intersection functions

BOOL WINAPI D3DXIntersectTri 
(
 CONST D3DXVECTOR3 *p0, // Triangle vertex 0 position
 CONST D3DXVECTOR3 *p1, // Triangle vertex 1 position
 CONST D3DXVECTOR3 *p2, // Triangle vertex 2 position
 CONST D3DXVECTOR3 *pRayPos, // Ray origin
 CONST D3DXVECTOR3 *pRayDir, // Ray direction
 FLOAT *pU, // Barycentric Hit Coordinates
 FLOAT *pV, // Barycentric Hit Coordinates
 FLOAT *pDist); // Ray-Intersection Parameter Distance

BOOL WINAPI
 D3DXSphereBoundProbe(
 CONST D3DXVECTOR3 *pCenter,
 FLOAT Radius,
 CONST D3DXVECTOR3 *pRayPosition,
 CONST D3DXVECTOR3 *pRayDirection);

BOOL WINAPI 
 D3DXBoxBoundProbe(
 CONST D3DXVECTOR3 *pMin, 
 CONST D3DXVECTOR3 *pMax,
 CONST D3DXVECTOR3 *pRayPosition,
 CONST D3DXVECTOR3 *pRayDirection);

HRESULT WINAPI 
 D3DXComputeBoundingSphere(
 CONST D3DXVECTOR3 *pFirstPosition, // pointer to first position
 DWORD NumVertices, 
 DWORD dwStride, // count in bytes to subsequent position vectors
 D3DXVECTOR3 *pCenter, 
 FLOAT *pRadius);

HRESULT WINAPI 
 D3DXComputeBoundingBox(
 CONST D3DXVECTOR3 *pFirstPosition, // pointer to first position
 DWORD NumVertices, 
 DWORD dwStride, // count in bytes to subsequent position vectors
 D3DXVECTOR3 *pMin, 
 D3DXVECTOR3 *pMax);


// CPU Optimization:

//-------------------------------------------------------------------------
// D3DX_CPU_OPTIMIZATION flags:
// ----------------------------
// D3DX_NOT_OPTIMIZED Use Intel Pentium optimizations
// D3DX_3DNOW_OPTIMIZED Use AMD 3DNow optimizations
// D3DX_SSE_OPTIMIZED Use Intel Pentium III SSE optimizations
// D3DX_SSE2_OPTIMIZED Use Intel Pentium IV SSE2 optimizations
//-------------------------------------------------------------------------


typedef enum _D3DX_CPU_OPTIMIZATION
{
 D3DX_NOT_OPTIMIZED = 0,
 D3DX_3DNOW_OPTIMIZED,
 D3DX_SSE2_OPTIMIZED,
 D3DX_SSE_OPTIMIZED
} D3DX_CPU_OPTIMIZATION;


//-------------------------------------------------------------------------
// D3DXCpuOptimizations:
// ---------------------
// Enables or disables CPU optimizations. Returns the type of CPU, which 
// was detected, and for which optimizations exist.
//
// Parameters:
// Enable
// TRUE to enable CPU optimizations. FALSE to disable.
//-------------------------------------------------------------------------

D3DX_CPU_OPTIMIZATION WINAPI 
 D3DXCpuOptimizations(BOOL Enable);

#ifdef __cplusplus
}
#endif


#include "d3dx10math.inl"

#if _MSC_VER >= 1200
#pragma warning(pop)
#else
#pragma warning(default:4201)
#endif

#endif // __D3DX9MATH_H__