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

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

模拟服务器

开发平台：

C/C++

d3dxmath.inl：源码内容
  1. //////////////////////////////////////////////////////////////////////////////
  2. //
  3. //  Copyright (C) Microsoft Corporation.  All Rights Reserved.
  4. //
  5. //  File:       d3dxmath.inl
  6. //  Content:    D3DX math inline functions
  7. //
  8. //////////////////////////////////////////////////////////////////////////////
  10. #ifndef __D3DXMATH_INL__
  11. #define __D3DXMATH_INL__
  14. //===========================================================================
  15. //
  16. // Inline Class Methods
  17. //
  18. //===========================================================================
  20. #ifdef __cplusplus
  22. //--------------------------
  23. // 2D Vector
  24. //--------------------------
  26. D3DXINLINE 
  27. D3DXVECTOR2::D3DXVECTOR2( const float *pf )
  28. {
  29. #ifdef D3DX_DEBUG
  30.     if(!pf)
  31.         return;
  32. #endif
  34.     x = pf[0];
  35.     y = pf[1];
  36. }
  38. D3DXINLINE 
  39. D3DXVECTOR2::D3DXVECTOR2( float fx, float fy )
  40. {
  41.     x = fx;
  42.     y = fy;
  43. }
  45. // casting
  46. D3DXINLINE 
  47. D3DXVECTOR2::operator float* ()
  48. {
  49.     return (float *) &x;
  50. }
  52. D3DXINLINE 
  53. D3DXVECTOR2::operator const float* () const
  54. {
  55.     return (const float *) &x;
  56. }
  58. // assignment operators
  59. D3DXINLINE D3DXVECTOR2& 
  60. D3DXVECTOR2::operator += ( const D3DXVECTOR2& v )
  61. {
  62.     x += v.x;
  63.     y += v.y;
  64.     return *this;
  65. }
  67. D3DXINLINE D3DXVECTOR2& 
  68. D3DXVECTOR2::operator -= ( const D3DXVECTOR2& v )
  69. {
  70.     x -= v.x;
  71.     y -= v.y;
  72.     return *this;
  73. }
  75. D3DXINLINE D3DXVECTOR2& 
  76. D3DXVECTOR2::operator *= ( float f )
  77. {
  78.     x *= f;
  79.     y *= f;
  80.     return *this;
  81. }
  83. D3DXINLINE D3DXVECTOR2& 
  84. D3DXVECTOR2::operator /= ( float f )
  85. {
  86.     float fInv = 1.0f / f;
  87.     x *= fInv;
  88.     y *= fInv;
  89.     return *this;
  90. }
  92. // unary operators
  93. D3DXINLINE D3DXVECTOR2 
  94. D3DXVECTOR2::operator + () const
  95. {
  96.     return *this;
  97. }
  99. D3DXINLINE D3DXVECTOR2 
  100. D3DXVECTOR2::operator - () const
  101. {
  102.     return D3DXVECTOR2(-x, -y);
  103. }
  105. // binary operators
  106. D3DXINLINE D3DXVECTOR2 
  107. D3DXVECTOR2::operator + ( const D3DXVECTOR2& v ) const
  108. {
  109.     return D3DXVECTOR2(x + v.x, y + v.y);
  110. }
  112. D3DXINLINE D3DXVECTOR2 
  113. D3DXVECTOR2::operator - ( const D3DXVECTOR2& v ) const
  114. {
  115.     return D3DXVECTOR2(x - v.x, y - v.y);
  116. }
  118. D3DXINLINE D3DXVECTOR2 
  119. D3DXVECTOR2::operator * ( float f ) const
  120. {
  121.     return D3DXVECTOR2(x * f, y * f);
  122. }
  124. D3DXINLINE D3DXVECTOR2 
  125. D3DXVECTOR2::operator / ( float f ) const
  126. {
  127.     float fInv = 1.0f / f;
  128.     return D3DXVECTOR2(x * fInv, y * fInv);
  129. }
  132. D3DXINLINE D3DXVECTOR2 
  133. operator * ( float f, const D3DXVECTOR2& v )
  134. {
  135.     return D3DXVECTOR2(f * v.x, f * v.y);
  136. }
  138. D3DXINLINE BOOL 
  139. D3DXVECTOR2::operator == ( const D3DXVECTOR2& v ) const
  140. {
  141.     return x == v.x && y == v.y;
  142. }
  144. D3DXINLINE BOOL 
  145. D3DXVECTOR2::operator != ( const D3DXVECTOR2& v ) const
  146. {
  147.     return x != v.x || y != v.y;
  148. }
  153. //--------------------------
  154. // 3D Vector
  155. //--------------------------
  156. D3DXINLINE 
  157. D3DXVECTOR3::D3DXVECTOR3( const float *pf )
  158. {
  159. #ifdef D3DX_DEBUG
  160.     if(!pf)
  161.         return;
  162. #endif
  164.     x = pf[0];
  165.     y = pf[1];
  166.     z = pf[2];
  167. }
  169. D3DXINLINE 
  170. D3DXVECTOR3::D3DXVECTOR3( const D3DVECTOR& v )
  171. {
  172.     x = v.x;
  173.     y = v.y;
  174.     z = v.z;
  175. }
  177. D3DXINLINE 
  178. D3DXVECTOR3::D3DXVECTOR3( float fx, float fy, float fz )
  179. {
  180.     x = fx;
  181.     y = fy;
  182.     z = fz;
  183. }
  186. // casting
  187. D3DXINLINE 
  188. D3DXVECTOR3::operator float* ()
  189. {
  190.     return (float *) &x;
  191. }
  193. D3DXINLINE 
  194. D3DXVECTOR3::operator const float* () const
  195. {
  196.     return (const float *) &x;
  197. }
  200. D3DXINLINE 
  201. D3DXVECTOR3::operator D3DVECTOR* ()
  202. {
  203.     return (D3DVECTOR *) &x;
  204. }
  206. D3DXINLINE 
  207. D3DXVECTOR3::operator const D3DVECTOR* () const
  208. {
  209.     return (const D3DVECTOR *) &x;
  210. }
  213. D3DXINLINE 
  214. D3DXVECTOR3::operator D3DVECTOR& ()
  215. {
  216.     return *((D3DVECTOR *) &x);
  217. }
  219. D3DXINLINE 
  220. D3DXVECTOR3::operator const D3DVECTOR& () const
  221. {
  222.     return *((const D3DVECTOR *) &x);
  223. }
  226. // assignment operators
  227. D3DXINLINE D3DXVECTOR3& 
  228. D3DXVECTOR3::operator += ( const D3DXVECTOR3& v )
  229. {
  230.     x += v.x;
  231.     y += v.y;
  232.     z += v.z;
  233.     return *this;
  234. }
  236. D3DXINLINE D3DXVECTOR3& 
  237. D3DXVECTOR3::operator -= ( const D3DXVECTOR3& v )
  238. {
  239.     x -= v.x;
  240.     y -= v.y;
  241.     z -= v.z;
  242.     return *this;
  243. }
  245. D3DXINLINE D3DXVECTOR3& 
  246. D3DXVECTOR3::operator *= ( float f )
  247. {
  248.     x *= f;
  249.     y *= f;
  250.     z *= f;
  251.     return *this;
  252. }
  254. D3DXINLINE D3DXVECTOR3& 
  255. D3DXVECTOR3::operator /= ( float f )
  256. {
  257.     float fInv = 1.0f / f;
  258.     x *= fInv;
  259.     y *= fInv;
  260.     z *= fInv;
  261.     return *this;
  262. }
  265. // unary operators
  266. D3DXINLINE D3DXVECTOR3 
  267. D3DXVECTOR3::operator + () const
  268. {
  269.     return *this;
  270. }
  272. D3DXINLINE D3DXVECTOR3 
  273. D3DXVECTOR3::operator - () const
  274. {
  275.     return D3DXVECTOR3(-x, -y, -z);
  276. }
  279. // binary operators
  280. D3DXINLINE D3DXVECTOR3 
  281. D3DXVECTOR3::operator + ( const D3DXVECTOR3& v ) const
  282. {
  283.     return D3DXVECTOR3(x + v.x, y + v.y, z + v.z);
  284. }
  286. D3DXINLINE D3DXVECTOR3 
  287. D3DXVECTOR3::operator - ( const D3DXVECTOR3& v ) const
  288. {
  289.     return D3DXVECTOR3(x - v.x, y - v.y, z - v.z);
  290. }
  292. D3DXINLINE D3DXVECTOR3 
  293. D3DXVECTOR3::operator * ( float f ) const
  294. {
  295.     return D3DXVECTOR3(x * f, y * f, z * f);
  296. }
  298. D3DXINLINE D3DXVECTOR3 
  299. D3DXVECTOR3::operator / ( float f ) const
  300. {
  301.     float fInv = 1.0f / f;
  302.     return D3DXVECTOR3(x * fInv, y * fInv, z * fInv);
  303. }
  306. D3DXINLINE D3DXVECTOR3 
  307. operator * ( float f, const struct D3DXVECTOR3& v )
  308. {
  309.     return D3DXVECTOR3(f * v.x, f * v.y, f * v.z);
  310. }
  313. D3DXINLINE BOOL 
  314. D3DXVECTOR3::operator == ( const D3DXVECTOR3& v ) const
  315. {
  316.     return x == v.x && y == v.y && z == v.z;
  317. }
  319. D3DXINLINE BOOL 
  320. D3DXVECTOR3::operator != ( const D3DXVECTOR3& v ) const
  321. {
  322.     return x != v.x || y != v.y || z != v.z;
  323. }
  327. //--------------------------
  328. // 4D Vector
  329. //--------------------------
  330. D3DXINLINE 
  331. D3DXVECTOR4::D3DXVECTOR4( const float *pf )
  332. {
  333. #ifdef D3DX_DEBUG
  334.     if(!pf)
  335.         return;
  336. #endif
  338.     x = pf[0];
  339.     y = pf[1];
  340.     z = pf[2];
  341.     w = pf[3];
  342. }
  344. D3DXINLINE 
  345. D3DXVECTOR4::D3DXVECTOR4( float fx, float fy, float fz, float fw )
  346. {
  347.     x = fx;
  348.     y = fy;
  349.     z = fz;
  350.     w = fw;
  351. }
  354. // casting
  355. D3DXINLINE 
  356. D3DXVECTOR4::operator float* ()
  357. {
  358.     return (float *) &x;
  359. }
  361. D3DXINLINE 
  362. D3DXVECTOR4::operator const float* () const
  363. {
  364.     return (const float *) &x;
  365. }
  368. // assignment operators
  369. D3DXINLINE D3DXVECTOR4& 
  370. D3DXVECTOR4::operator += ( const D3DXVECTOR4& v )
  371. {
  372.     x += v.x;
  373.     y += v.y;
  374.     z += v.z;
  375.     w += v.w;
  376.     return *this;
  377. }
  379. D3DXINLINE D3DXVECTOR4& 
  380. D3DXVECTOR4::operator -= ( const D3DXVECTOR4& v )
  381. {
  382.     x -= v.x;
  383.     y -= v.y;
  384.     z -= v.z;
  385.     w -= v.w;
  386.     return *this;
  387. }
  389. D3DXINLINE D3DXVECTOR4& 
  390. D3DXVECTOR4::operator *= ( float f )
  391. {
  392.     x *= f;
  393.     y *= f;
  394.     z *= f;
  395.     w *= f;
  396.     return *this;
  397. }
  399. D3DXINLINE D3DXVECTOR4& 
  400. D3DXVECTOR4::operator /= ( float f )
  401. {
  402.     float fInv = 1.0f / f;
  403.     x *= fInv;
  404.     y *= fInv;
  405.     z *= fInv;
  406.     w *= fInv;
  407.     return *this;
  408. }
  411. // unary operators
  412. D3DXINLINE D3DXVECTOR4 
  413. D3DXVECTOR4::operator + () const
  414. {
  415.     return *this;
  416. }
  418. D3DXINLINE D3DXVECTOR4 
  419. D3DXVECTOR4::operator - () const
  420. {
  421.     return D3DXVECTOR4(-x, -y, -z, -w);
  422. }
  425. // binary operators
  426. D3DXINLINE D3DXVECTOR4 
  427. D3DXVECTOR4::operator + ( const D3DXVECTOR4& v ) const
  428. {
  429.     return D3DXVECTOR4(x + v.x, y + v.y, z + v.z, w + v.w);
  430. }
  432. D3DXINLINE D3DXVECTOR4 
  433. D3DXVECTOR4::operator - ( const D3DXVECTOR4& v ) const
  434. {
  435.     return D3DXVECTOR4(x - v.x, y - v.y, z - v.z, w - v.w);
  436. }
  438. D3DXINLINE D3DXVECTOR4 
  439. D3DXVECTOR4::operator * ( float f ) const
  440. {
  441.     return D3DXVECTOR4(x * f, y * f, z * f, w * f);
  442. }
  444. D3DXINLINE D3DXVECTOR4 
  445. D3DXVECTOR4::operator / ( float f ) const
  446. {
  447.     float fInv = 1.0f / f;
  448.     return D3DXVECTOR4(x * fInv, y * fInv, z * fInv, w * fInv);
  449. }
  452. D3DXINLINE D3DXVECTOR4 
  453. operator * ( float f, const D3DXVECTOR4& v )
  454. {
  455.     return D3DXVECTOR4(f * v.x, f * v.y, f * v.z, f * v.w);
  456. }
  459. D3DXINLINE BOOL 
  460. D3DXVECTOR4::operator == ( const D3DXVECTOR4& v ) const
  461. {
  462.     return x == v.x && y == v.y && z == v.z && w == v.w;
  463. }
  465. D3DXINLINE BOOL 
  466. D3DXVECTOR4::operator != ( const D3DXVECTOR4& v ) const
  467. {
  468.     return x != v.x || y != v.y || z != v.z || w != v.w;
  469. }
  472. //--------------------------
  473. // Matrix
  474. //--------------------------
  475. D3DXINLINE 
  476. D3DXMATRIX::D3DXMATRIX( const float* pf )
  477. {
  478. #ifdef D3DX_DEBUG
  479.     if(!pf)
  480.         return;
  481. #endif
  483.     memcpy(&m00, pf, sizeof(D3DXMATRIX));
  484. }
  486. D3DXINLINE 
  487. D3DXMATRIX::D3DXMATRIX( const D3DMATRIX& mat )
  488. {
  489.     memcpy(&m00, &mat, sizeof(D3DXMATRIX));
  490. }
  492. D3DXINLINE 
  493. D3DXMATRIX::D3DXMATRIX( float f00, float f01, float f02, float f03,
  494.                         float f10, float f11, float f12, float f13,
  495.                         float f20, float f21, float f22, float f23,
  496.                         float f30, float f31, float f32, float f33 )
  497. {
  498.     m00 = f00; m01 = f01; m02 = f02; m03 = f03;
  499.     m10 = f10; m11 = f11; m12 = f12; m13 = f13;
  500.     m20 = f20; m21 = f21; m22 = f22; m23 = f23;
  501.     m30 = f30; m31 = f31; m32 = f32; m33 = f33;
  502. }
  506. // access grants
  507. D3DXINLINE float& 
  508. D3DXMATRIX::operator () ( UINT iRow, UINT iCol )
  509. {
  510.     return m[iRow][iCol];
  511. }
  513. D3DXINLINE float  
  514. D3DXMATRIX::operator () ( UINT iRow, UINT iCol ) const
  515. {
  516.     return m[iRow][iCol];
  517. }
  520. // casting operators
  521. D3DXINLINE 
  522. D3DXMATRIX::operator float* ()
  523. {
  524.     return (float *) &m00;
  525. }
  527. D3DXINLINE 
  528. D3DXMATRIX::operator const float* () const
  529. {
  530.     return (const float *) &m00;
  531. }
  534. D3DXINLINE 
  535. D3DXMATRIX::operator D3DMATRIX* ()
  536. {
  537.     return (D3DMATRIX *) &m00;
  538. }
  540. D3DXINLINE 
  541. D3DXMATRIX::operator const D3DMATRIX* () const
  542. {
  543.     return (const D3DMATRIX *) &m00;
  544. }
  547. D3DXINLINE 
  548. D3DXMATRIX::operator D3DMATRIX& ()
  549. {
  550.     return *((D3DMATRIX *) &m00);
  551. }
  553. D3DXINLINE 
  554. D3DXMATRIX::operator const D3DMATRIX& () const
  555. {
  556.     return *((const D3DMATRIX *) &m00);
  557. }
  560. // assignment operators
  561. D3DXINLINE D3DXMATRIX& 
  562. D3DXMATRIX::operator *= ( const D3DXMATRIX& mat )
  563. {
  564.     D3DXMatrixMultiply(this, this, &mat);
  565.     return *this;
  566. }
  568. D3DXINLINE D3DXMATRIX& 
  569. D3DXMATRIX::operator += ( const D3DXMATRIX& mat )
  570. {
  571.     m00 += mat.m00; m01 += mat.m01; m02 += mat.m02; m03 += mat.m03;
  572.     m10 += mat.m10; m11 += mat.m11; m12 += mat.m12; m13 += mat.m13;
  573.     m20 += mat.m20; m21 += mat.m21; m22 += mat.m22; m23 += mat.m23;
  574.     m30 += mat.m30; m31 += mat.m31; m32 += mat.m32; m33 += mat.m33;
  575.     return *this;
  576. }
  578. D3DXINLINE D3DXMATRIX& 
  579. D3DXMATRIX::operator -= ( const D3DXMATRIX& mat )
  580. {
  581.     m00 -= mat.m00; m01 -= mat.m01; m02 -= mat.m02; m03 -= mat.m03;
  582.     m10 -= mat.m10; m11 -= mat.m11; m12 -= mat.m12; m13 -= mat.m13;
  583.     m20 -= mat.m20; m21 -= mat.m21; m22 -= mat.m22; m23 -= mat.m23;
  584.     m30 -= mat.m30; m31 -= mat.m31; m32 -= mat.m32; m33 -= mat.m33;
  585.     return *this;
  586. }
  588. D3DXINLINE D3DXMATRIX& 
  589. D3DXMATRIX::operator *= ( float f )
  590. {
  591.     m00 *= f; m01 *= f; m02 *= f; m03 *= f;
  592.     m10 *= f; m11 *= f; m12 *= f; m13 *= f;
  593.     m20 *= f; m21 *= f; m22 *= f; m23 *= f;
  594.     m30 *= f; m31 *= f; m32 *= f; m33 *= f;
  595.     return *this;
  596. }
  598. D3DXINLINE D3DXMATRIX& 
  599. D3DXMATRIX::operator /= ( float f )
  600. {
  601.     float fInv = 1.0f / f;
  602.     m00 *= fInv; m01 *= fInv; m02 *= fInv; m03 *= fInv;
  603.     m10 *= fInv; m11 *= fInv; m12 *= fInv; m13 *= fInv;
  604.     m20 *= fInv; m21 *= fInv; m22 *= fInv; m23 *= fInv;
  605.     m30 *= fInv; m31 *= fInv; m32 *= fInv; m33 *= fInv;
  606.     return *this;
  607. }
  610. // unary operators
  611. D3DXINLINE D3DXMATRIX 
  612. D3DXMATRIX::operator + () const
  613. {
  614.     return *this;
  615. }
  617. D3DXINLINE D3DXMATRIX 
  618. D3DXMATRIX::operator - () const
  619. {
  620.     return D3DXMATRIX(-m00, -m01, -m02, -m03,
  621.                       -m10, -m11, -m12, -m13,
  622.                       -m20, -m21, -m22, -m23,
  623.                       -m30, -m31, -m32, -m33);
  624. }
  627. // binary operators
  628. D3DXINLINE D3DXMATRIX 
  629. D3DXMATRIX::operator * ( const D3DXMATRIX& mat ) const
  630. {
  631.     D3DXMATRIX matT;
  632.     D3DXMatrixMultiply(&matT, this, &mat);
  633.     return matT;
  634. }
  636. D3DXINLINE D3DXMATRIX 
  637. D3DXMATRIX::operator + ( const D3DXMATRIX& mat ) const
  638. {
  639.     return D3DXMATRIX(m00 + mat.m00, m01 + mat.m01, m02 + mat.m02, m03 + mat.m03, 
  640.                       m10 + mat.m10, m11 + mat.m11, m12 + mat.m12, m13 + mat.m13, 
  641.                       m20 + mat.m20, m21 + mat.m21, m22 + mat.m22, m23 + mat.m23, 
  642.                       m30 + mat.m30, m31 + mat.m31, m32 + mat.m32, m33 + mat.m33);
  643. }    
  645. D3DXINLINE D3DXMATRIX 
  646. D3DXMATRIX::operator - ( const D3DXMATRIX& mat ) const
  647. {
  648.     return D3DXMATRIX(m00 - mat.m00, m01 - mat.m01, m02 - mat.m02, m03 - mat.m03, 
  649.                       m10 - mat.m10, m11 - mat.m11, m12 - mat.m12, m13 - mat.m13, 
  650.                       m20 - mat.m20, m21 - mat.m21, m22 - mat.m22, m23 - mat.m23, 
  651.                       m30 - mat.m30, m31 - mat.m31, m32 - mat.m32, m33 - mat.m33);
  652. }
  654. D3DXINLINE D3DXMATRIX 
  655. D3DXMATRIX::operator * ( float f ) const
  656. {
  657.     return D3DXMATRIX(m00 * f, m01 * f, m02 * f, m03 * f, 
  658.                       m10 * f, m11 * f, m12 * f, m13 * f, 
  659.                       m20 * f, m21 * f, m22 * f, m23 * f, 
  660.                       m30 * f, m31 * f, m32 * f, m33 * f);
  661. }
  663. D3DXINLINE D3DXMATRIX 
  664. D3DXMATRIX::operator / ( float f ) const
  665. {
  666.     float fInv = 1.0f / f;
  667.     return D3DXMATRIX(m00 * fInv, m01 * fInv, m02 * fInv, m03 * fInv, 
  668.                       m10 * fInv, m11 * fInv, m12 * fInv, m13 * fInv, 
  669.                       m20 * fInv, m21 * fInv, m22 * fInv, m23 * fInv, 
  670.                       m30 * fInv, m31 * fInv, m32 * fInv, m33 * fInv);
  671. }
  674. D3DXINLINE D3DXMATRIX 
  675. operator * ( float f, const D3DXMATRIX& mat )
  676. {
  677.     return D3DXMATRIX(f * mat.m00, f * mat.m01, f * mat.m02, f * mat.m03, 
  678.                       f * mat.m10, f * mat.m11, f * mat.m12, f * mat.m13, 
  679.                       f * mat.m20, f * mat.m21, f * mat.m22, f * mat.m23, 
  680.                       f * mat.m30, f * mat.m31, f * mat.m32, f * mat.m33);
  681. }
  684. D3DXINLINE BOOL 
  685. D3DXMATRIX::operator == ( const D3DXMATRIX& mat ) const
  686. {
  687.     return 0 == memcmp(this, &mat, sizeof(D3DXMATRIX));
  688. }
  690. D3DXINLINE BOOL 
  691. D3DXMATRIX::operator != ( const D3DXMATRIX& mat ) const
  692. {
  693.     return 0 != memcmp(this, &mat, sizeof(D3DXMATRIX));
  694. }
  698. //--------------------------
  699. // Quaternion
  700. //--------------------------
  702. D3DXINLINE 
  703. D3DXQUATERNION::D3DXQUATERNION( const float* pf )
  704. {
  705. #ifdef D3DX_DEBUG
  706.     if(!pf)
  707.         return;
  708. #endif
  710.     x = pf[0];
  711.     y = pf[1];
  712.     z = pf[2];
  713.     w = pf[3];
  714. }
  716. D3DXINLINE 
  717. D3DXQUATERNION::D3DXQUATERNION( float fx, float fy, float fz, float fw )
  718. {
  719.     x = fx;
  720.     y = fy;
  721.     z = fz;
  722.     w = fw;
  723. }
  726. // casting
  727. D3DXINLINE 
  728. D3DXQUATERNION::operator float* ()
  729. {
  730.     return (float *) &x;
  731. }
  733. D3DXINLINE 
  734. D3DXQUATERNION::operator const float* () const
  735. {
  736.     return (const float *) &x;
  737. }
  740. // assignment operators
  741. D3DXINLINE D3DXQUATERNION& 
  742. D3DXQUATERNION::operator += ( const D3DXQUATERNION& q )
  743. {
  744.     x += q.x;
  745.     y += q.y;
  746.     z += q.z;
  747.     w += q.w;
  748.     return *this;
  749. }
  751. D3DXINLINE D3DXQUATERNION& 
  752. D3DXQUATERNION::operator -= ( const D3DXQUATERNION& q )
  753. {
  754.     x -= q.x;
  755.     y -= q.y;
  756.     z -= q.z;
  757.     w -= q.w;
  758.     return *this;
  759. }
  761. D3DXINLINE D3DXQUATERNION& 
  762. D3DXQUATERNION::operator *= ( const D3DXQUATERNION& q )
  763. {
  764.     D3DXQuaternionMultiply(this, this, &q);
  765.     return *this;
  766. }
  768. D3DXINLINE D3DXQUATERNION& 
  769. D3DXQUATERNION::operator *= ( float f )
  770. {
  771.     x *= f;
  772.     y *= f;
  773.     z *= f;
  774.     w *= f;
  775.     return *this;
  776. }
  778. D3DXINLINE D3DXQUATERNION& 
  779. D3DXQUATERNION::operator /= ( float f )
  780. {
  781.     float fInv = 1.0f / f;
  782.     x *= fInv;
  783.     y *= fInv;
  784.     z *= fInv;
  785.     w *= fInv;
  786.     return *this;
  787. }
  790. // unary operators
  791. D3DXINLINE D3DXQUATERNION  
  792. D3DXQUATERNION::operator + () const
  793. {
  794.     return *this;
  795. }
  797. D3DXINLINE D3DXQUATERNION  
  798. D3DXQUATERNION::operator - () const
  799. {
  800.     return D3DXQUATERNION(-x, -y, -z, -w);
  801. }
  804. // binary operators
  805. D3DXINLINE D3DXQUATERNION 
  806. D3DXQUATERNION::operator + ( const D3DXQUATERNION& q ) const
  807. {
  808.     return D3DXQUATERNION(x + q.x, y + q.y, z + q.z, w + q.w);
  809. }
  811. D3DXINLINE D3DXQUATERNION 
  812. D3DXQUATERNION::operator - ( const D3DXQUATERNION& q ) const
  813. {
  814.     return D3DXQUATERNION(x - q.x, y - q.y, z - q.z, w - q.w);
  815. }
  817. D3DXINLINE D3DXQUATERNION 
  818. D3DXQUATERNION::operator * ( const D3DXQUATERNION& q ) const
  819. {
  820.     D3DXQUATERNION qT;
  821.     D3DXQuaternionMultiply(&qT, this, &q);
  822.     return qT;
  823. }
  825. D3DXINLINE D3DXQUATERNION 
  826. D3DXQUATERNION::operator * ( float f ) const
  827. {
  828.     return D3DXQUATERNION(x * f, y * f, z * f, w * f);
  829. }
  831. D3DXINLINE D3DXQUATERNION 
  832. D3DXQUATERNION::operator / ( float f ) const
  833. {
  834.     float fInv = 1.0f / f;
  835.     return D3DXQUATERNION(x * fInv, y * fInv, z * fInv, w * fInv);
  836. }
  839. D3DXINLINE D3DXQUATERNION 
  840. operator * (float f, const D3DXQUATERNION& q )
  841. {
  842.     return D3DXQUATERNION(f * q.x, f * q.y, f * q.z, f * q.w);
  843. }
  846. D3DXINLINE BOOL 
  847. D3DXQUATERNION::operator == ( const D3DXQUATERNION& q ) const
  848. {
  849.     return x == q.x && y == q.y && z == q.z && w == q.w;
  850. }
  852. D3DXINLINE BOOL 
  853. D3DXQUATERNION::operator != ( const D3DXQUATERNION& q ) const
  854. {
  855.     return x != q.x || y != q.y || z != q.z || w != q.w;
  856. }
  860. //--------------------------
  861. // Plane
  862. //--------------------------
  864. D3DXINLINE 
  865. D3DXPLANE::D3DXPLANE( const float* pf )
  866. {
  867. #ifdef D3DX_DEBUG
  868.     if(!pf)
  869.         return;
  870. #endif
  872.     a = pf[0];
  873.     b = pf[1];
  874.     c = pf[2];
  875.     d = pf[3];
  876. }
  878. D3DXINLINE 
  879. D3DXPLANE::D3DXPLANE( float fa, float fb, float fc, float fd )
  880. {
  881.     a = fa;
  882.     b = fb;
  883.     c = fc;
  884.     d = fd;
  885. }
  888. // casting
  889. D3DXINLINE 
  890. D3DXPLANE::operator float* ()
  891. {
  892.     return (float *) &a;
  893. }
  895. D3DXINLINE 
  896. D3DXPLANE::operator const float* () const
  897. {
  898.     return (const float *) &a;
  899. }
  902. // unary operators
  903. D3DXINLINE D3DXPLANE 
  904. D3DXPLANE::operator + () const
  905. {
  906.     return *this;
  907. }
  909. D3DXINLINE D3DXPLANE 
  910. D3DXPLANE::operator - () const
  911. {
  912.     return D3DXPLANE(-a, -b, -c, -d);
  913. }
  916. // binary operators
  917. D3DXINLINE BOOL 
  918. D3DXPLANE::operator == ( const D3DXPLANE& p ) const
  919. {
  920.     return a == p.a && b == p.b && c == p.c && d == p.d;
  921. }
  923. D3DXINLINE BOOL 
  924. D3DXPLANE::operator != ( const D3DXPLANE& p ) const
  925. {
  926.     return a != p.a || b != p.b || c != p.c || d != p.d;
  927. }
  932. //--------------------------
  933. // Color
  934. //--------------------------
  936. D3DXINLINE 
  937. D3DXCOLOR::D3DXCOLOR( DWORD dw )
  938. {
  939.     const float f = 1.0f / 255.0f;
  940.     r = f * (float) (unsigned char) (dw >> 16);
  941.     g = f * (float) (unsigned char) (dw >>  8);
  942.     b = f * (float) (unsigned char) (dw >>  0);
  943.     a = f * (float) (unsigned char) (dw >> 24);
  944. }
  946. D3DXINLINE 
  947. D3DXCOLOR::D3DXCOLOR( const float* pf )
  948. {
  949. #ifdef D3DX_DEBUG
  950.     if(!pf)
  951.         return;
  952. #endif
  954.     r = pf[0];
  955.     g = pf[1];
  956.     b = pf[2];
  957.     a = pf[3];
  958. }
  960. D3DXINLINE 
  961. D3DXCOLOR::D3DXCOLOR( const D3DCOLORVALUE& c )
  962. {
  963.     r = c.r;
  964.     g = c.g;
  965.     b = c.b;
  966.     a = c.a;
  967. }
  969. D3DXINLINE 
  970. D3DXCOLOR::D3DXCOLOR( float fr, float fg, float fb, float fa )
  971. {
  972.     r = fr;
  973.     g = fg;
  974.     b = fb;
  975.     a = fa;
  976. }
  979. // casting
  980. D3DXINLINE 
  981. D3DXCOLOR::operator DWORD () const
  982. {
  983.     DWORD dwR = r >= 1.0f ? 0xff : r <= 0.0f ? 0x00 : (DWORD) (r * 255.0f + 0.5f);
  984.     DWORD dwG = g >= 1.0f ? 0xff : g <= 0.0f ? 0x00 : (DWORD) (g * 255.0f + 0.5f);
  985.     DWORD dwB = b >= 1.0f ? 0xff : b <= 0.0f ? 0x00 : (DWORD) (b * 255.0f + 0.5f);
  986.     DWORD dwA = a >= 1.0f ? 0xff : a <= 0.0f ? 0x00 : (DWORD) (a * 255.0f + 0.5f);
  988.     return (dwA << 24) | (dwR << 16) | (dwG << 8) | dwB;
  989. }
  992. D3DXINLINE 
  993. D3DXCOLOR::operator float * ()
  994. {
  995.     return (float *) &r;
  996. }
  998. D3DXINLINE 
  999. D3DXCOLOR::operator const float * () const
  1000. {
  1001.     return (const float *) &r;
  1002. }
  1005. D3DXINLINE 
  1006. D3DXCOLOR::operator D3DCOLORVALUE * ()
  1007. {
  1008.     return (D3DCOLORVALUE *) &r;
  1009. }
  1011. D3DXINLINE 
  1012. D3DXCOLOR::operator const D3DCOLORVALUE * () const
  1013. {
  1014.     return (const D3DCOLORVALUE *) &r;
  1015. }
  1018. D3DXINLINE 
  1019. D3DXCOLOR::operator D3DCOLORVALUE& ()
  1020. {
  1021.     return *((D3DCOLORVALUE *) &r);
  1022. }
  1024. D3DXINLINE 
  1025. D3DXCOLOR::operator const D3DCOLORVALUE& () const
  1026. {
  1027.     return *((const D3DCOLORVALUE *) &r);
  1028. }
  1031. // assignment operators
  1032. D3DXINLINE D3DXCOLOR& 
  1033. D3DXCOLOR::operator += ( const D3DXCOLOR& c )
  1034. {
  1035.     r += c.r;
  1036.     g += c.g;
  1037.     b += c.b;
  1038.     a += c.a;
  1039.     return *this;
  1040. }
  1042. D3DXINLINE D3DXCOLOR& 
  1043. D3DXCOLOR::operator -= ( const D3DXCOLOR& c )
  1044. {
  1045.     r -= c.r;
  1046.     g -= c.g;
  1047.     b -= c.b;
  1048.     a -= c.a;
  1049.     return *this;
  1050. }
  1052. D3DXINLINE D3DXCOLOR& 
  1053. D3DXCOLOR::operator *= ( float f )
  1054. {
  1055.     r *= f;
  1056.     g *= f;
  1057.     b *= f;
  1058.     a *= f;
  1059.     return *this;
  1060. }
  1062. D3DXINLINE D3DXCOLOR& 
  1063. D3DXCOLOR::operator /= ( float f )
  1064. {
  1065.     float fInv = 1.0f / f;
  1066.     r *= fInv;
  1067.     g *= fInv;
  1068.     b *= fInv;
  1069.     a *= fInv;
  1070.     return *this;
  1071. }
  1074. // unary operators
  1075. D3DXINLINE D3DXCOLOR 
  1076. D3DXCOLOR::operator + () const
  1077. {
  1078.     return *this;
  1079. }
  1081. D3DXINLINE D3DXCOLOR 
  1082. D3DXCOLOR::operator - () const
  1083. {
  1084.     return D3DXCOLOR(-r, -g, -b, -a);
  1085. }
  1088. // binary operators
  1089. D3DXINLINE D3DXCOLOR 
  1090. D3DXCOLOR::operator + ( const D3DXCOLOR& c ) const
  1091. {
  1092.     return D3DXCOLOR(r + c.r, g + c.g, b + c.b, a + c.a);
  1093. }
  1095. D3DXINLINE D3DXCOLOR 
  1096. D3DXCOLOR::operator - ( const D3DXCOLOR& c ) const
  1097. {
  1098.     return D3DXCOLOR(r - c.r, g - c.g, b - c.b, a - c.a);
  1099. }
  1101. D3DXINLINE D3DXCOLOR 
  1102. D3DXCOLOR::operator * ( float f ) const
  1103. {
  1104.     return D3DXCOLOR(r * f, g * f, b * f, a * f);
  1105. }
  1107. D3DXINLINE D3DXCOLOR 
  1108. D3DXCOLOR::operator / ( float f ) const
  1109. {
  1110.     float fInv = 1.0f / f;
  1111.     return D3DXCOLOR(r * fInv, g * fInv, b * fInv, a * fInv);
  1112. }
  1115. D3DXINLINE D3DXCOLOR 
  1116. operator * (float f, const D3DXCOLOR& c )
  1117. {
  1118.     return D3DXCOLOR(f * c.r, f * c.g, f * c.b, f * c.a);
  1119. }
  1122. D3DXINLINE BOOL 
  1123. D3DXCOLOR::operator == ( const D3DXCOLOR& c ) const
  1124. {
  1125.     return r == c.r && g == c.g && b == c.b && a == c.a;
  1126. }
  1128. D3DXINLINE BOOL 
  1129. D3DXCOLOR::operator != ( const D3DXCOLOR& c ) const
  1130. {
  1131.     return r != c.r || g != c.g || b != c.b || a != c.a;
  1132. }
  1135. #endif //__cplusplus
  1139. //===========================================================================
  1140. //
  1141. // Inline functions
  1142. //
  1143. //===========================================================================
  1146. //--------------------------
  1147. // 2D Vector
  1148. //--------------------------
  1150. D3DXINLINE float D3DXVec2Length
  1151.     ( const D3DXVECTOR2 *pV )
  1152. {
  1153. #ifdef D3DX_DEBUG
  1154.     if(!pV)
  1155.         return 0.0f;
  1156. #endif
  1158. #ifdef __cplusplus
  1159.     return sqrtf(pV->x * pV->x + pV->y * pV->y);
  1160. #else
  1161.     return (float) sqrt(pV->x * pV->x + pV->y * pV->y);
  1162. #endif 
  1163. }
  1165. D3DXINLINE float D3DXVec2LengthSq
  1166.     ( const D3DXVECTOR2 *pV )
  1167. {
  1168. #ifdef D3DX_DEBUG
  1169.     if(!pV)
  1170.         return 0.0f;
  1171. #endif
  1173.     return pV->x * pV->x + pV->y * pV->y;
  1174. }
  1176. D3DXINLINE float D3DXVec2Dot
  1177.     ( const D3DXVECTOR2 *pV1, const D3DXVECTOR2 *pV2 )
  1178. {
  1179. #ifdef D3DX_DEBUG
  1180.     if(!pV1 || !pV2)
  1181.         return 0.0f;
  1182. #endif
  1184.     return pV1->x * pV2->x + pV1->y * pV2->y;
  1185. }
  1187. D3DXINLINE float D3DXVec2CCW
  1188.     ( const D3DXVECTOR2 *pV1, const D3DXVECTOR2 *pV2 )
  1189. {
  1190. #ifdef D3DX_DEBUG
  1191.     if(!pV1 || !pV2)
  1192.         return 0.0f;
  1193. #endif
  1195.     return pV1->x * pV2->y - pV1->y * pV2->x;
  1196. }
  1198. D3DXINLINE D3DXVECTOR2* D3DXVec2Add
  1199.     ( D3DXVECTOR2 *pOut, const D3DXVECTOR2 *pV1, const D3DXVECTOR2 *pV2 )
  1200. {
  1201. #ifdef D3DX_DEBUG
  1202.     if(!pOut || !pV1 || !pV2)
  1203.         return NULL;
  1204. #endif
  1206.     pOut->x = pV1->x + pV2->x;
  1207.     pOut->y = pV1->y + pV2->y;
  1208.     return pOut;
  1209. }
  1211. D3DXINLINE D3DXVECTOR2* D3DXVec2Subtract
  1212.     ( D3DXVECTOR2 *pOut, const D3DXVECTOR2 *pV1, const D3DXVECTOR2 *pV2 )
  1213. {
  1214. #ifdef D3DX_DEBUG
  1215.     if(!pOut || !pV1 || !pV2)
  1216.         return NULL;
  1217. #endif
  1219.     pOut->x = pV1->x - pV2->x;
  1220.     pOut->y = pV1->y - pV2->y;
  1221.     return pOut;
  1222. }
  1224. D3DXINLINE D3DXVECTOR2* D3DXVec2Minimize
  1225.     ( D3DXVECTOR2 *pOut, const D3DXVECTOR2 *pV1, const D3DXVECTOR2 *pV2 )
  1226. {
  1227. #ifdef D3DX_DEBUG
  1228.     if(!pOut || !pV1 || !pV2)
  1229.         return NULL;
  1230. #endif
  1232.     pOut->x = pV1->x < pV2->x ? pV1->x : pV2->x;
  1233.     pOut->y = pV1->y < pV2->y ? pV1->y : pV2->y;
  1234.     return pOut;
  1235. }
  1237. D3DXINLINE D3DXVECTOR2* D3DXVec2Maximize
  1238.     ( D3DXVECTOR2 *pOut, const D3DXVECTOR2 *pV1, const D3DXVECTOR2 *pV2 )
  1239. {
  1240. #ifdef D3DX_DEBUG
  1241.     if(!pOut || !pV1 || !pV2)
  1242.         return NULL;
  1243. #endif
  1245.     pOut->x = pV1->x > pV2->x ? pV1->x : pV2->x;
  1246.     pOut->y = pV1->y > pV2->y ? pV1->y : pV2->y;
  1247.     return pOut;
  1248. }
  1250. D3DXINLINE D3DXVECTOR2* D3DXVec2Scale
  1251.     ( D3DXVECTOR2 *pOut, const D3DXVECTOR2 *pV, float s )
  1252. {
  1253. #ifdef D3DX_DEBUG
  1254.     if(!pOut || !pV)
  1255.         return NULL;
  1256. #endif
  1258.     pOut->x = pV->x * s;
  1259.     pOut->y = pV->y * s;
  1260.     return pOut;
  1261. }
  1263. D3DXINLINE D3DXVECTOR2* D3DXVec2Lerp
  1264.     ( D3DXVECTOR2 *pOut, const D3DXVECTOR2 *pV1, const D3DXVECTOR2 *pV2,
  1265.       float s )
  1266. {
  1267. #ifdef D3DX_DEBUG
  1268.     if(!pOut || !pV1 || !pV2)
  1269.         return NULL;
  1270. #endif
  1272.     pOut->x = pV1->x + s * (pV2->x - pV1->x);
  1273.     pOut->y = pV1->y + s * (pV2->y - pV1->y);
  1274.     return pOut;
  1275. }
  1278. //--------------------------
  1279. // 3D Vector
  1280. //--------------------------
  1282. D3DXINLINE float D3DXVec3Length
  1283.     ( const D3DXVECTOR3 *pV )
  1284. {
  1285. #ifdef D3DX_DEBUG
  1286.     if(!pV)
  1287.         return 0.0f;
  1288. #endif
  1290. #ifdef __cplusplus
  1291.     return sqrtf(pV->x * pV->x + pV->y * pV->y + pV->z * pV->z);
  1292. #else
  1293.     return (float) sqrt(pV->x * pV->x + pV->y * pV->y + pV->z * pV->z);
  1294. #endif
  1295. }
  1297. D3DXINLINE float D3DXVec3LengthSq
  1298.     ( const D3DXVECTOR3 *pV )
  1299. {
  1300. #ifdef D3DX_DEBUG
  1301.     if(!pV)
  1302.         return 0.0f;
  1303. #endif
  1305.     return pV->x * pV->x + pV->y * pV->y + pV->z * pV->z;
  1306. }
  1308. D3DXINLINE float D3DXVec3Dot
  1309.     ( const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pV2 )
  1310. {
  1311. #ifdef D3DX_DEBUG
  1312.     if(!pV1 || !pV2)
  1313.         return 0.0f;
  1314. #endif
  1316.     return pV1->x * pV2->x + pV1->y * pV2->y + pV1->z * pV2->z;
  1317. }
  1319. D3DXINLINE D3DXVECTOR3* D3DXVec3Cross
  1320.     ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pV2 )
  1321. {
  1322.     D3DXVECTOR3 v;
  1324. #ifdef D3DX_DEBUG
  1325.     if(!pOut || !pV1 || !pV2)
  1326.         return NULL;
  1327. #endif
  1329.     v.x = pV1->y * pV2->z - pV1->z * pV2->y;
  1330.     v.y = pV1->z * pV2->x - pV1->x * pV2->z;
  1331.     v.z = pV1->x * pV2->y - pV1->y * pV2->x;
  1333.     *pOut = v;
  1334.     return pOut;
  1335. }
  1337. D3DXINLINE D3DXVECTOR3* D3DXVec3Add
  1338.     ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pV2 )
  1339. {
  1340. #ifdef D3DX_DEBUG
  1341.     if(!pOut || !pV1 || !pV2)
  1342.         return NULL;
  1343. #endif
  1345.     pOut->x = pV1->x + pV2->x;
  1346.     pOut->y = pV1->y + pV2->y;
  1347.     pOut->z = pV1->z + pV2->z;
  1348.     return pOut;
  1349. }
  1351. D3DXINLINE D3DXVECTOR3* D3DXVec3Subtract
  1352.     ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pV2 )
  1353. {
  1354. #ifdef D3DX_DEBUG
  1355.     if(!pOut || !pV1 || !pV2)
  1356.         return NULL;
  1357. #endif
  1359.     pOut->x = pV1->x - pV2->x;
  1360.     pOut->y = pV1->y - pV2->y;
  1361.     pOut->z = pV1->z - pV2->z;
  1362.     return pOut;
  1363. }
  1365. D3DXINLINE D3DXVECTOR3* D3DXVec3Minimize
  1366.     ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pV2 )
  1367. {
  1368. #ifdef D3DX_DEBUG
  1369.     if(!pOut || !pV1 || !pV2)
  1370.         return NULL;
  1371. #endif
  1373.     pOut->x = pV1->x < pV2->x ? pV1->x : pV2->x;
  1374.     pOut->y = pV1->y < pV2->y ? pV1->y : pV2->y;
  1375.     pOut->z = pV1->z < pV2->z ? pV1->z : pV2->z;
  1376.     return pOut;
  1377. }
  1379. D3DXINLINE D3DXVECTOR3* D3DXVec3Maximize
  1380.     ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pV2 )
  1381. {
  1382. #ifdef D3DX_DEBUG
  1383.     if(!pOut || !pV1 || !pV2)
  1384.         return NULL;
  1385. #endif
  1387.     pOut->x = pV1->x > pV2->x ? pV1->x : pV2->x;
  1388.     pOut->y = pV1->y > pV2->y ? pV1->y : pV2->y;
  1389.     pOut->z = pV1->z > pV2->z ? pV1->z : pV2->z;
  1390.     return pOut;
  1391. }
  1393. D3DXINLINE D3DXVECTOR3* D3DXVec3Scale
  1394.     ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV, float s)
  1395. {
  1396. #ifdef D3DX_DEBUG
  1397.     if(!pOut || !pV)
  1398.         return NULL;
  1399. #endif
  1401.     pOut->x = pV->x * s;
  1402.     pOut->y = pV->y * s;
  1403.     pOut->z = pV->z * s;
  1404.     return pOut;
  1405. }
  1407. D3DXINLINE D3DXVECTOR3* D3DXVec3Lerp
  1408.     ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pV2,
  1409.       float s )
  1410. {
  1411. #ifdef D3DX_DEBUG
  1412.     if(!pOut || !pV1 || !pV2)
  1413.         return NULL;
  1414. #endif
  1416.     pOut->x = pV1->x + s * (pV2->x - pV1->x);
  1417.     pOut->y = pV1->y + s * (pV2->y - pV1->y);
  1418.     pOut->z = pV1->z + s * (pV2->z - pV1->z);
  1419.     return pOut;
  1420. }
  1423. //--------------------------
  1424. // 4D Vector
  1425. //--------------------------
  1427. D3DXINLINE float D3DXVec4Length
  1428.     ( const D3DXVECTOR4 *pV )
  1429. {
  1430. #ifdef D3DX_DEBUG
  1431.     if(!pV)
  1432.         return 0.0f;
  1433. #endif
  1435. #ifdef __cplusplus
  1436.     return sqrtf(pV->x * pV->x + pV->y * pV->y + pV->z * pV->z + pV->w * pV->w);
  1437. #else
  1438.     return (float) sqrt(pV->x * pV->x + pV->y * pV->y + pV->z * pV->z + pV->w * pV->w);
  1439. #endif
  1440. }
  1442. D3DXINLINE float D3DXVec4LengthSq
  1443.     ( const D3DXVECTOR4 *pV )
  1444. {
  1445. #ifdef D3DX_DEBUG
  1446.     if(!pV)
  1447.         return 0.0f;
  1448. #endif
  1450.     return pV->x * pV->x + pV->y * pV->y + pV->z * pV->z + pV->w * pV->w;
  1451. }
  1453. D3DXINLINE float D3DXVec4Dot
  1454.     ( const D3DXVECTOR4 *pV1, const D3DXVECTOR4 *pV2 )
  1455. {
  1456. #ifdef D3DX_DEBUG
  1457.     if(!pV1 || !pV2)
  1458.         return 0.0f;
  1459. #endif
  1461.     return pV1->x * pV2->x + pV1->y * pV2->y + pV1->z * pV2->z + pV1->w * pV2->w;
  1462. }
  1464. D3DXINLINE D3DXVECTOR4* D3DXVec4Add
  1465.     ( D3DXVECTOR4 *pOut, const D3DXVECTOR4 *pV1, const D3DXVECTOR4 *pV2)
  1466. {
  1467. #ifdef D3DX_DEBUG
  1468.     if(!pOut || !pV1 || !pV2)
  1469.         return NULL;
  1470. #endif
  1472.     pOut->x = pV1->x + pV2->x;
  1473.     pOut->y = pV1->y + pV2->y;
  1474.     pOut->z = pV1->z + pV2->z;
  1475.     pOut->w = pV1->w + pV2->w;
  1476.     return pOut;
  1477. }
  1479. D3DXINLINE D3DXVECTOR4* D3DXVec4Subtract
  1480.     ( D3DXVECTOR4 *pOut, const D3DXVECTOR4 *pV1, const D3DXVECTOR4 *pV2)
  1481. {
  1482. #ifdef D3DX_DEBUG
  1483.     if(!pOut || !pV1 || !pV2)
  1484.         return NULL;
  1485. #endif
  1487.     pOut->x = pV1->x - pV2->x;
  1488.     pOut->y = pV1->y - pV2->y;
  1489.     pOut->z = pV1->z - pV2->z;
  1490.     pOut->w = pV1->w - pV2->w;
  1491.     return pOut;
  1492. }
  1494. D3DXINLINE D3DXVECTOR4* D3DXVec4Minimize
  1495.     ( D3DXVECTOR4 *pOut, const D3DXVECTOR4 *pV1, const D3DXVECTOR4 *pV2)
  1496. {
  1497. #ifdef D3DX_DEBUG
  1498.     if(!pOut || !pV1 || !pV2)
  1499.         return NULL;
  1500. #endif
  1502.     pOut->x = pV1->x < pV2->x ? pV1->x : pV2->x;
  1503.     pOut->y = pV1->y < pV2->y ? pV1->y : pV2->y;
  1504.     pOut->z = pV1->z < pV2->z ? pV1->z : pV2->z;
  1505.     pOut->w = pV1->w < pV2->w ? pV1->w : pV2->w;
  1506.     return pOut;
  1507. }
  1509. D3DXINLINE D3DXVECTOR4* D3DXVec4Maximize
  1510.     ( D3DXVECTOR4 *pOut, const D3DXVECTOR4 *pV1, const D3DXVECTOR4 *pV2)
  1511. {
  1512. #ifdef D3DX_DEBUG
  1513.     if(!pOut || !pV1 || !pV2)
  1514.         return NULL;
  1515. #endif
  1517.     pOut->x = pV1->x > pV2->x ? pV1->x : pV2->x;
  1518.     pOut->y = pV1->y > pV2->y ? pV1->y : pV2->y;
  1519.     pOut->z = pV1->z > pV2->z ? pV1->z : pV2->z;
  1520.     pOut->w = pV1->w > pV2->w ? pV1->w : pV2->w;
  1521.     return pOut;
  1522. }
  1524. D3DXINLINE D3DXVECTOR4* D3DXVec4Scale
  1525.     ( D3DXVECTOR4 *pOut, const D3DXVECTOR4 *pV, float s)
  1526. {
  1527. #ifdef D3DX_DEBUG
  1528.     if(!pOut || !pV)
  1529.         return NULL;
  1530. #endif
  1532.     pOut->x = pV->x * s;
  1533.     pOut->y = pV->y * s;
  1534.     pOut->z = pV->z * s;
  1535.     pOut->w = pV->w * s;
  1536.     return pOut;
  1537. }
  1539. D3DXINLINE D3DXVECTOR4* D3DXVec4Lerp
  1540.     ( D3DXVECTOR4 *pOut, const D3DXVECTOR4 *pV1, const D3DXVECTOR4 *pV2,
  1541.       float s )
  1542. {
  1543. #ifdef D3DX_DEBUG
  1544.     if(!pOut || !pV1 || !pV2)
  1545.         return NULL;
  1546. #endif
  1548.     pOut->x = pV1->x + s * (pV2->x - pV1->x);
  1549.     pOut->y = pV1->y + s * (pV2->y - pV1->y);
  1550.     pOut->z = pV1->z + s * (pV2->z - pV1->z);
  1551.     pOut->w = pV1->w + s * (pV2->w - pV1->w);
  1552.     return pOut;
  1553. }
  1556. //--------------------------
  1557. // 4D Matrix
  1558. //--------------------------
  1560. D3DXINLINE D3DXMATRIX* D3DXMatrixIdentity
  1561.     ( D3DXMATRIX *pOut )
  1562. {
  1563. #ifdef D3DX_DEBUG
  1564.     if(!pOut)
  1565.         return NULL;
  1566. #endif
  1568.     pOut->m[0][1] = pOut->m[0][2] = pOut->m[0][3] = 
  1569.     pOut->m[1][0] = pOut->m[1][2] = pOut->m[1][3] = 
  1570.     pOut->m[2][0] = pOut->m[2][1] = pOut->m[2][3] = 
  1571.     pOut->m[3][0] = pOut->m[3][1] = pOut->m[3][2] = 0.0f;
  1573.     pOut->m[0][0] = pOut->m[1][1] = pOut->m[2][2] = pOut->m[3][3] = 1.0f;
  1574.     return pOut;
  1575. }
  1578. D3DXINLINE BOOL D3DXMatrixIsIdentity
  1579.     ( const D3DXMATRIX *pM )
  1580. {
  1581. #ifdef D3DX_DEBUG
  1582.     if(!pM)
  1583.         return FALSE;
  1584. #endif
  1586.     return pM->m[0][0] == 1.0f && pM->m[0][1] == 0.0f && pM->m[0][2] == 0.0f && pM->m[0][3] == 0.0f &&
  1587.            pM->m[1][0] == 0.0f && pM->m[1][1] == 1.0f && pM->m[1][2] == 0.0f && pM->m[1][3] == 0.0f &&
  1588.            pM->m[2][0] == 0.0f && pM->m[2][1] == 0.0f && pM->m[2][2] == 1.0f && pM->m[2][3] == 0.0f &&
  1589.            pM->m[3][0] == 0.0f && pM->m[3][1] == 0.0f && pM->m[3][2] == 0.0f && pM->m[3][3] == 1.0f;
  1590. }
  1593. //--------------------------
  1594. // Quaternion
  1595. //--------------------------
  1597. D3DXINLINE float D3DXQuaternionLength
  1598.     ( const D3DXQUATERNION *pQ )
  1599. {
  1600. #ifdef D3DX_DEBUG
  1601.     if(!pQ)
  1602.         return 0.0f;
  1603. #endif
  1605. #ifdef __cplusplus
  1606.     return sqrtf(pQ->x * pQ->x + pQ->y * pQ->y + pQ->z * pQ->z + pQ->w * pQ->w);
  1607. #else
  1608.     return (float) sqrt(pQ->x * pQ->x + pQ->y * pQ->y + pQ->z * pQ->z + pQ->w * pQ->w);
  1609. #endif
  1610. }
  1612. D3DXINLINE float D3DXQuaternionLengthSq
  1613.     ( const D3DXQUATERNION *pQ )
  1614. {
  1615. #ifdef D3DX_DEBUG
  1616.     if(!pQ)
  1617.         return 0.0f;
  1618. #endif
  1620.     return pQ->x * pQ->x + pQ->y * pQ->y + pQ->z * pQ->z + pQ->w * pQ->w;
  1621. }
  1623. D3DXINLINE float D3DXQuaternionDot
  1624.     ( const D3DXQUATERNION *pQ1, const D3DXQUATERNION *pQ2 )
  1625. {
  1626. #ifdef D3DX_DEBUG
  1627.     if(!pQ1 || !pQ2)
  1628.         return 0.0f;
  1629. #endif
  1631.     return pQ1->x * pQ2->x + pQ1->y * pQ2->y + pQ1->z * pQ2->z + pQ1->w * pQ2->w;
  1632. }
  1635. D3DXINLINE D3DXQUATERNION* D3DXQuaternionIdentity
  1636.     ( D3DXQUATERNION *pOut )
  1637. {
  1638. #ifdef D3DX_DEBUG
  1639.     if(!pOut)
  1640.         return NULL;
  1641. #endif
  1643.     pOut->x = pOut->y = pOut->z = 0.0f;
  1644.     pOut->w = 1.0f;
  1645.     return pOut;
  1646. }
  1648. D3DXINLINE BOOL D3DXQuaternionIsIdentity
  1649.     ( const D3DXQUATERNION *pQ )
  1650. {
  1651. #ifdef D3DX_DEBUG
  1652.     if(!pQ)
  1653.         return FALSE;
  1654. #endif
  1656.     return pQ->x == 0.0f && pQ->y == 0.0f && pQ->z == 0.0f && pQ->w == 1.0f;
  1657. }
  1660. D3DXINLINE D3DXQUATERNION* D3DXQuaternionConjugate
  1661.     ( D3DXQUATERNION *pOut, const D3DXQUATERNION *pQ )
  1662. {
  1663. #ifdef D3DX_DEBUG
  1664.     if(!pOut || !pQ)
  1665.         return NULL;
  1666. #endif
  1668.     pOut->x = -pQ->x;
  1669.     pOut->y = -pQ->y;
  1670.     pOut->z = -pQ->z;
  1671.     pOut->w =  pQ->w;
  1672.     return pOut;
  1673. }
  1676. //--------------------------
  1677. // Plane
  1678. //--------------------------
  1680. D3DXINLINE float D3DXPlaneDot
  1681.     ( const D3DXPLANE *pP, const D3DXVECTOR4 *pV)
  1682. {
  1683. #ifdef D3DX_DEBUG
  1684.     if(!pP || !pV)
  1685.         return 0.0f;
  1686. #endif
  1688.     return pP->a * pV->x + pP->b * pV->y + pP->c * pV->z + pP->d * pV->w;
  1689. }
  1691. D3DXINLINE float D3DXPlaneDotCoord
  1692.     ( const D3DXPLANE *pP, const D3DXVECTOR3 *pV)
  1693. {
  1694. #ifdef D3DX_DEBUG
  1695.     if(!pP || !pV)
  1696.         return 0.0f;
  1697. #endif
  1699.     return pP->a * pV->x + pP->b * pV->y + pP->c * pV->z + pP->d;
  1700. }
  1702. D3DXINLINE float D3DXPlaneDotNormal
  1703.     ( const D3DXPLANE *pP, const D3DXVECTOR3 *pV)
  1704. {
  1705. #ifdef D3DX_DEBUG
  1706.     if(!pP || !pV)
  1707.         return 0.0f;
  1708. #endif
  1710.     return pP->a * pV->x + pP->b * pV->y + pP->c * pV->z;
  1711. }
  1714. //--------------------------
  1715. // Color
  1716. //--------------------------
  1718. D3DXINLINE D3DXCOLOR* D3DXColorNegative
  1719.     (D3DXCOLOR *pOut, const D3DXCOLOR *pC)
  1720. {
  1721. #ifdef D3DX_DEBUG
  1722.     if(!pOut || !pC)
  1723.         return NULL;
  1724. #endif
  1726.     pOut->r = 1.0f - pC->r;
  1727.     pOut->g = 1.0f - pC->g;
  1728.     pOut->b = 1.0f - pC->b;
  1729.     pOut->a = pC->a;
  1730.     return pOut;
  1731. }
  1733. D3DXINLINE D3DXCOLOR* D3DXColorAdd        
  1734.     (D3DXCOLOR *pOut, const D3DXCOLOR *pC1, const D3DXCOLOR *pC2)
  1735. {
  1736. #ifdef D3DX_DEBUG
  1737.     if(!pOut || !pC1 || !pC2)
  1738.         return NULL;
  1739. #endif
  1741.     pOut->r = pC1->r + pC2->r;
  1742.     pOut->g = pC1->g + pC2->g;
  1743.     pOut->b = pC1->b + pC2->b;
  1744.     pOut->a = pC1->a + pC2->a;
  1745.     return pOut;
  1746. }
  1748. D3DXINLINE D3DXCOLOR* D3DXColorSubtract   
  1749.     (D3DXCOLOR *pOut, const D3DXCOLOR *pC1, const D3DXCOLOR *pC2)
  1750. {
  1751. #ifdef D3DX_DEBUG
  1752.     if(!pOut || !pC1 || !pC2)
  1753.         return NULL;
  1754. #endif
  1756.     pOut->r = pC1->r - pC2->r;
  1757.     pOut->g = pC1->g - pC2->g;
  1758.     pOut->b = pC1->b - pC2->b;
  1759.     pOut->a = pC1->a - pC2->a;
  1760.     return pOut;
  1761. }
  1763. D3DXINLINE D3DXCOLOR* D3DXColorScale      
  1764.     (D3DXCOLOR *pOut, const D3DXCOLOR *pC, float s)
  1765. {
  1766. #ifdef D3DX_DEBUG
  1767.     if(!pOut || !pC)
  1768.         return NULL;
  1769. #endif
  1771.     pOut->r = pC->r * s;
  1772.     pOut->g = pC->g * s;
  1773.     pOut->b = pC->b * s;
  1774.     pOut->a = pC->a * s;
  1775.     return pOut;
  1776. } 
  1778. D3DXINLINE D3DXCOLOR* D3DXColorModulate   
  1779.     (D3DXCOLOR *pOut, const D3DXCOLOR *pC1, const D3DXCOLOR *pC2)
  1780. {
  1781. #ifdef D3DX_DEBUG
  1782.     if(!pOut || !pC1 || !pC2)
  1783.         return NULL;
  1784. #endif
  1786.     pOut->r = pC1->r * pC2->r;
  1787.     pOut->g = pC1->g * pC2->g;
  1788.     pOut->b = pC1->b * pC2->b;
  1789.     pOut->a = pC1->a * pC2->a;
  1790.     return pOut;
  1791. }
  1793. D3DXINLINE D3DXCOLOR* D3DXColorLerp       
  1794.     (D3DXCOLOR *pOut, const D3DXCOLOR *pC1, const D3DXCOLOR *pC2, float s)
  1795. {
  1796. #ifdef D3DX_DEBUG
  1797.     if(!pOut || !pC1 || !pC2)
  1798.         return NULL;
  1799. #endif
  1801.     pOut->r = pC1->r + s * (pC2->r - pC1->r);
  1802.     pOut->g = pC1->g + s * (pC2->g - pC1->g);
  1803.     pOut->b = pC1->b + s * (pC2->b - pC1->b);
  1804.     pOut->a = pC1->a + s * (pC2->a - pC1->a);
  1805.     return pOut;
  1806. }
  1809. #endif // __D3DXMATH_INL__