开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
d3dx8math.h
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：37k
源码类别：

模拟服务器

开发平台：

C/C++

d3dx8math.h：源码内容
  1. //////////////////////////////////////////////////////////////////////////////
  2. //
  3. //  Copyright (C) Microsoft Corporation.  All Rights Reserved.
  4. //
  5. //  File:       d3dx8math.h
  6. //  Content:    D3DX math types and functions
  7. //
  8. //////////////////////////////////////////////////////////////////////////////
  10. #include "d3dx8.h"
  12. #ifndef __D3DX8MATH_H__
  13. #define __D3DX8MATH_H__
  15. #include <math.h>
  16. #pragma warning(disable:4201) // anonymous unions warning
  20. //===========================================================================
  21. //
  22. // General purpose utilities
  23. //
  24. //===========================================================================
  25. #define D3DX_PI    ((FLOAT)  3.141592654f)
  26. #define D3DX_1BYPI ((FLOAT)  0.318309886f)
  28. #define D3DXToRadian( degree ) ((degree) * (D3DX_PI / 180.0f))
  29. #define D3DXToDegree( radian ) ((radian) * (180.0f / D3DX_PI))
  33. //===========================================================================
  34. //
  35. // Vectors
  36. //
  37. //===========================================================================
  39. //--------------------------
  40. // 2D Vector
  41. //--------------------------
  42. typedef struct D3DXVECTOR2
  43. {
  44. #ifdef __cplusplus
  45. public:
  46.     D3DXVECTOR2() {};
  47.     D3DXVECTOR2( CONST FLOAT * );
  48.     D3DXVECTOR2( FLOAT x, FLOAT y );
  50.     // casting
  51.     operator FLOAT* ();
  52.     operator CONST FLOAT* () const;
  54.     // assignment operators
  55.     D3DXVECTOR2& operator += ( CONST D3DXVECTOR2& );
  56.     D3DXVECTOR2& operator -= ( CONST D3DXVECTOR2& );
  57.     D3DXVECTOR2& operator *= ( FLOAT );
  58.     D3DXVECTOR2& operator /= ( FLOAT );
  60.     // unary operators
  61.     D3DXVECTOR2 operator + () const;
  62.     D3DXVECTOR2 operator - () const;
  64.     // binary operators
  65.     D3DXVECTOR2 operator + ( CONST D3DXVECTOR2& ) const;
  66.     D3DXVECTOR2 operator - ( CONST D3DXVECTOR2& ) const;
  67.     D3DXVECTOR2 operator * ( FLOAT ) const;
  68.     D3DXVECTOR2 operator / ( FLOAT ) const;
  70.     friend D3DXVECTOR2 operator * ( FLOAT, CONST D3DXVECTOR2& );
  72.     BOOL operator == ( CONST D3DXVECTOR2& ) const;
  73.     BOOL operator != ( CONST D3DXVECTOR2& ) const;
  76. public:
  77. #endif //__cplusplus
  78.     FLOAT x, y;
  79. } D3DXVECTOR2, *LPD3DXVECTOR2;
  82. //--------------------------
  83. // 3D Vector
  84. //--------------------------
  85. #ifdef __cplusplus
  86. typedef struct D3DXVECTOR3 : public D3DVECTOR
  87. {
  88. public:
  89.     D3DXVECTOR3() {};
  90.     D3DXVECTOR3( CONST FLOAT * );
  91.     D3DXVECTOR3( CONST D3DVECTOR& );
  92.     D3DXVECTOR3( FLOAT x, FLOAT y, FLOAT z );
  94.     // casting
  95.     operator FLOAT* ();
  96.     operator CONST FLOAT* () const;
  98.     // assignment operators
  99.     D3DXVECTOR3& operator += ( CONST D3DXVECTOR3& );
  100.     D3DXVECTOR3& operator -= ( CONST D3DXVECTOR3& );
  101.     D3DXVECTOR3& operator *= ( FLOAT );
  102.     D3DXVECTOR3& operator /= ( FLOAT );
  104.     // unary operators
  105.     D3DXVECTOR3 operator + () const;
  106.     D3DXVECTOR3 operator - () const;
  108.     // binary operators
  109.     D3DXVECTOR3 operator + ( CONST D3DXVECTOR3& ) const;
  110.     D3DXVECTOR3 operator - ( CONST D3DXVECTOR3& ) const;
  111.     D3DXVECTOR3 operator * ( FLOAT ) const;
  112.     D3DXVECTOR3 operator / ( FLOAT ) const;
  114.     friend D3DXVECTOR3 operator * ( FLOAT, CONST struct D3DXVECTOR3& );
  116.     BOOL operator == ( CONST D3DXVECTOR3& ) const;
  117.     BOOL operator != ( CONST D3DXVECTOR3& ) const;
  119. } D3DXVECTOR3, *LPD3DXVECTOR3;
  121. #else //!__cplusplus
  122. typedef struct _D3DVECTOR D3DXVECTOR3, *LPD3DXVECTOR3;
  123. #endif //!__cplusplus
  126. //--------------------------
  127. // 4D Vector
  128. //--------------------------
  129. typedef struct D3DXVECTOR4
  130. {
  131. #ifdef __cplusplus
  132. public:
  133.     D3DXVECTOR4() {};
  134.     D3DXVECTOR4( CONST FLOAT* );
  135.     D3DXVECTOR4( FLOAT x, FLOAT y, FLOAT z, FLOAT w );
  137.     // casting
  138.     operator FLOAT* ();
  139.     operator CONST FLOAT* () const;
  141.     // assignment operators
  142.     D3DXVECTOR4& operator += ( CONST D3DXVECTOR4& );
  143.     D3DXVECTOR4& operator -= ( CONST D3DXVECTOR4& );
  144.     D3DXVECTOR4& operator *= ( FLOAT );
  145.     D3DXVECTOR4& operator /= ( FLOAT );
  147.     // unary operators
  148.     D3DXVECTOR4 operator + () const;
  149.     D3DXVECTOR4 operator - () const;
  151.     // binary operators
  152.     D3DXVECTOR4 operator + ( CONST D3DXVECTOR4& ) const;
  153.     D3DXVECTOR4 operator - ( CONST D3DXVECTOR4& ) const;
  154.     D3DXVECTOR4 operator * ( FLOAT ) const;
  155.     D3DXVECTOR4 operator / ( FLOAT ) const;
  157.     friend D3DXVECTOR4 operator * ( FLOAT, CONST D3DXVECTOR4& );
  159.     BOOL operator == ( CONST D3DXVECTOR4& ) const;
  160.     BOOL operator != ( CONST D3DXVECTOR4& ) const;
  162. public:
  163. #endif //__cplusplus
  164.     FLOAT x, y, z, w;
  165. } D3DXVECTOR4, *LPD3DXVECTOR4;
  168. //===========================================================================
  169. //
  170. // Matrices
  171. //
  172. //===========================================================================
  173. #ifdef __cplusplus
  174. typedef struct D3DXMATRIX : public D3DMATRIX
  175. {
  176. public:
  177.     D3DXMATRIX() {};
  178.     D3DXMATRIX( CONST FLOAT * );
  179.     D3DXMATRIX( CONST D3DMATRIX& );
  180.     D3DXMATRIX( FLOAT _11, FLOAT _12, FLOAT _13, FLOAT _14,
  181.                 FLOAT _21, FLOAT _22, FLOAT _23, FLOAT _24,
  182.                 FLOAT _31, FLOAT _32, FLOAT _33, FLOAT _34,
  183.                 FLOAT _41, FLOAT _42, FLOAT _43, FLOAT _44 );
  186.     // access grants
  187.     FLOAT& operator () ( UINT Row, UINT Col );
  188.     FLOAT  operator () ( UINT Row, UINT Col ) const;
  190.     // casting operators
  191.     operator FLOAT* ();
  192.     operator CONST FLOAT* () const;
  194.     // assignment operators
  195.     D3DXMATRIX& operator *= ( CONST D3DXMATRIX& );
  196.     D3DXMATRIX& operator += ( CONST D3DXMATRIX& );
  197.     D3DXMATRIX& operator -= ( CONST D3DXMATRIX& );
  198.     D3DXMATRIX& operator *= ( FLOAT );
  199.     D3DXMATRIX& operator /= ( FLOAT );
  201.     // unary operators
  202.     D3DXMATRIX operator + () const;
  203.     D3DXMATRIX operator - () const;
  205.     // binary operators
  206.     D3DXMATRIX operator * ( CONST D3DXMATRIX& ) const;
  207.     D3DXMATRIX operator + ( CONST D3DXMATRIX& ) const;
  208.     D3DXMATRIX operator - ( CONST D3DXMATRIX& ) const;
  209.     D3DXMATRIX operator * ( FLOAT ) const;
  210.     D3DXMATRIX operator / ( FLOAT ) const;
  212.     friend D3DXMATRIX operator * ( FLOAT, CONST D3DXMATRIX& );
  214.     BOOL operator == ( CONST D3DXMATRIX& ) const;
  215.     BOOL operator != ( CONST D3DXMATRIX& ) const;
  217. } D3DXMATRIX, *LPD3DXMATRIX;
  219. #else //!__cplusplus
  220. typedef struct _D3DMATRIX D3DXMATRIX, *LPD3DXMATRIX;
  221. #endif //!__cplusplus
  223. #ifdef __cplusplus
  224. typedef struct _D3DXMATRIXA16 : public D3DXMATRIX
  225. {
  226.     _D3DXMATRIXA16() {}
  227.     _D3DXMATRIXA16( CONST FLOAT * f): D3DXMATRIX(f) {}
  228.     _D3DXMATRIXA16( CONST D3DMATRIX& m): D3DXMATRIX(m) {}
  229.     _D3DXMATRIXA16( FLOAT _11, FLOAT _12, FLOAT _13, FLOAT _14,
  230.                     FLOAT _21, FLOAT _22, FLOAT _23, FLOAT _24,
  231.                     FLOAT _31, FLOAT _32, FLOAT _33, FLOAT _34,
  232.                     FLOAT _41, FLOAT _42, FLOAT _43, FLOAT _44 ) :
  233.                 D3DXMATRIX(_11, _12, _13, _14,
  234.                            _21, _22, _23, _24,
  235.                            _31, _32, _33, _34,
  236.                            _41, _42, _43, _44) {}
  237.     void* operator new(size_t s)
  238.     {
  239.         LPBYTE p = ::new BYTE[s + 16];
  240.         if (p)
  241.         {
  242.             BYTE offset = (BYTE)(16 - ((ULONG_PTR)p & 15));
  243.             p += offset;
  244.             p[-1] = offset;
  245.         }
  246.         return p;
  247.     };
  249.     void* operator new[](size_t s)
  250.     {
  251.         LPBYTE p = ::new BYTE[s + 16];
  252.         if (p)
  253.         {
  254.             BYTE offset = (BYTE)(16 - ((ULONG_PTR)p & 15));
  255.             p += offset;
  256.             p[-1] = offset;
  257.         }
  258.         return p;
  259.     };
  261.     // This is NOT a virtual operator. If you cast
  262.     // to D3DXMATRIX, do not delete using that
  263.     void operator delete(void* p)
  264.     {
  265.         if(p)
  266.         {
  267.             BYTE* pb = static_cast<BYTE*>(p);
  268.             pb -= pb[-1];
  269.             ::delete [] pb;
  270.         }
  271.     };
  273.     // This is NOT a virtual operator. If you cast
  274.     // to D3DXMATRIX, do not delete using that
  275.     void operator delete[](void* p)
  276.     {
  277.         if(p)
  278.         {
  279.             BYTE* pb = static_cast<BYTE*>(p);
  280.             pb -= pb[-1];
  281.             ::delete [] pb;
  282.         }
  283.     };
  285.     struct _D3DXMATRIXA16& operator=(CONST D3DXMATRIX& rhs)
  286.     {
  287.         memcpy(&_11, &rhs, sizeof(D3DXMATRIX));
  288.         return *this;
  289.     };
  290. } _D3DXMATRIXA16;
  292. #else //!__cplusplus
  293. typedef D3DXMATRIX  _D3DXMATRIXA16;
  294. #endif //!__cplusplus
  296. #if _MSC_FULL_VER >= 12008804        // First Processor Pack
  297. #define _ALIGN_16 __declspec(align(16))
  298. #else
  299. #define _ALIGN_16
  300. #endif
  302. #define D3DXMATRIXA16 _ALIGN_16 _D3DXMATRIXA16
  304. typedef D3DXMATRIXA16 *LPD3DXMATRIXA16;
  306. //===========================================================================
  307. //
  308. //    Quaternions
  309. //
  310. //===========================================================================
  311. typedef struct D3DXQUATERNION
  312. {
  313. #ifdef __cplusplus
  314. public:
  315.     D3DXQUATERNION() {}
  316.     D3DXQUATERNION( CONST FLOAT * );
  317.     D3DXQUATERNION( FLOAT x, FLOAT y, FLOAT z, FLOAT w );
  319.     // casting
  320.     operator FLOAT* ();
  321.     operator CONST FLOAT* () const;
  323.     // assignment operators
  324.     D3DXQUATERNION& operator += ( CONST D3DXQUATERNION& );
  325.     D3DXQUATERNION& operator -= ( CONST D3DXQUATERNION& );
  326.     D3DXQUATERNION& operator *= ( CONST D3DXQUATERNION& );
  327.     D3DXQUATERNION& operator *= ( FLOAT );
  328.     D3DXQUATERNION& operator /= ( FLOAT );
  330.     // unary operators
  331.     D3DXQUATERNION  operator + () const;
  332.     D3DXQUATERNION  operator - () const;
  334.     // binary operators
  335.     D3DXQUATERNION operator + ( CONST D3DXQUATERNION& ) const;
  336.     D3DXQUATERNION operator - ( CONST D3DXQUATERNION& ) const;
  337.     D3DXQUATERNION operator * ( CONST D3DXQUATERNION& ) const;
  338.     D3DXQUATERNION operator * ( FLOAT ) const;
  339.     D3DXQUATERNION operator / ( FLOAT ) const;
  341.     friend D3DXQUATERNION operator * (FLOAT, CONST D3DXQUATERNION& );
  343.     BOOL operator == ( CONST D3DXQUATERNION& ) const;
  344.     BOOL operator != ( CONST D3DXQUATERNION& ) const;
  346. #endif //__cplusplus
  347.     FLOAT x, y, z, w;
  348. } D3DXQUATERNION, *LPD3DXQUATERNION;
  351. //===========================================================================
  352. //
  353. // Planes
  354. //
  355. //===========================================================================
  356. typedef struct D3DXPLANE
  357. {
  358. #ifdef __cplusplus
  359. public:
  360.     D3DXPLANE() {}
  361.     D3DXPLANE( CONST FLOAT* );
  362.     D3DXPLANE( FLOAT a, FLOAT b, FLOAT c, FLOAT d );
  364.     // casting
  365.     operator FLOAT* ();
  366.     operator CONST FLOAT* () const;
  368.     // unary operators
  369.     D3DXPLANE operator + () const;
  370.     D3DXPLANE operator - () const;
  372.     // binary operators
  373.     BOOL operator == ( CONST D3DXPLANE& ) const;
  374.     BOOL operator != ( CONST D3DXPLANE& ) const;
  376. #endif //__cplusplus
  377.     FLOAT a, b, c, d;
  378. } D3DXPLANE, *LPD3DXPLANE;
  381. //===========================================================================
  382. //
  383. // Colors
  384. //
  385. //===========================================================================
  387. typedef struct D3DXCOLOR
  388. {
  389. #ifdef __cplusplus
  390. public:
  391.     D3DXCOLOR() {}
  392.     D3DXCOLOR( DWORD argb );
  393.     D3DXCOLOR( CONST FLOAT * );
  394.     D3DXCOLOR( CONST D3DCOLORVALUE& );
  395.     D3DXCOLOR( FLOAT r, FLOAT g, FLOAT b, FLOAT a );
  397.     // casting
  398.     operator DWORD () const;
  400.     operator FLOAT* ();
  401.     operator CONST FLOAT* () const;
  403.     operator D3DCOLORVALUE* ();
  404.     operator CONST D3DCOLORVALUE* () const;
  406.     operator D3DCOLORVALUE& ();
  407.     operator CONST D3DCOLORVALUE& () const;
  409.     // assignment operators
  410.     D3DXCOLOR& operator += ( CONST D3DXCOLOR& );
  411.     D3DXCOLOR& operator -= ( CONST D3DXCOLOR& );
  412.     D3DXCOLOR& operator *= ( FLOAT );
  413.     D3DXCOLOR& operator /= ( FLOAT );
  415.     // unary operators
  416.     D3DXCOLOR operator + () const;
  417.     D3DXCOLOR operator - () const;
  419.     // binary operators
  420.     D3DXCOLOR operator + ( CONST D3DXCOLOR& ) const;
  421.     D3DXCOLOR operator - ( CONST D3DXCOLOR& ) const;
  422.     D3DXCOLOR operator * ( FLOAT ) const;
  423.     D3DXCOLOR operator / ( FLOAT ) const;
  425.     friend D3DXCOLOR operator * (FLOAT, CONST D3DXCOLOR& );
  427.     BOOL operator == ( CONST D3DXCOLOR& ) const;
  428.     BOOL operator != ( CONST D3DXCOLOR& ) const;
  430. #endif //__cplusplus
  431.     FLOAT r, g, b, a;
  432. } D3DXCOLOR, *LPD3DXCOLOR;
  436. //===========================================================================
  437. //
  438. // D3DX math functions:
  439. //
  440. // NOTE:
  441. //  * All these functions can take the same object as in and out parameters.
  442. //
  443. //  * Out parameters are typically also returned as return values, so that
  444. //    the output of one function may be used as a parameter to another.
  445. //
  446. //===========================================================================
  448. //--------------------------
  449. // 2D Vector
  450. //--------------------------
  452. // inline
  454. FLOAT D3DXVec2Length
  455.     ( CONST D3DXVECTOR2 *pV );
  457. FLOAT D3DXVec2LengthSq
  458.     ( CONST D3DXVECTOR2 *pV );
  460. FLOAT D3DXVec2Dot
  461.     ( CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 );
  463. // Z component of ((x1,y1,0) cross (x2,y2,0))
  464. FLOAT D3DXVec2CCW
  465.     ( CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 );
  467. D3DXVECTOR2* D3DXVec2Add
  468.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 );
  470. D3DXVECTOR2* D3DXVec2Subtract
  471.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 );
  473. // Minimize each component.  x = min(x1, x2), y = min(y1, y2)
  474. D3DXVECTOR2* D3DXVec2Minimize
  475.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 );
  477. // Maximize each component.  x = max(x1, x2), y = max(y1, y2)
  478. D3DXVECTOR2* D3DXVec2Maximize
  479.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 );
  481. D3DXVECTOR2* D3DXVec2Scale
  482.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV, FLOAT s );
  484. // Linear interpolation. V1 + s(V2-V1)
  485. D3DXVECTOR2* D3DXVec2Lerp
  486.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2,
  487.       FLOAT s );
  489. // non-inline
  490. #ifdef __cplusplus
  491. extern "C" {
  492. #endif
  494. D3DXVECTOR2* WINAPI D3DXVec2Normalize
  495.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV );
  497. // Hermite interpolation between position V1, tangent T1 (when s == 0)
  498. // and position V2, tangent T2 (when s == 1).
  499. D3DXVECTOR2* WINAPI D3DXVec2Hermite
  500.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pT1,
  501.       CONST D3DXVECTOR2 *pV2, CONST D3DXVECTOR2 *pT2, FLOAT s );
  503. // CatmullRom interpolation between V1 (when s == 0) and V2 (when s == 1)
  504. D3DXVECTOR2* WINAPI D3DXVec2CatmullRom
  505.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV0, CONST D3DXVECTOR2 *pV1,
  506.       CONST D3DXVECTOR2 *pV2, CONST D3DXVECTOR2 *pV3, FLOAT s );
  508. // Barycentric coordinates.  V1 + f(V2-V1) + g(V3-V1)
  509. D3DXVECTOR2* WINAPI D3DXVec2BaryCentric
  510.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2,
  511.       CONST D3DXVECTOR2 *pV3, FLOAT f, FLOAT g);
  513. // Transform (x, y, 0, 1) by matrix.
  514. D3DXVECTOR4* WINAPI D3DXVec2Transform
  515.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR2 *pV, CONST D3DXMATRIX *pM );
  517. // Transform (x, y, 0, 1) by matrix, project result back into w=1.
  518. D3DXVECTOR2* WINAPI D3DXVec2TransformCoord
  519.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV, CONST D3DXMATRIX *pM );
  521. // Transform (x, y, 0, 0) by matrix.
  522. D3DXVECTOR2* WINAPI D3DXVec2TransformNormal
  523.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV, CONST D3DXMATRIX *pM );
  525. #ifdef __cplusplus
  526. }
  527. #endif
  530. //--------------------------
  531. // 3D Vector
  532. //--------------------------
  534. // inline
  536. FLOAT D3DXVec3Length
  537.     ( CONST D3DXVECTOR3 *pV );
  539. FLOAT D3DXVec3LengthSq
  540.     ( CONST D3DXVECTOR3 *pV );
  542. FLOAT D3DXVec3Dot
  543.     ( CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 );
  545. D3DXVECTOR3* D3DXVec3Cross
  546.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 );
  548. D3DXVECTOR3* D3DXVec3Add
  549.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 );
  551. D3DXVECTOR3* D3DXVec3Subtract
  552.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 );
  554. // Minimize each component.  x = min(x1, x2), y = min(y1, y2), ...
  555. D3DXVECTOR3* D3DXVec3Minimize
  556.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 );
  558. // Maximize each component.  x = max(x1, x2), y = max(y1, y2), ...
  559. D3DXVECTOR3* D3DXVec3Maximize
  560.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 );
  562. D3DXVECTOR3* D3DXVec3Scale
  563.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, FLOAT s);
  565. // Linear interpolation. V1 + s(V2-V1)
  566. D3DXVECTOR3* D3DXVec3Lerp
  567.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2,
  568.       FLOAT s );
  570. // non-inline
  571. #ifdef __cplusplus
  572. extern "C" {
  573. #endif
  575. D3DXVECTOR3* WINAPI D3DXVec3Normalize
  576.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV );
  578. // Hermite interpolation between position V1, tangent T1 (when s == 0)
  579. // and position V2, tangent T2 (when s == 1).
  580. D3DXVECTOR3* WINAPI D3DXVec3Hermite
  581.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pT1,
  582.       CONST D3DXVECTOR3 *pV2, CONST D3DXVECTOR3 *pT2, FLOAT s );
  584. // CatmullRom interpolation between V1 (when s == 0) and V2 (when s == 1)
  585. D3DXVECTOR3* WINAPI D3DXVec3CatmullRom
  586.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV0, CONST D3DXVECTOR3 *pV1,
  587.       CONST D3DXVECTOR3 *pV2, CONST D3DXVECTOR3 *pV3, FLOAT s );
  589. // Barycentric coordinates.  V1 + f(V2-V1) + g(V3-V1)
  590. D3DXVECTOR3* WINAPI D3DXVec3BaryCentric
  591.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2,
  592.       CONST D3DXVECTOR3 *pV3, FLOAT f, FLOAT g);
  594. // Transform (x, y, z, 1) by matrix.
  595. D3DXVECTOR4* WINAPI D3DXVec3Transform
  596.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR3 *pV, CONST D3DXMATRIX *pM );
  598. // Transform (x, y, z, 1) by matrix, project result back into w=1.
  599. D3DXVECTOR3* WINAPI D3DXVec3TransformCoord
  600.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, CONST D3DXMATRIX *pM );
  602. // Transform (x, y, z, 0) by matrix.  If you transforming a normal by a 
  603. // non-affine matrix, the matrix you pass to this function should be the 
  604. // transpose of the inverse of the matrix you would use to transform a coord.
  605. D3DXVECTOR3* WINAPI D3DXVec3TransformNormal
  606.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, CONST D3DXMATRIX *pM );
  608. // Project vector from object space into screen space
  609. D3DXVECTOR3* WINAPI D3DXVec3Project
  610.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, CONST D3DVIEWPORT8 *pViewport,
  611.       CONST D3DXMATRIX *pProjection, CONST D3DXMATRIX *pView, CONST D3DXMATRIX *pWorld);
  613. // Project vector from screen space into object space
  614. D3DXVECTOR3* WINAPI D3DXVec3Unproject
  615.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, CONST D3DVIEWPORT8 *pViewport,
  616.       CONST D3DXMATRIX *pProjection, CONST D3DXMATRIX *pView, CONST D3DXMATRIX *pWorld);
  618. #ifdef __cplusplus
  619. }
  620. #endif
  624. //--------------------------
  625. // 4D Vector
  626. //--------------------------
  628. // inline
  630. FLOAT D3DXVec4Length
  631.     ( CONST D3DXVECTOR4 *pV );
  633. FLOAT D3DXVec4LengthSq
  634.     ( CONST D3DXVECTOR4 *pV );
  636. FLOAT D3DXVec4Dot
  637.     ( CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2 );
  639. D3DXVECTOR4* D3DXVec4Add
  640.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2);
  642. D3DXVECTOR4* D3DXVec4Subtract
  643.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2);
  645. // Minimize each component.  x = min(x1, x2), y = min(y1, y2), ...
  646. D3DXVECTOR4* D3DXVec4Minimize
  647.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2);
  649. // Maximize each component.  x = max(x1, x2), y = max(y1, y2), ...
  650. D3DXVECTOR4* D3DXVec4Maximize
  651.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2);
  653. D3DXVECTOR4* D3DXVec4Scale
  654.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV, FLOAT s);
  656. // Linear interpolation. V1 + s(V2-V1)
  657. D3DXVECTOR4* D3DXVec4Lerp
  658.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2,
  659.       FLOAT s );
  661. // non-inline
  662. #ifdef __cplusplus
  663. extern "C" {
  664. #endif
  666. // Cross-product in 4 dimensions.
  667. D3DXVECTOR4* WINAPI D3DXVec4Cross
  668.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2,
  669.       CONST D3DXVECTOR4 *pV3);
  671. D3DXVECTOR4* WINAPI D3DXVec4Normalize
  672.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV );
  674. // Hermite interpolation between position V1, tangent T1 (when s == 0)
  675. // and position V2, tangent T2 (when s == 1).
  676. D3DXVECTOR4* WINAPI D3DXVec4Hermite
  677.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pT1,
  678.       CONST D3DXVECTOR4 *pV2, CONST D3DXVECTOR4 *pT2, FLOAT s );
  680. // CatmullRom interpolation between V1 (when s == 0) and V2 (when s == 1)
  681. D3DXVECTOR4* WINAPI D3DXVec4CatmullRom
  682.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV0, CONST D3DXVECTOR4 *pV1,
  683.       CONST D3DXVECTOR4 *pV2, CONST D3DXVECTOR4 *pV3, FLOAT s );
  685. // Barycentric coordinates.  V1 + f(V2-V1) + g(V3-V1)
  686. D3DXVECTOR4* WINAPI D3DXVec4BaryCentric
  687.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2,
  688.       CONST D3DXVECTOR4 *pV3, FLOAT f, FLOAT g);
  690. // Transform vector by matrix.
  691. D3DXVECTOR4* WINAPI D3DXVec4Transform
  692.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV, CONST D3DXMATRIX *pM );
  694. #ifdef __cplusplus
  695. }
  696. #endif
  699. //--------------------------
  700. // 4D Matrix
  701. //--------------------------
  703. // inline
  705. D3DXMATRIX* D3DXMatrixIdentity
  706.     ( D3DXMATRIX *pOut );
  708. BOOL D3DXMatrixIsIdentity
  709.     ( CONST D3DXMATRIX *pM );
  712. // non-inline
  713. #ifdef __cplusplus
  714. extern "C" {
  715. #endif
  717. FLOAT WINAPI D3DXMatrixfDeterminant
  718.     ( CONST D3DXMATRIX *pM );
  720. D3DXMATRIX* WINAPI D3DXMatrixTranspose
  721.     ( D3DXMATRIX *pOut, CONST D3DXMATRIX *pM );
  723. // Matrix multiplication.  The result represents the transformation M2
  724. // followed by the transformation M1.  (Out = M1 * M2)
  725. D3DXMATRIX* WINAPI D3DXMatrixMultiply
  726.     ( D3DXMATRIX *pOut, CONST D3DXMATRIX *pM1, CONST D3DXMATRIX *pM2 );
  728. // Matrix multiplication, followed by a transpose. (Out = T(M1 * M2))
  729. D3DXMATRIX* WINAPI D3DXMatrixMultiplyTranspose
  730.     ( D3DXMATRIX *pOut, CONST D3DXMATRIX *pM1, CONST D3DXMATRIX *pM2 );
  732. // Calculate inverse of matrix.  Inversion my fail, in which case NULL will
  733. // be returned.  The determinant of pM is also returned it pfDeterminant
  734. // is non-NULL.
  735. D3DXMATRIX* WINAPI D3DXMatrixInverse
  736.     ( D3DXMATRIX *pOut, FLOAT *pDeterminant, CONST D3DXMATRIX *pM );
  738. // Build a matrix which scales by (sx, sy, sz)
  739. D3DXMATRIX* WINAPI D3DXMatrixScaling
  740.     ( D3DXMATRIX *pOut, FLOAT sx, FLOAT sy, FLOAT sz );
  742. // Build a matrix which translates by (x, y, z)
  743. D3DXMATRIX* WINAPI D3DXMatrixTranslation
  744.     ( D3DXMATRIX *pOut, FLOAT x, FLOAT y, FLOAT z );
  746. // Build a matrix which rotates around the X axis
  747. D3DXMATRIX* WINAPI D3DXMatrixRotationX
  748.     ( D3DXMATRIX *pOut, FLOAT Angle );
  750. // Build a matrix which rotates around the Y axis
  751. D3DXMATRIX* WINAPI D3DXMatrixRotationY
  752.     ( D3DXMATRIX *pOut, FLOAT Angle );
  754. // Build a matrix which rotates around the Z axis
  755. D3DXMATRIX* WINAPI D3DXMatrixRotationZ
  756.     ( D3DXMATRIX *pOut, FLOAT Angle );
  758. // Build a matrix which rotates around an arbitrary axis
  759. D3DXMATRIX* WINAPI D3DXMatrixRotationAxis
  760.     ( D3DXMATRIX *pOut, CONST D3DXVECTOR3 *pV, FLOAT Angle );
  762. // Build a matrix from a quaternion
  763. D3DXMATRIX* WINAPI D3DXMatrixRotationQuaternion
  764.     ( D3DXMATRIX *pOut, CONST D3DXQUATERNION *pQ);
  766. // Yaw around the Y axis, a pitch around the X axis,
  767. // and a roll around the Z axis.
  768. D3DXMATRIX* WINAPI D3DXMatrixRotationYawPitchRoll
  769.     ( D3DXMATRIX *pOut, FLOAT Yaw, FLOAT Pitch, FLOAT Roll );
  772. // Build transformation matrix.  NULL arguments are treated as identity.
  773. // Mout = Msc-1 * Msr-1 * Ms * Msr * Msc * Mrc-1 * Mr * Mrc * Mt
  774. D3DXMATRIX* WINAPI D3DXMatrixTransformation
  775.     ( D3DXMATRIX *pOut, CONST D3DXVECTOR3 *pScalingCenter,
  776.       CONST D3DXQUATERNION *pScalingRotation, CONST D3DXVECTOR3 *pScaling,
  777.       CONST D3DXVECTOR3 *pRotationCenter, CONST D3DXQUATERNION *pRotation,
  778.       CONST D3DXVECTOR3 *pTranslation);
  780. // Build affine transformation matrix.  NULL arguments are treated as identity.
  781. // Mout = Ms * Mrc-1 * Mr * Mrc * Mt
  782. D3DXMATRIX* WINAPI D3DXMatrixAffineTransformation
  783.     ( D3DXMATRIX *pOut, FLOAT Scaling, CONST D3DXVECTOR3 *pRotationCenter,
  784.       CONST D3DXQUATERNION *pRotation, CONST D3DXVECTOR3 *pTranslation);
  786. // Build a lookat matrix. (right-handed)
  787. D3DXMATRIX* WINAPI D3DXMatrixLookAtRH
  788.     ( D3DXMATRIX *pOut, CONST D3DXVECTOR3 *pEye, CONST D3DXVECTOR3 *pAt,
  789.       CONST D3DXVECTOR3 *pUp );
  791. // Build a lookat matrix. (left-handed)
  792. D3DXMATRIX* WINAPI D3DXMatrixLookAtLH
  793.     ( D3DXMATRIX *pOut, CONST D3DXVECTOR3 *pEye, CONST D3DXVECTOR3 *pAt,
  794.       CONST D3DXVECTOR3 *pUp );
  796. // Build a perspective projection matrix. (right-handed)
  797. D3DXMATRIX* WINAPI D3DXMatrixPerspectiveRH
  798.     ( D3DXMATRIX *pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf );
  800. // Build a perspective projection matrix. (left-handed)
  801. D3DXMATRIX* WINAPI D3DXMatrixPerspectiveLH
  802.     ( D3DXMATRIX *pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf );
  804. // Build a perspective projection matrix. (right-handed)
  805. D3DXMATRIX* WINAPI D3DXMatrixPerspectiveFovRH
  806.     ( D3DXMATRIX *pOut, FLOAT fovy, FLOAT Aspect, FLOAT zn, FLOAT zf );
  808. // Build a perspective projection matrix. (left-handed)
  809. D3DXMATRIX* WINAPI D3DXMatrixPerspectiveFovLH
  810.     ( D3DXMATRIX *pOut, FLOAT fovy, FLOAT Aspect, FLOAT zn, FLOAT zf );
  812. // Build a perspective projection matrix. (right-handed)
  813. D3DXMATRIX* WINAPI D3DXMatrixPerspectiveOffCenterRH
  814.     ( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn,
  815.       FLOAT zf );
  817. // Build a perspective projection matrix. (left-handed)
  818. D3DXMATRIX* WINAPI D3DXMatrixPerspectiveOffCenterLH
  819.     ( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn,
  820.       FLOAT zf );
  822. // Build an ortho projection matrix. (right-handed)
  823. D3DXMATRIX* WINAPI D3DXMatrixOrthoRH
  824.     ( D3DXMATRIX *pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf );
  826. // Build an ortho projection matrix. (left-handed)
  827. D3DXMATRIX* WINAPI D3DXMatrixOrthoLH
  828.     ( D3DXMATRIX *pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf );
  830. // Build an ortho projection matrix. (right-handed)
  831. D3DXMATRIX* WINAPI D3DXMatrixOrthoOffCenterRH
  832.     ( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn,
  833.       FLOAT zf );
  835. // Build an ortho projection matrix. (left-handed)
  836. D3DXMATRIX* WINAPI D3DXMatrixOrthoOffCenterLH
  837.     ( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn,
  838.       FLOAT zf );
  840. // Build a matrix which flattens geometry into a plane, as if casting
  841. // a shadow from a light.
  842. D3DXMATRIX* WINAPI D3DXMatrixShadow
  843.     ( D3DXMATRIX *pOut, CONST D3DXVECTOR4 *pLight,
  844.       CONST D3DXPLANE *pPlane );
  846. // Build a matrix which reflects the coordinate system about a plane
  847. D3DXMATRIX* WINAPI D3DXMatrixReflect
  848.     ( D3DXMATRIX *pOut, CONST D3DXPLANE *pPlane );
  850. #ifdef __cplusplus
  851. }
  852. #endif
  855. //--------------------------
  856. // Quaternion
  857. //--------------------------
  859. // inline
  861. FLOAT D3DXQuaternionLength
  862.     ( CONST D3DXQUATERNION *pQ );
  864. // Length squared, or "norm"
  865. FLOAT D3DXQuaternionLengthSq
  866.     ( CONST D3DXQUATERNION *pQ );
  868. FLOAT D3DXQuaternionDot
  869.     ( CONST D3DXQUATERNION *pQ1, CONST D3DXQUATERNION *pQ2 );
  871. // (0, 0, 0, 1)
  872. D3DXQUATERNION* D3DXQuaternionIdentity
  873.     ( D3DXQUATERNION *pOut );
  875. BOOL D3DXQuaternionIsIdentity
  876.     ( CONST D3DXQUATERNION *pQ );
  878. // (-x, -y, -z, w)
  879. D3DXQUATERNION* D3DXQuaternionConjugate
  880.     ( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ );
  883. // non-inline
  884. #ifdef __cplusplus
  885. extern "C" {
  886. #endif
  888. // Compute a quaternin's axis and angle of rotation. Expects unit quaternions.
  889. void WINAPI D3DXQuaternionToAxisAngle
  890.     ( CONST D3DXQUATERNION *pQ, D3DXVECTOR3 *pAxis, FLOAT *pAngle );
  892. // Build a quaternion from a rotation matrix.
  893. D3DXQUATERNION* WINAPI D3DXQuaternionRotationMatrix
  894.     ( D3DXQUATERNION *pOut, CONST D3DXMATRIX *pM);
  896. // Rotation about arbitrary axis.
  897. D3DXQUATERNION* WINAPI D3DXQuaternionRotationAxis
  898.     ( D3DXQUATERNION *pOut, CONST D3DXVECTOR3 *pV, FLOAT Angle );
  900. // Yaw around the Y axis, a pitch around the X axis,
  901. // and a roll around the Z axis.
  902. D3DXQUATERNION* WINAPI D3DXQuaternionRotationYawPitchRoll
  903.     ( D3DXQUATERNION *pOut, FLOAT Yaw, FLOAT Pitch, FLOAT Roll );
  905. // Quaternion multiplication.  The result represents the rotation Q2
  906. // followed by the rotation Q1.  (Out = Q2 * Q1)
  907. D3DXQUATERNION* WINAPI D3DXQuaternionMultiply
  908.     ( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ1,
  909.       CONST D3DXQUATERNION *pQ2 );
  911. D3DXQUATERNION* WINAPI D3DXQuaternionNormalize
  912.     ( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ );
  914. // Conjugate and re-norm
  915. D3DXQUATERNION* WINAPI D3DXQuaternionInverse
  916.     ( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ );
  918. // Expects unit quaternions.
  919. // if q = (cos(theta), sin(theta) * v); ln(q) = (0, theta * v)
  920. D3DXQUATERNION* WINAPI D3DXQuaternionLn
  921.     ( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ );
  923. // Expects pure quaternions. (w == 0)  w is ignored in calculation.
  924. // if q = (0, theta * v); exp(q) = (cos(theta), sin(theta) * v)
  925. D3DXQUATERNION* WINAPI D3DXQuaternionExp
  926.     ( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ );
  927.       
  928. // Spherical linear interpolation between Q1 (t == 0) and Q2 (t == 1).
  929. // Expects unit quaternions.
  930. D3DXQUATERNION* WINAPI D3DXQuaternionSlerp
  931.     ( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ1,
  932.       CONST D3DXQUATERNION *pQ2, FLOAT t );
  934. // Spherical quadrangle interpolation.
  935. // Slerp(Slerp(Q1, C, t), Slerp(A, B, t), 2t(1-t))
  936. D3DXQUATERNION* WINAPI D3DXQuaternionSquad
  937.     ( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ1,
  938.       CONST D3DXQUATERNION *pA, CONST D3DXQUATERNION *pB,
  939.       CONST D3DXQUATERNION *pC, FLOAT t );
  941. // Setup control points for spherical quadrangle interpolation
  942. // from Q1 to Q2.  The control points are chosen in such a way 
  943. // to ensure the continuity of tangents with adjacent segments.
  944. void WINAPI D3DXQuaternionSquadSetup
  945.     ( D3DXQUATERNION *pAOut, D3DXQUATERNION *pBOut, D3DXQUATERNION *pCOut,
  946.       CONST D3DXQUATERNION *pQ0, CONST D3DXQUATERNION *pQ1, 
  947.       CONST D3DXQUATERNION *pQ2, CONST D3DXQUATERNION *pQ3 );
  949. // Barycentric interpolation.
  950. // Slerp(Slerp(Q1, Q2, f+g), Slerp(Q1, Q3, f+g), g/(f+g))
  951. D3DXQUATERNION* WINAPI D3DXQuaternionBaryCentric
  952.     ( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ1,
  953.       CONST D3DXQUATERNION *pQ2, CONST D3DXQUATERNION *pQ3,
  954.       FLOAT f, FLOAT g );
  956. #ifdef __cplusplus
  957. }
  958. #endif
  961. //--------------------------
  962. // Plane
  963. //--------------------------
  965. // inline
  967. // ax + by + cz + dw
  968. FLOAT D3DXPlaneDot
  969.     ( CONST D3DXPLANE *pP, CONST D3DXVECTOR4 *pV);
  971. // ax + by + cz + d
  972. FLOAT D3DXPlaneDotCoord
  973.     ( CONST D3DXPLANE *pP, CONST D3DXVECTOR3 *pV);
  975. // ax + by + cz
  976. FLOAT D3DXPlaneDotNormal
  977.     ( CONST D3DXPLANE *pP, CONST D3DXVECTOR3 *pV);
  979. // non-inline
  980. #ifdef __cplusplus
  981. extern "C" {
  982. #endif
  984. // Normalize plane (so that |a,b,c| == 1)
  985. D3DXPLANE* WINAPI D3DXPlaneNormalize
  986.     ( D3DXPLANE *pOut, CONST D3DXPLANE *pP);
  988. // Find the intersection between a plane and a line.  If the line is
  989. // parallel to the plane, NULL is returned.
  990. D3DXVECTOR3* WINAPI D3DXPlaneIntersectLine
  991.     ( D3DXVECTOR3 *pOut, CONST D3DXPLANE *pP, CONST D3DXVECTOR3 *pV1,
  992.       CONST D3DXVECTOR3 *pV2);
  994. // Construct a plane from a point and a normal
  995. D3DXPLANE* WINAPI D3DXPlaneFromPointNormal
  996.     ( D3DXPLANE *pOut, CONST D3DXVECTOR3 *pPoint, CONST D3DXVECTOR3 *pNormal);
  998. // Construct a plane from 3 points
  999. D3DXPLANE* WINAPI D3DXPlaneFromPoints
  1000.     ( D3DXPLANE *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2,
  1001.       CONST D3DXVECTOR3 *pV3);
  1003. // Transform a plane by a matrix.  The vector (a,b,c) must be normal.
  1004. // M should be the inverse transpose of the transformation desired.
  1005. D3DXPLANE* WINAPI D3DXPlaneTransform
  1006.     ( D3DXPLANE *pOut, CONST D3DXPLANE *pP, CONST D3DXMATRIX *pM );
  1008. #ifdef __cplusplus
  1009. }
  1010. #endif
  1013. //--------------------------
  1014. // Color
  1015. //--------------------------
  1017. // inline
  1019. // (1-r, 1-g, 1-b, a)
  1020. D3DXCOLOR* D3DXColorNegative
  1021.     (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC);
  1023. D3DXCOLOR* D3DXColorAdd
  1024.     (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2);
  1026. D3DXCOLOR* D3DXColorSubtract
  1027.     (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2);
  1029. D3DXCOLOR* D3DXColorScale
  1030.     (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC, FLOAT s);
  1032. // (r1*r2, g1*g2, b1*b2, a1*a2)
  1033. D3DXCOLOR* D3DXColorModulate
  1034.     (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2);
  1036. // Linear interpolation of r,g,b, and a. C1 + s(C2-C1)
  1037. D3DXCOLOR* D3DXColorLerp
  1038.     (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2, FLOAT s);
  1040. // non-inline
  1041. #ifdef __cplusplus
  1042. extern "C" {
  1043. #endif
  1045. // Interpolate r,g,b between desaturated color and color.
  1046. // DesaturatedColor + s(Color - DesaturatedColor)
  1047. D3DXCOLOR* WINAPI D3DXColorAdjustSaturation
  1048.     (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC, FLOAT s);
  1050. // Interpolate r,g,b between 50% grey and color.  Grey + s(Color - Grey)
  1051. D3DXCOLOR* WINAPI D3DXColorAdjustContrast
  1052.     (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC, FLOAT c);
  1054. #ifdef __cplusplus
  1055. }
  1056. #endif
  1061. //--------------------------
  1062. // Misc
  1063. //--------------------------
  1065. #ifdef __cplusplus
  1066. extern "C" {
  1067. #endif
  1069. // Calculate Fresnel term given the cosine of theta (likely obtained by
  1070. // taking the dot of two normals), and the refraction index of the material.
  1071. FLOAT WINAPI D3DXFresnelTerm
  1072.     (FLOAT CosTheta, FLOAT RefractionIndex);     
  1074. #ifdef __cplusplus
  1075. }
  1076. #endif
  1080. //===========================================================================
  1081. //
  1082. //    Matrix Stack
  1083. //
  1084. //===========================================================================
  1086. typedef interface ID3DXMatrixStack ID3DXMatrixStack;
  1087. typedef interface ID3DXMatrixStack *LPD3DXMATRIXSTACK;
  1089. // {E3357330-CC5E-11d2-A434-00A0C90629A8}
  1090. DEFINE_GUID( IID_ID3DXMatrixStack,
  1091. 0xe3357330, 0xcc5e, 0x11d2, 0xa4, 0x34, 0x0, 0xa0, 0xc9, 0x6, 0x29, 0xa8);
  1094. #undef INTERFACE
  1095. #define INTERFACE ID3DXMatrixStack
  1097. DECLARE_INTERFACE_(ID3DXMatrixStack, IUnknown)
  1098. {
  1099.     //
  1100.     // IUnknown methods
  1101.     //
  1102.     STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE;
  1103.     STDMETHOD_(ULONG,AddRef)(THIS) PURE;
  1104.     STDMETHOD_(ULONG,Release)(THIS) PURE;
  1106.     //
  1107.     // ID3DXMatrixStack methods
  1108.     //
  1110.     // Pops the top of the stack, returns the current top
  1111.     // *after* popping the top.
  1112.     STDMETHOD(Pop)(THIS) PURE;
  1114.     // Pushes the stack by one, duplicating the current matrix.
  1115.     STDMETHOD(Push)(THIS) PURE;
  1117.     // Loads identity in the current matrix.
  1118.     STDMETHOD(LoadIdentity)(THIS) PURE;
  1120.     // Loads the given matrix into the current matrix
  1121.     STDMETHOD(LoadMatrix)(THIS_ CONST D3DXMATRIX* pM ) PURE;
  1123.     // Right-Multiplies the given matrix to the current matrix.
  1124.     // (transformation is about the current world origin)
  1125.     STDMETHOD(MultMatrix)(THIS_ CONST D3DXMATRIX* pM ) PURE;
  1127.     // Left-Multiplies the given matrix to the current matrix
  1128.     // (transformation is about the local origin of the object)
  1129.     STDMETHOD(MultMatrixLocal)(THIS_ CONST D3DXMATRIX* pM ) PURE;
  1131.     // Right multiply the current matrix with the computed rotation
  1132.     // matrix, counterclockwise about the given axis with the given angle.
  1133.     // (rotation is about the current world origin)
  1134.     STDMETHOD(RotateAxis)
  1135.         (THIS_ CONST D3DXVECTOR3* pV, FLOAT Angle) PURE;
  1137.     // Left multiply the current matrix with the computed rotation
  1138.     // matrix, counterclockwise about the given axis with the given angle.
  1139.     // (rotation is about the local origin of the object)
  1140.     STDMETHOD(RotateAxisLocal)
  1141.         (THIS_ CONST D3DXVECTOR3* pV, FLOAT Angle) PURE;
  1143.     // Right multiply the current matrix with the computed rotation
  1144.     // matrix. All angles are counterclockwise. (rotation is about the
  1145.     // current world origin)
  1147.     // The rotation is composed of a yaw around the Y axis, a pitch around
  1148.     // the X axis, and a roll around the Z axis.
  1149.     STDMETHOD(RotateYawPitchRoll)
  1150.         (THIS_ FLOAT Yaw, FLOAT Pitch, FLOAT Roll) PURE;
  1152.     // Left multiply the current matrix with the computed rotation
  1153.     // matrix. All angles are counterclockwise. (rotation is about the
  1154.     // local origin of the object)
  1156.     // The rotation is composed of a yaw around the Y axis, a pitch around
  1157.     // the X axis, and a roll around the Z axis.
  1158.     STDMETHOD(RotateYawPitchRollLocal)
  1159.         (THIS_ FLOAT Yaw, FLOAT Pitch, FLOAT Roll) PURE;
  1161.     // Right multiply the current matrix with the computed scale
  1162.     // matrix. (transformation is about the current world origin)
  1163.     STDMETHOD(Scale)(THIS_ FLOAT x, FLOAT y, FLOAT z) PURE;
  1165.     // Left multiply the current matrix with the computed scale
  1166.     // matrix. (transformation is about the local origin of the object)
  1167.     STDMETHOD(ScaleLocal)(THIS_ FLOAT x, FLOAT y, FLOAT z) PURE;
  1169.     // Right multiply the current matrix with the computed translation
  1170.     // matrix. (transformation is about the current world origin)
  1171.     STDMETHOD(Translate)(THIS_ FLOAT x, FLOAT y, FLOAT z ) PURE;
  1173.     // Left multiply the current matrix with the computed translation
  1174.     // matrix. (transformation is about the local origin of the object)
  1175.     STDMETHOD(TranslateLocal)(THIS_ FLOAT x, FLOAT y, FLOAT z) PURE;
  1177.     // Obtain the current matrix at the top of the stack
  1178.     STDMETHOD_(D3DXMATRIX*, GetTop)(THIS) PURE;
  1179. };
  1181. #ifdef __cplusplus
  1182. extern "C" {
  1183. #endif
  1185. HRESULT WINAPI 
  1186.     D3DXCreateMatrixStack( 
  1187.         DWORD               Flags, 
  1188.         LPD3DXMATRIXSTACK*  ppStack);
  1190. #ifdef __cplusplus
  1191. }
  1192. #endif
  1194. #include "d3dx8math.inl"
  1196. #pragma warning(default:4201)
  1198. #endif // __D3DX8MATH_H__