text: //////////////////////////////////////////////////////////////////////////////
  //
  //  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 <math.h>
  #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      (-14)            // 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);
  
  	//============================================================================
  	//
  	//  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.
  	//
  	//============================================================================
  
  	FLOAT* WINAPI D3DXSHMultiply2(FLOAT *pOut, CONST FLOAT *pF, CONST FLOAT *pG);
  	FLOAT* WINAPI D3DXSHMultiply3(FLOAT *pOut, CONST FLOAT *pF, CONST FLOAT *pG);
  	FLOAT* WINAPI D3DXSHMultiply4(FLOAT *pOut, CONST FLOAT *pF, CONST FLOAT *pG);
  	FLOAT* WINAPI D3DXSHMultiply5(FLOAT *pOut, CONST FLOAT *pF, CONST FLOAT *pG);
  	FLOAT* WINAPI D3DXSHMultiply6(FLOAT *pOut, CONST FLOAT *pF, 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,
  		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__