Home | History | Annotate | Download | only in include
      1 /*
      2  * Copyright (C) 2007 David Adam
      3  * Copyright (C) 2007 Tony Wasserka
      4  *
      5  * This library is free software; you can redistribute it and/or
      6  * modify it under the terms of the GNU Lesser General Public
      7  * License as published by the Free Software Foundation; either
      8  * version 2.1 of the License, or (at your option) any later version.
      9  *
     10  * This library is distributed in the hope that it will be useful,
     11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
     12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     13  * Lesser General Public License for more details.
     14  *
     15  * You should have received a copy of the GNU Lesser General Public
     16  * License along with this library; if not, write to the Free Software
     17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
     18  */
     19 
     20 #ifndef __D3DX9MATH_INL__
     21 #define __D3DX9MATH_INL__
     22 
     23 /* constructors & operators */
     24 #ifdef __cplusplus
     25 
     26 inline D3DXVECTOR2::D3DXVECTOR2()
     27 {
     28 }
     29 
     30 inline D3DXVECTOR2::D3DXVECTOR2(CONST FLOAT *pf)
     31 {
     32     if(!pf) return;
     33     x = pf[0];
     34     y = pf[1];
     35 }
     36 
     37 inline D3DXVECTOR2::D3DXVECTOR2(FLOAT fx, FLOAT fy)
     38 {
     39     x = fx;
     40     y = fy;
     41 }
     42 
     43 inline D3DXVECTOR2::operator FLOAT* ()
     44 {
     45     return (FLOAT*)&x;
     46 }
     47 
     48 inline D3DXVECTOR2::operator CONST FLOAT* () const
     49 {
     50     return (CONST FLOAT*)&x;
     51 }
     52 
     53 inline D3DXVECTOR2& D3DXVECTOR2::operator += (CONST D3DXVECTOR2& v)
     54 {
     55     x += v.x;
     56     y += v.y;
     57     return *this;
     58 }
     59 
     60 inline D3DXVECTOR2& D3DXVECTOR2::operator -= (CONST D3DXVECTOR2& v)
     61 {
     62     x -= v.x;
     63     y -= v.y;
     64     return *this;
     65 }
     66 
     67 inline D3DXVECTOR2& D3DXVECTOR2::operator *= (FLOAT f)
     68 {
     69     x *= f;
     70     y *= f;
     71     return *this;
     72 }
     73 
     74 inline D3DXVECTOR2& D3DXVECTOR2::operator /= (FLOAT f)
     75 {
     76     x /= f;
     77     y /= f;
     78     return *this;
     79 }
     80 
     81 inline D3DXVECTOR2 D3DXVECTOR2::operator + () const
     82 {
     83     return *this;
     84 }
     85 
     86 inline D3DXVECTOR2 D3DXVECTOR2::operator - () const
     87 {
     88     return D3DXVECTOR2(-x, -y);
     89 }
     90 
     91 inline D3DXVECTOR2 D3DXVECTOR2::operator + (CONST D3DXVECTOR2& v) const
     92 {
     93     return D3DXVECTOR2(x + v.x, y + v.y);
     94 }
     95 
     96 inline D3DXVECTOR2 D3DXVECTOR2::operator - (CONST D3DXVECTOR2& v) const
     97 {
     98     return D3DXVECTOR2(x - v.x, y - v.y);
     99 }
    100 
    101 inline D3DXVECTOR2 D3DXVECTOR2::operator * (FLOAT f) const
    102 {
    103     return D3DXVECTOR2(x * f, y * f);
    104 }
    105 
    106 inline D3DXVECTOR2 D3DXVECTOR2::operator / (FLOAT f) const
    107 {
    108     return D3DXVECTOR2(x / f, y / f);
    109 }
    110 
    111 inline D3DXVECTOR2 operator * (FLOAT f, CONST D3DXVECTOR2& v)
    112 {
    113     return D3DXVECTOR2(f * v.x, f * v.y);
    114 }
    115 
    116 inline WINBOOL D3DXVECTOR2::operator == (CONST D3DXVECTOR2& v) const
    117 {
    118     return x == v.x && y == v.y;
    119 }
    120 
    121 inline WINBOOL D3DXVECTOR2::operator != (CONST D3DXVECTOR2& v) const
    122 {
    123     return x != v.x || y != v.y;
    124 }
    125 
    126 inline D3DXVECTOR3::D3DXVECTOR3()
    127 {
    128 }
    129 
    130 inline D3DXVECTOR3::D3DXVECTOR3(CONST FLOAT *pf)
    131 {
    132     if(!pf) return;
    133     x = pf[0];
    134     y = pf[1];
    135     z = pf[2];
    136 }
    137 
    138 inline D3DXVECTOR3::D3DXVECTOR3(CONST D3DVECTOR& v)
    139 {
    140     x = v.x;
    141     y = v.y;
    142     z = v.z;
    143 }
    144 
    145 inline D3DXVECTOR3::D3DXVECTOR3(FLOAT fx, FLOAT fy, FLOAT fz)
    146 {
    147     x = fx;
    148     y = fy;
    149     z = fz;
    150 }
    151 
    152 inline D3DXVECTOR3::operator FLOAT* ()
    153 {
    154     return (FLOAT*)&x;
    155 }
    156 
    157 inline D3DXVECTOR3::operator CONST FLOAT* () const
    158 {
    159     return (CONST FLOAT*)&x;
    160 }
    161 
    162 inline D3DXVECTOR3& D3DXVECTOR3::operator += (CONST D3DXVECTOR3& v)
    163 {
    164     x += v.x;
    165     y += v.y;
    166     z += v.z;
    167     return *this;
    168 }
    169 
    170 inline D3DXVECTOR3& D3DXVECTOR3::operator -= (CONST D3DXVECTOR3& v)
    171 {
    172     x -= v.x;
    173     y -= v.y;
    174     z -= v.z;
    175     return *this;
    176 }
    177 
    178 inline D3DXVECTOR3& D3DXVECTOR3::operator *= (FLOAT f)
    179 {
    180     x *= f;
    181     y *= f;
    182     z *= f;
    183     return *this;
    184 }
    185 
    186 inline D3DXVECTOR3& D3DXVECTOR3::operator /= (FLOAT f)
    187 {
    188     x /= f;
    189     y /= f;
    190     z /= f;
    191     return *this;
    192 }
    193 
    194 inline D3DXVECTOR3 D3DXVECTOR3::operator + () const
    195 {
    196     return *this;
    197 }
    198 
    199 inline D3DXVECTOR3 D3DXVECTOR3::operator - () const
    200 {
    201     return D3DXVECTOR3(-x, -y, -z);
    202 }
    203 
    204 inline D3DXVECTOR3 D3DXVECTOR3::operator + (CONST D3DXVECTOR3& v) const
    205 {
    206     return D3DXVECTOR3(x + v.x, y + v.y, z + v.z);
    207 }
    208 
    209 inline D3DXVECTOR3 D3DXVECTOR3::operator - (CONST D3DXVECTOR3& v) const
    210 {
    211     return D3DXVECTOR3(x - v.x, y - v.y, z - v.z);
    212 }
    213 
    214 inline D3DXVECTOR3 D3DXVECTOR3::operator * (FLOAT f) const
    215 {
    216     return D3DXVECTOR3(x * f, y * f, z * f);
    217 }
    218 
    219 inline D3DXVECTOR3 D3DXVECTOR3::operator / (FLOAT f) const
    220 {
    221     return D3DXVECTOR3(x / f, y / f, z / f);
    222 }
    223 
    224 inline D3DXVECTOR3 operator * (FLOAT f, CONST D3DXVECTOR3& v)
    225 {
    226     return D3DXVECTOR3(f * v.x, f * v.y, f * v.z);
    227 }
    228 
    229 inline WINBOOL D3DXVECTOR3::operator == (CONST D3DXVECTOR3& v) const
    230 {
    231     return x == v.x && y == v.y && z == v.z;
    232 }
    233 
    234 inline WINBOOL D3DXVECTOR3::operator != (CONST D3DXVECTOR3& v) const
    235 {
    236     return x != v.x || y != v.y || z != v.z;
    237 }
    238 
    239 inline D3DXVECTOR4::D3DXVECTOR4()
    240 {
    241 }
    242 
    243 inline D3DXVECTOR4::D3DXVECTOR4(CONST FLOAT *pf)
    244 {
    245     if(!pf) return;
    246     x = pf[0];
    247     y = pf[1];
    248     z = pf[2];
    249     w = pf[3];
    250 }
    251 
    252 inline D3DXVECTOR4::D3DXVECTOR4(FLOAT fx, FLOAT fy, FLOAT fz, FLOAT fw)
    253 {
    254     x = fx;
    255     y = fy;
    256     z = fz;
    257     w = fw;
    258 }
    259 
    260 inline D3DXVECTOR4::operator FLOAT* ()
    261 {
    262     return (FLOAT*)&x;
    263 }
    264 
    265 inline D3DXVECTOR4::operator CONST FLOAT* () const
    266 {
    267     return (CONST FLOAT*)&x;
    268 }
    269 
    270 inline D3DXVECTOR4& D3DXVECTOR4::operator += (CONST D3DXVECTOR4& v)
    271 {
    272     x += v.x;
    273     y += v.y;
    274     z += v.z;
    275     w += v.w;
    276     return *this;
    277 }
    278 
    279 inline D3DXVECTOR4& D3DXVECTOR4::operator -= (CONST D3DXVECTOR4& v)
    280 {
    281     x -= v.x;
    282     y -= v.y;
    283     z -= v.z;
    284     w -= v.w;
    285     return *this;
    286 }
    287 
    288 inline D3DXVECTOR4& D3DXVECTOR4::operator *= (FLOAT f)
    289 {
    290     x *= f;
    291     y *= f;
    292     z *= f;
    293     w *= f;
    294     return *this;
    295 }
    296 
    297 inline D3DXVECTOR4& D3DXVECTOR4::operator /= (FLOAT f)
    298 {
    299     x /= f;
    300     y /= f;
    301     z /= f;
    302     w /= f;
    303     return *this;
    304 }
    305 
    306 inline D3DXVECTOR4 D3DXVECTOR4::operator + () const
    307 {
    308     return *this;
    309 }
    310 
    311 inline D3DXVECTOR4 D3DXVECTOR4::operator - () const
    312 {
    313     return D3DXVECTOR4(-x, -y, -z, -w);
    314 }
    315 
    316 inline D3DXVECTOR4 D3DXVECTOR4::operator + (CONST D3DXVECTOR4& v) const
    317 {
    318     return D3DXVECTOR4(x + v.x, y + v.y, z + v.z, w + v.w);
    319 }
    320 
    321 inline D3DXVECTOR4 D3DXVECTOR4::operator - (CONST D3DXVECTOR4& v) const
    322 {
    323     return D3DXVECTOR4(x - v.x, y - v.y, z - v.z, w - v.w);
    324 }
    325 
    326 inline D3DXVECTOR4 D3DXVECTOR4::operator * (FLOAT f) const
    327 {
    328     return D3DXVECTOR4(x * f, y * f, z * f, w * f);
    329 }
    330 
    331 inline D3DXVECTOR4 D3DXVECTOR4::operator / (FLOAT f) const
    332 {
    333     return D3DXVECTOR4(x / f, y / f, z / f, w / f);
    334 }
    335 
    336 inline D3DXVECTOR4 operator * (FLOAT f, CONST D3DXVECTOR4& v)
    337 {
    338     return D3DXVECTOR4(f * v.x, f * v.y, f * v.z, f * v.w);
    339 }
    340 
    341 inline WINBOOL D3DXVECTOR4::operator == (CONST D3DXVECTOR4& v) const
    342 {
    343     return x == v.x && y == v.y && z == v.z && w == v.w;
    344 }
    345 
    346 inline WINBOOL D3DXVECTOR4::operator != (CONST D3DXVECTOR4& v) const
    347 {
    348     return x != v.x || y != v.y || z != v.z || w != v.w;
    349 }
    350 
    351 inline D3DXMATRIX::D3DXMATRIX()
    352 {
    353 }
    354 
    355 inline D3DXMATRIX::D3DXMATRIX(CONST FLOAT *pf)
    356 {
    357     if(!pf) return;
    358     memcpy(&_11, pf, sizeof(D3DXMATRIX));
    359 }
    360 
    361 inline D3DXMATRIX::D3DXMATRIX(CONST D3DMATRIX& mat)
    362 {
    363     memcpy(&_11, &mat, sizeof(D3DXMATRIX));
    364 }
    365 
    366 inline D3DXMATRIX::D3DXMATRIX(FLOAT f11, FLOAT f12, FLOAT f13, FLOAT f14,
    367                               FLOAT f21, FLOAT f22, FLOAT f23, FLOAT f24,
    368                               FLOAT f31, FLOAT f32, FLOAT f33, FLOAT f34,
    369                               FLOAT f41, FLOAT f42, FLOAT f43, FLOAT f44)
    370 {
    371     _11 = f11; _12 = f12; _13 = f13; _14 = f14;
    372     _21 = f21; _22 = f22; _23 = f23; _24 = f24;
    373     _31 = f31; _32 = f32; _33 = f33; _34 = f34;
    374     _41 = f41; _42 = f42; _43 = f43; _44 = f44;
    375 }
    376 
    377 inline FLOAT& D3DXMATRIX::operator () (UINT row, UINT col)
    378 {
    379     return m[row][col];
    380 }
    381 
    382 inline FLOAT D3DXMATRIX::operator () (UINT row, UINT col) const
    383 {
    384     return m[row][col];
    385 }
    386 
    387 inline D3DXMATRIX::operator FLOAT* ()
    388 {
    389     return (FLOAT*)&_11;
    390 }
    391 
    392 inline D3DXMATRIX::operator CONST FLOAT* () const
    393 {
    394     return (CONST FLOAT*)&_11;
    395 }
    396 
    397 inline D3DXMATRIX& D3DXMATRIX::operator *= (CONST D3DXMATRIX& mat)
    398 {
    399     D3DXMatrixMultiply(this, this, &mat);
    400     return *this;
    401 }
    402 
    403 inline D3DXMATRIX& D3DXMATRIX::operator += (CONST D3DXMATRIX& mat)
    404 {
    405     _11 += mat._11; _12 += mat._12; _13 += mat._13; _14 += mat._14;
    406     _21 += mat._21; _22 += mat._22; _23 += mat._23; _24 += mat._24;
    407     _31 += mat._31; _32 += mat._32; _33 += mat._33; _34 += mat._34;
    408     _41 += mat._41; _42 += mat._42; _43 += mat._43; _44 += mat._44;
    409     return *this;
    410 }
    411 
    412 inline D3DXMATRIX& D3DXMATRIX::operator -= (CONST D3DXMATRIX& mat)
    413 {
    414     _11 -= mat._11; _12 -= mat._12; _13 -= mat._13; _14 -= mat._14;
    415     _21 -= mat._21; _22 -= mat._22; _23 -= mat._23; _24 -= mat._24;
    416     _31 -= mat._31; _32 -= mat._32; _33 -= mat._33; _34 -= mat._34;
    417     _41 -= mat._41; _42 -= mat._42; _43 -= mat._43; _44 -= mat._44;
    418     return *this;
    419 }
    420 
    421 inline D3DXMATRIX& D3DXMATRIX::operator *= (FLOAT f)
    422 {
    423     _11 *= f; _12 *= f; _13 *= f; _14 *= f;
    424     _21 *= f; _22 *= f; _23 *= f; _24 *= f;
    425     _31 *= f; _32 *= f; _33 *= f; _34 *= f;
    426     _41 *= f; _42 *= f; _43 *= f; _44 *= f;
    427     return *this;
    428 }
    429 
    430 inline D3DXMATRIX& D3DXMATRIX::operator /= (FLOAT f)
    431 {
    432     FLOAT inv = 1.0f / f;
    433     _11 *= inv; _12 *= inv; _13 *= inv; _14 *= inv;
    434     _21 *= inv; _22 *= inv; _23 *= inv; _24 *= inv;
    435     _31 *= inv; _32 *= inv; _33 *= inv; _34 *= inv;
    436     _41 *= inv; _42 *= inv; _43 *= inv; _44 *= inv;
    437     return *this;
    438 }
    439 
    440 inline D3DXMATRIX D3DXMATRIX::operator + () const
    441 {
    442     return *this;
    443 }
    444 
    445 inline D3DXMATRIX D3DXMATRIX::operator - () const
    446 {
    447     return D3DXMATRIX(-_11, -_12, -_13, -_14,
    448                       -_21, -_22, -_23, -_24,
    449                       -_31, -_32, -_33, -_34,
    450                       -_41, -_42, -_43, -_44);
    451 }
    452 
    453 inline D3DXMATRIX D3DXMATRIX::operator * (CONST D3DXMATRIX& mat) const
    454 {
    455     D3DXMATRIX buf;
    456     D3DXMatrixMultiply(&buf, this, &mat);
    457     return buf;
    458 }
    459 
    460 inline D3DXMATRIX D3DXMATRIX::operator + (CONST D3DXMATRIX& mat) const
    461 {
    462     return D3DXMATRIX(_11 + mat._11, _12 + mat._12, _13 + mat._13, _14 + mat._14,
    463                       _21 + mat._21, _22 + mat._22, _23 + mat._23, _24 + mat._24,
    464                       _31 + mat._31, _32 + mat._32, _33 + mat._33, _34 + mat._34,
    465                       _41 + mat._41, _42 + mat._42, _43 + mat._43, _44 + mat._44);
    466 }
    467 
    468 inline D3DXMATRIX D3DXMATRIX::operator - (CONST D3DXMATRIX& mat) const
    469 {
    470     return D3DXMATRIX(_11 - mat._11, _12 - mat._12, _13 - mat._13, _14 - mat._14,
    471                       _21 - mat._21, _22 - mat._22, _23 - mat._23, _24 - mat._24,
    472                       _31 - mat._31, _32 - mat._32, _33 - mat._33, _34 - mat._34,
    473                       _41 - mat._41, _42 - mat._42, _43 - mat._43, _44 - mat._44);
    474 }
    475 
    476 inline D3DXMATRIX D3DXMATRIX::operator * (FLOAT f) const
    477 {
    478     return D3DXMATRIX(_11 * f, _12 * f, _13 * f, _14 * f,
    479                       _21 * f, _22 * f, _23 * f, _24 * f,
    480                       _31 * f, _32 * f, _33 * f, _34 * f,
    481                       _41 * f, _42 * f, _43 * f, _44 * f);
    482 }
    483 
    484 inline D3DXMATRIX D3DXMATRIX::operator / (FLOAT f) const
    485 {
    486     FLOAT inv = 1.0f / f;
    487     return D3DXMATRIX(_11 * inv, _12 * inv, _13 * inv, _14 * inv,
    488                       _21 * inv, _22 * inv, _23 * inv, _24 * inv,
    489                       _31 * inv, _32 * inv, _33 * inv, _34 * inv,
    490                       _41 * inv, _42 * inv, _43 * inv, _44 * inv);
    491 }
    492 
    493 inline D3DXMATRIX operator * (FLOAT f, CONST D3DXMATRIX& mat)
    494 {
    495     return D3DXMATRIX(f * mat._11, f * mat._12, f * mat._13, f * mat._14,
    496                       f * mat._21, f * mat._22, f * mat._23, f * mat._24,
    497                       f * mat._31, f * mat._32, f * mat._33, f * mat._34,
    498                       f * mat._41, f * mat._42, f * mat._43, f * mat._44);
    499 }
    500 
    501 inline WINBOOL D3DXMATRIX::operator == (CONST D3DXMATRIX& mat) const
    502 {
    503     return (memcmp(this, &mat, sizeof(D3DXMATRIX)) == 0);
    504 }
    505 
    506 inline WINBOOL D3DXMATRIX::operator != (CONST D3DXMATRIX& mat) const
    507 {
    508     return (memcmp(this, &mat, sizeof(D3DXMATRIX)) != 0);
    509 }
    510 
    511 inline D3DXQUATERNION::D3DXQUATERNION()
    512 {
    513 }
    514 
    515 inline D3DXQUATERNION::D3DXQUATERNION(CONST FLOAT *pf)
    516 {
    517     if(!pf) return;
    518     x = pf[0];
    519     y = pf[1];
    520     z = pf[2];
    521     w = pf[3];
    522 }
    523 
    524 inline D3DXQUATERNION::D3DXQUATERNION(FLOAT fx, FLOAT fy, FLOAT fz, FLOAT fw)
    525 {
    526     x = fx;
    527     y = fy;
    528     z = fz;
    529     w = fw;
    530 }
    531 
    532 inline D3DXQUATERNION::operator FLOAT* ()
    533 {
    534     return (FLOAT*)&x;
    535 }
    536 
    537 inline D3DXQUATERNION::operator CONST FLOAT* () const
    538 {
    539     return (CONST FLOAT*)&x;
    540 }
    541 
    542 inline D3DXQUATERNION& D3DXQUATERNION::operator += (CONST D3DXQUATERNION& quat)
    543 {
    544     x += quat.x;
    545     y += quat.y;
    546     z += quat.z;
    547     w += quat.w;
    548     return *this;
    549 }
    550 
    551 inline D3DXQUATERNION& D3DXQUATERNION::operator -= (CONST D3DXQUATERNION& quat)
    552 {
    553     x -= quat.x;
    554     y -= quat.y;
    555     z -= quat.z;
    556     w -= quat.w;
    557     return *this;
    558 }
    559 
    560 inline D3DXQUATERNION& D3DXQUATERNION::operator *= (CONST D3DXQUATERNION& quat)
    561 {
    562     D3DXQuaternionMultiply(this, this, &quat);
    563     return *this;
    564 }
    565 
    566 inline D3DXQUATERNION& D3DXQUATERNION::operator *= (FLOAT f)
    567 {
    568     x *= f;
    569     y *= f;
    570     z *= f;
    571     w *= f;
    572     return *this;
    573 }
    574 
    575 inline D3DXQUATERNION& D3DXQUATERNION::operator /= (FLOAT f)
    576 {
    577     FLOAT inv = 1.0f / f;
    578     x *= inv;
    579     y *= inv;
    580     z *= inv;
    581     w *= inv;
    582     return *this;
    583 }
    584 
    585 inline D3DXQUATERNION D3DXQUATERNION::operator + () const
    586 {
    587     return *this;
    588 }
    589 
    590 inline D3DXQUATERNION D3DXQUATERNION::operator - () const
    591 {
    592     return D3DXQUATERNION(-x, -y, -z, -w);
    593 }
    594 
    595 inline D3DXQUATERNION D3DXQUATERNION::operator + (CONST D3DXQUATERNION& quat) const
    596 {
    597     return D3DXQUATERNION(x + quat.x, y + quat.y, z + quat.z, w + quat.w);
    598 }
    599 
    600 inline D3DXQUATERNION D3DXQUATERNION::operator - (CONST D3DXQUATERNION& quat) const
    601 {
    602     return D3DXQUATERNION(x - quat.x, y - quat.y, z - quat.z, w - quat.w);
    603 }
    604 
    605 inline D3DXQUATERNION D3DXQUATERNION::operator * (CONST D3DXQUATERNION& quat) const
    606 {
    607     D3DXQUATERNION buf;
    608     D3DXQuaternionMultiply(&buf, this, &quat);
    609     return buf;
    610 }
    611 
    612 inline D3DXQUATERNION D3DXQUATERNION::operator * (FLOAT f) const
    613 {
    614     return D3DXQUATERNION(x * f, y * f, z * f, w * f);
    615 }
    616 
    617 inline D3DXQUATERNION D3DXQUATERNION::operator / (FLOAT f) const
    618 {
    619     FLOAT inv = 1.0f / f;
    620     return D3DXQUATERNION(x * inv, y * inv, z * inv, w * inv);
    621 }
    622 
    623 inline D3DXQUATERNION operator * (FLOAT f, CONST D3DXQUATERNION& quat)
    624 {
    625     return D3DXQUATERNION(f * quat.x, f * quat.y, f * quat.z, f * quat.w);
    626 }
    627 
    628 inline WINBOOL D3DXQUATERNION::operator == (CONST D3DXQUATERNION& quat) const
    629 {
    630     return x == quat.x && y == quat.y && z == quat.z && w == quat.w;
    631 }
    632 
    633 inline WINBOOL D3DXQUATERNION::operator != (CONST D3DXQUATERNION& quat) const
    634 {
    635     return x != quat.x || y != quat.y || z != quat.z || w != quat.w;
    636 }
    637 
    638 inline D3DXPLANE::D3DXPLANE()
    639 {
    640 }
    641 
    642 inline D3DXPLANE::D3DXPLANE(CONST FLOAT *pf)
    643 {
    644     if(!pf) return;
    645     a = pf[0];
    646     b = pf[1];
    647     c = pf[2];
    648     d = pf[3];
    649 }
    650 
    651 inline D3DXPLANE::D3DXPLANE(FLOAT fa, FLOAT fb, FLOAT fc, FLOAT fd)
    652 {
    653     a = fa;
    654     b = fb;
    655     c = fc;
    656     d = fd;
    657 }
    658 
    659 inline D3DXPLANE::operator FLOAT* ()
    660 {
    661     return (FLOAT*)&a;
    662 }
    663 
    664 inline D3DXPLANE::operator CONST FLOAT* () const
    665 {
    666     return (CONST FLOAT*)&a;
    667 }
    668 
    669 inline D3DXPLANE D3DXPLANE::operator + () const
    670 {
    671     return *this;
    672 }
    673 
    674 inline D3DXPLANE D3DXPLANE::operator - () const
    675 {
    676     return D3DXPLANE(-a, -b, -c, -d);
    677 }
    678 
    679 inline WINBOOL D3DXPLANE::operator == (CONST D3DXPLANE& pl) const
    680 {
    681     return a == pl.a && b == pl.b && c == pl.c && d == pl.d;
    682 }
    683 
    684 inline WINBOOL D3DXPLANE::operator != (CONST D3DXPLANE& pl) const
    685 {
    686     return a != pl.a || b != pl.b || c != pl.c || d != pl.d;
    687 }
    688 
    689 inline D3DXCOLOR::D3DXCOLOR()
    690 {
    691 }
    692 
    693 inline D3DXCOLOR::D3DXCOLOR(DWORD col)
    694 {
    695     CONST FLOAT f = 1.0f / 255.0f;
    696     r = f * (FLOAT)(unsigned char)(col >> 16);
    697     g = f * (FLOAT)(unsigned char)(col >>  8);
    698     b = f * (FLOAT)(unsigned char)col;
    699     a = f * (FLOAT)(unsigned char)(col >> 24);
    700 }
    701 
    702 inline D3DXCOLOR::D3DXCOLOR(CONST FLOAT *pf)
    703 {
    704     if(!pf) return;
    705     r = pf[0];
    706     g = pf[1];
    707     b = pf[2];
    708     a = pf[3];
    709 }
    710 
    711 inline D3DXCOLOR::D3DXCOLOR(CONST D3DCOLORVALUE& col)
    712 {
    713     r = col.r;
    714     g = col.g;
    715     b = col.b;
    716     a = col.a;
    717 }
    718 
    719 inline D3DXCOLOR::D3DXCOLOR(FLOAT fr, FLOAT fg, FLOAT fb, FLOAT fa)
    720 {
    721     r = fr;
    722     g = fg;
    723     b = fb;
    724     a = fa;
    725 }
    726 
    727 inline D3DXCOLOR::operator DWORD () const
    728 {
    729     DWORD _r = r >= 1.0f ? 0xff : r <= 0.0f ? 0x00 : (DWORD)(r * 255.0f + 0.5f);
    730     DWORD _g = g >= 1.0f ? 0xff : g <= 0.0f ? 0x00 : (DWORD)(g * 255.0f + 0.5f);
    731     DWORD _b = b >= 1.0f ? 0xff : b <= 0.0f ? 0x00 : (DWORD)(b * 255.0f + 0.5f);
    732     DWORD _a = a >= 1.0f ? 0xff : a <= 0.0f ? 0x00 : (DWORD)(a * 255.0f + 0.5f);
    733 
    734     return (_a << 24) | (_r << 16) | (_g << 8) | _b;
    735 }
    736 
    737 inline D3DXCOLOR::operator FLOAT * ()
    738 {
    739     return (FLOAT*)&r;
    740 }
    741 
    742 inline D3DXCOLOR::operator CONST FLOAT * () const
    743 {
    744     return (CONST FLOAT*)&r;
    745 }
    746 
    747 inline D3DXCOLOR::operator D3DCOLORVALUE * ()
    748 {
    749     return (D3DCOLORVALUE*)&r;
    750 }
    751 
    752 inline D3DXCOLOR::operator CONST D3DCOLORVALUE * () const
    753 {
    754     return (CONST D3DCOLORVALUE*)&r;
    755 }
    756 
    757 inline D3DXCOLOR::operator D3DCOLORVALUE& ()
    758 {
    759     return *((D3DCOLORVALUE*)&r);
    760 }
    761 
    762 inline D3DXCOLOR::operator CONST D3DCOLORVALUE& () const
    763 {
    764     return *((CONST D3DCOLORVALUE*)&r);
    765 }
    766 
    767 inline D3DXCOLOR& D3DXCOLOR::operator += (CONST D3DXCOLOR& col)
    768 {
    769     r += col.r;
    770     g += col.g;
    771     b += col.b;
    772     a += col.a;
    773     return *this;
    774 }
    775 
    776 inline D3DXCOLOR& D3DXCOLOR::operator -= (CONST D3DXCOLOR& col)
    777 {
    778     r -= col.r;
    779     g -= col.g;
    780     b -= col.b;
    781     a -= col.a;
    782     return *this;
    783 }
    784 
    785 inline D3DXCOLOR& D3DXCOLOR::operator *= (FLOAT f)
    786 {
    787     r *= f;
    788     g *= f;
    789     b *= f;
    790     a *= f;
    791     return *this;
    792 }
    793 
    794 inline D3DXCOLOR& D3DXCOLOR::operator /= (FLOAT f)
    795 {
    796     FLOAT inv = 1.0f / f;
    797     r *= inv;
    798     g *= inv;
    799     b *= inv;
    800     a *= inv;
    801     return *this;
    802 }
    803 
    804 inline D3DXCOLOR D3DXCOLOR::operator + () const
    805 {
    806     return *this;
    807 }
    808 
    809 inline D3DXCOLOR D3DXCOLOR::operator - () const
    810 {
    811     return D3DXCOLOR(-r, -g, -b, -a);
    812 }
    813 
    814 inline D3DXCOLOR D3DXCOLOR::operator + (CONST D3DXCOLOR& col) const
    815 {
    816     return D3DXCOLOR(r + col.r, g + col.g, b + col.b, a + col.a);
    817 }
    818 
    819 inline D3DXCOLOR D3DXCOLOR::operator - (CONST D3DXCOLOR& col) const
    820 {
    821     return D3DXCOLOR(r - col.r, g - col.g, b - col.b, a - col.a);
    822 }
    823 
    824 inline D3DXCOLOR D3DXCOLOR::operator * (FLOAT f) const
    825 {
    826     return D3DXCOLOR(r * f, g * f, b * f, a * f);
    827 }
    828 
    829 inline D3DXCOLOR D3DXCOLOR::operator / (FLOAT f) const
    830 {
    831     FLOAT inv = 1.0f / f;
    832     return D3DXCOLOR(r * inv, g * inv, b * inv, a * inv);
    833 }
    834 
    835 inline D3DXCOLOR operator * (FLOAT f, CONST D3DXCOLOR& col)
    836 {
    837     return D3DXCOLOR(f * col.r, f * col.g, f * col.b, f * col.a);
    838 }
    839 
    840 inline WINBOOL D3DXCOLOR::operator == (CONST D3DXCOLOR& col) const
    841 {
    842     return r == col.r && g == col.g && b == col.b && a == col.a;
    843 }
    844 
    845 inline WINBOOL D3DXCOLOR::operator != (CONST D3DXCOLOR& col) const
    846 {
    847     return r != col.r || g != col.g || b != col.b || a != col.a;
    848 }
    849 
    850 inline D3DXFLOAT16::D3DXFLOAT16()
    851 {
    852 }
    853 
    854 inline D3DXFLOAT16::D3DXFLOAT16(FLOAT f)
    855 {
    856     D3DXFloat32To16Array(this, &f, 1);
    857 }
    858 
    859 inline D3DXFLOAT16::D3DXFLOAT16(CONST D3DXFLOAT16 &f)
    860 {
    861     value = f.value;
    862 }
    863 
    864 inline D3DXFLOAT16::operator FLOAT ()
    865 {
    866     FLOAT f;
    867     D3DXFloat16To32Array(&f, this, 1);
    868     return f;
    869 }
    870 
    871 inline WINBOOL D3DXFLOAT16::operator == (CONST D3DXFLOAT16 &f) const
    872 {
    873     return value == f.value;
    874 }
    875 
    876 inline WINBOOL D3DXFLOAT16::operator != (CONST D3DXFLOAT16 &f) const
    877 {
    878     return value != f.value;
    879 }
    880 
    881 #endif /* __cplusplus */
    882 
    883 /*_______________D3DXCOLOR_____________________*/
    884 
    885 static inline D3DXCOLOR* D3DXColorAdd(D3DXCOLOR *pout, CONST D3DXCOLOR *pc1, CONST D3DXCOLOR *pc2)
    886 {
    887     if ( !pout || !pc1 || !pc2 ) return NULL;
    888     pout->r = (pc1->r) + (pc2->r);
    889     pout->g = (pc1->g) + (pc2->g);
    890     pout->b = (pc1->b) + (pc2->b);
    891     pout->a = (pc1->a) + (pc2->a);
    892     return pout;
    893 }
    894 
    895 static inline D3DXCOLOR* D3DXColorLerp(D3DXCOLOR *pout, CONST D3DXCOLOR *pc1, CONST D3DXCOLOR *pc2, FLOAT s)
    896 {
    897     if ( !pout || !pc1 || !pc2 ) return NULL;
    898     pout->r = (1-s) * (pc1->r) + s *(pc2->r);
    899     pout->g = (1-s) * (pc1->g) + s *(pc2->g);
    900     pout->b = (1-s) * (pc1->b) + s *(pc2->b);
    901     pout->a = (1-s) * (pc1->a) + s *(pc2->a);
    902     return pout;
    903 }
    904 
    905 static inline D3DXCOLOR* D3DXColorModulate(D3DXCOLOR *pout, CONST D3DXCOLOR *pc1, CONST D3DXCOLOR *pc2)
    906 {
    907     if ( !pout || !pc1 || !pc2 ) return NULL;
    908     pout->r = (pc1->r) * (pc2->r);
    909     pout->g = (pc1->g) * (pc2->g);
    910     pout->b = (pc1->b) * (pc2->b);
    911     pout->a = (pc1->a) * (pc2->a);
    912     return pout;
    913 }
    914 
    915 static inline D3DXCOLOR* D3DXColorNegative(D3DXCOLOR *pout, CONST D3DXCOLOR *pc)
    916 {
    917     if ( !pout || !pc ) return NULL;
    918     pout->r = 1.0f - pc->r;
    919     pout->g = 1.0f - pc->g;
    920     pout->b = 1.0f - pc->b;
    921     pout->a = pc->a;
    922     return pout;
    923 }
    924 
    925 static inline D3DXCOLOR* D3DXColorScale(D3DXCOLOR *pout, CONST D3DXCOLOR *pc, FLOAT s)
    926 {
    927     if ( !pout || !pc ) return NULL;
    928     pout->r = s* (pc->r);
    929     pout->g = s* (pc->g);
    930     pout->b = s* (pc->b);
    931     pout->a = s* (pc->a);
    932     return pout;
    933 }
    934 
    935 static inline D3DXCOLOR* D3DXColorSubtract(D3DXCOLOR *pout, CONST D3DXCOLOR *pc1, CONST D3DXCOLOR *pc2)
    936 {
    937     if ( !pout || !pc1 || !pc2 ) return NULL;
    938     pout->r = (pc1->r) - (pc2->r);
    939     pout->g = (pc1->g) - (pc2->g);
    940     pout->b = (pc1->b) - (pc2->b);
    941     pout->a = (pc1->a) - (pc2->a);
    942     return pout;
    943 }
    944 
    945 /*_______________D3DXVECTOR2________________________*/
    946 
    947 static inline D3DXVECTOR2* D3DXVec2Add(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2)
    948 {
    949     if ( !pout || !pv1 || !pv2) return NULL;
    950     pout->x = pv1->x + pv2->x;
    951     pout->y = pv1->y + pv2->y;
    952     return pout;
    953 }
    954 
    955 static inline FLOAT D3DXVec2CCW(CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2)
    956 {
    957     if ( !pv1 || !pv2) return 0.0f;
    958     return ( (pv1->x) * (pv2->y) - (pv1->y) * (pv2->x) );
    959 }
    960 
    961 static inline FLOAT D3DXVec2Dot(CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2)
    962 {
    963     if ( !pv1 || !pv2) return 0.0f;
    964     return ( (pv1->x * pv2->x + pv1->y * pv2->y) );
    965 }
    966 
    967 static inline FLOAT D3DXVec2Length(CONST D3DXVECTOR2 *pv)
    968 {
    969     if (!pv) return 0.0f;
    970     return sqrtf( pv->x * pv->x + pv->y * pv->y );
    971 }
    972 
    973 static inline FLOAT D3DXVec2LengthSq(CONST D3DXVECTOR2 *pv)
    974 {
    975     if (!pv) return 0.0f;
    976     return( (pv->x) * (pv->x) + (pv->y) * (pv->y) );
    977 }
    978 
    979 static inline D3DXVECTOR2* D3DXVec2Lerp(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2, FLOAT s)
    980 {
    981     if ( !pout || !pv1 || !pv2) return NULL;
    982     pout->x = (1-s) * (pv1->x) + s * (pv2->x);
    983     pout->y = (1-s) * (pv1->y) + s * (pv2->y);
    984     return pout;
    985 }
    986 
    987 static inline D3DXVECTOR2* D3DXVec2Maximize(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2)
    988 {
    989     if ( !pout || !pv1 || !pv2) return NULL;
    990     pout->x = pv1->x > pv2->x ? pv1->x : pv2->x;
    991     pout->y = pv1->y > pv2->y ? pv1->y : pv2->y;
    992     return pout;
    993 }
    994 
    995 static inline D3DXVECTOR2* D3DXVec2Minimize(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2)
    996 {
    997     if ( !pout || !pv1 || !pv2) return NULL;
    998     pout->x = pv1->x < pv2->x ? pv1->x : pv2->x;
    999     pout->y = pv1->y < pv2->y ? pv1->y : pv2->y;
   1000     return pout;
   1001 }
   1002 
   1003 static inline D3DXVECTOR2* D3DXVec2Scale(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv, FLOAT s)
   1004 {
   1005     if ( !pout || !pv) return NULL;
   1006     pout->x = s * (pv->x);
   1007     pout->y = s * (pv->y);
   1008     return pout;
   1009 }
   1010 
   1011 static inline D3DXVECTOR2* D3DXVec2Subtract(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2)
   1012 {
   1013     if ( !pout || !pv1 || !pv2) return NULL;
   1014     pout->x = pv1->x - pv2->x;
   1015     pout->y = pv1->y - pv2->y;
   1016     return pout;
   1017 }
   1018 
   1019 /*__________________D3DXVECTOR3_______________________*/
   1020 
   1021 static inline D3DXVECTOR3* D3DXVec3Add(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
   1022 {
   1023     if ( !pout || !pv1 || !pv2) return NULL;
   1024     pout->x = pv1->x + pv2->x;
   1025     pout->y = pv1->y + pv2->y;
   1026     pout->z = pv1->z + pv2->z;
   1027     return pout;
   1028 }
   1029 
   1030 static inline D3DXVECTOR3* D3DXVec3Cross(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
   1031 {
   1032     if ( !pout || !pv1 || !pv2) return NULL;
   1033     pout->x = (pv1->y) * (pv2->z) - (pv1->z) * (pv2->y);
   1034     pout->y = (pv1->z) * (pv2->x) - (pv1->x) * (pv2->z);
   1035     pout->z = (pv1->x) * (pv2->y) - (pv1->y) * (pv2->x);
   1036     return pout;
   1037 }
   1038 
   1039 static inline FLOAT D3DXVec3Dot(CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
   1040 {
   1041     if ( !pv1 || !pv2 ) return 0.0f;
   1042     return (pv1->x) * (pv2->x) + (pv1->y) * (pv2->y) + (pv1->z) * (pv2->z);
   1043 }
   1044 
   1045 static inline FLOAT D3DXVec3Length(CONST D3DXVECTOR3 *pv)
   1046 {
   1047     if (!pv) return 0.0f;
   1048     return sqrtf( pv->x * pv->x + pv->y * pv->y + pv->z * pv->z );
   1049 }
   1050 
   1051 static inline FLOAT D3DXVec3LengthSq(CONST D3DXVECTOR3 *pv)
   1052 {
   1053     if (!pv) return 0.0f;
   1054     return (pv->x) * (pv->x) + (pv->y) * (pv->y) + (pv->z) * (pv->z);
   1055 }
   1056 
   1057 static inline D3DXVECTOR3* D3DXVec3Lerp(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, FLOAT s)
   1058 {
   1059     if ( !pout || !pv1 || !pv2) return NULL;
   1060     pout->x = (1-s) * (pv1->x) + s * (pv2->x);
   1061     pout->y = (1-s) * (pv1->y) + s * (pv2->y);
   1062     pout->z = (1-s) * (pv1->z) + s * (pv2->z);
   1063     return pout;
   1064 }
   1065 
   1066 static inline D3DXVECTOR3* D3DXVec3Maximize(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
   1067 {
   1068     if ( !pout || !pv1 || !pv2) return NULL;
   1069     pout->x = pv1->x > pv2->x ? pv1->x : pv2->x;
   1070     pout->y = pv1->y > pv2->y ? pv1->y : pv2->y;
   1071     pout->z = pv1->z > pv2->z ? pv1->z : pv2->z;
   1072     return pout;
   1073 }
   1074 
   1075 static inline D3DXVECTOR3* D3DXVec3Minimize(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
   1076 {
   1077     if ( !pout || !pv1 || !pv2) return NULL;
   1078     pout->x = pv1->x < pv2->x ? pv1->x : pv2->x;
   1079     pout->y = pv1->y < pv2->y ? pv1->y : pv2->y;
   1080     pout->z = pv1->z < pv2->z ? pv1->z : pv2->z;
   1081     return pout;
   1082 }
   1083 
   1084 static inline D3DXVECTOR3* D3DXVec3Scale(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, FLOAT s)
   1085 {
   1086     if ( !pout || !pv) return NULL;
   1087     pout->x = s * (pv->x);
   1088     pout->y = s * (pv->y);
   1089     pout->z = s * (pv->z);
   1090     return pout;
   1091 }
   1092 
   1093 static inline D3DXVECTOR3* D3DXVec3Subtract(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
   1094 {
   1095     if ( !pout || !pv1 || !pv2) return NULL;
   1096     pout->x = pv1->x - pv2->x;
   1097     pout->y = pv1->y - pv2->y;
   1098     pout->z = pv1->z - pv2->z;
   1099     return pout;
   1100 }
   1101 /*__________________D3DXVECTOR4_______________________*/
   1102 
   1103 static inline D3DXVECTOR4* D3DXVec4Add(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2)
   1104 {
   1105     if ( !pout || !pv1 || !pv2) return NULL;
   1106     pout->x = pv1->x + pv2->x;
   1107     pout->y = pv1->y + pv2->y;
   1108     pout->z = pv1->z + pv2->z;
   1109     pout->w = pv1->w + pv2->w;
   1110     return pout;
   1111 }
   1112 
   1113 static inline FLOAT D3DXVec4Dot(CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2)
   1114 {
   1115     if (!pv1 || !pv2 ) return 0.0f;
   1116     return (pv1->x) * (pv2->x) + (pv1->y) * (pv2->y) + (pv1->z) * (pv2->z) + (pv1->w) * (pv2->w);
   1117 }
   1118 
   1119 static inline FLOAT D3DXVec4Length(CONST D3DXVECTOR4 *pv)
   1120 {
   1121     if (!pv) return 0.0f;
   1122     return sqrtf( pv->x * pv->x + pv->y * pv->y + pv->z * pv->z + pv->w * pv->w );
   1123 }
   1124 
   1125 static inline FLOAT D3DXVec4LengthSq(CONST D3DXVECTOR4 *pv)
   1126 {
   1127     if (!pv) return 0.0f;
   1128     return (pv->x) * (pv->x) + (pv->y) * (pv->y) + (pv->z) * (pv->z) + (pv->w) * (pv->w);
   1129 }
   1130 
   1131 static inline D3DXVECTOR4* D3DXVec4Lerp(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, FLOAT s)
   1132 {
   1133     if ( !pout || !pv1 || !pv2) return NULL;
   1134     pout->x = (1-s) * (pv1->x) + s * (pv2->x);
   1135     pout->y = (1-s) * (pv1->y) + s * (pv2->y);
   1136     pout->z = (1-s) * (pv1->z) + s * (pv2->z);
   1137     pout->w = (1-s) * (pv1->w) + s * (pv2->w);
   1138     return pout;
   1139 }
   1140 
   1141 
   1142 static inline D3DXVECTOR4* D3DXVec4Maximize(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2)
   1143 {
   1144     if ( !pout || !pv1 || !pv2) return NULL;
   1145     pout->x = pv1->x > pv2->x ? pv1->x : pv2->x;
   1146     pout->y = pv1->y > pv2->y ? pv1->y : pv2->y;
   1147     pout->z = pv1->z > pv2->z ? pv1->z : pv2->z;
   1148     pout->w = pv1->w > pv2->w ? pv1->w : pv2->w;
   1149     return pout;
   1150 }
   1151 
   1152 static inline D3DXVECTOR4* D3DXVec4Minimize(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2)
   1153 {
   1154     if ( !pout || !pv1 || !pv2) return NULL;
   1155     pout->x = pv1->x < pv2->x ? pv1->x : pv2->x;
   1156     pout->y = pv1->y < pv2->y ? pv1->y : pv2->y;
   1157     pout->z = pv1->z < pv2->z ? pv1->z : pv2->z;
   1158     pout->w = pv1->w < pv2->w ? pv1->w : pv2->w;
   1159     return pout;
   1160 }
   1161 
   1162 static inline D3DXVECTOR4* D3DXVec4Scale(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv, FLOAT s)
   1163 {
   1164     if ( !pout || !pv) return NULL;
   1165     pout->x = s * (pv->x);
   1166     pout->y = s * (pv->y);
   1167     pout->z = s * (pv->z);
   1168     pout->w = s * (pv->w);
   1169     return pout;
   1170 }
   1171 
   1172 static inline D3DXVECTOR4* D3DXVec4Subtract(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2)
   1173 {
   1174     if ( !pout || !pv1 || !pv2) return NULL;
   1175     pout->x = pv1->x - pv2->x;
   1176     pout->y = pv1->y - pv2->y;
   1177     pout->z = pv1->z - pv2->z;
   1178     pout->w = pv1->w - pv2->w;
   1179     return pout;
   1180 }
   1181 
   1182 /*__________________D3DXMatrix____________________*/
   1183 #ifdef NONAMELESSUNION
   1184 # define D3DX_U(x)  (x).u
   1185 #else
   1186 # define D3DX_U(x)  (x)
   1187 #endif
   1188 
   1189 static inline D3DXMATRIX* D3DXMatrixIdentity(D3DXMATRIX *pout)
   1190 {
   1191     if ( !pout ) return NULL;
   1192     D3DX_U(*pout).m[0][1] = 0.0f;
   1193     D3DX_U(*pout).m[0][2] = 0.0f;
   1194     D3DX_U(*pout).m[0][3] = 0.0f;
   1195     D3DX_U(*pout).m[1][0] = 0.0f;
   1196     D3DX_U(*pout).m[1][2] = 0.0f;
   1197     D3DX_U(*pout).m[1][3] = 0.0f;
   1198     D3DX_U(*pout).m[2][0] = 0.0f;
   1199     D3DX_U(*pout).m[2][1] = 0.0f;
   1200     D3DX_U(*pout).m[2][3] = 0.0f;
   1201     D3DX_U(*pout).m[3][0] = 0.0f;
   1202     D3DX_U(*pout).m[3][1] = 0.0f;
   1203     D3DX_U(*pout).m[3][2] = 0.0f;
   1204     D3DX_U(*pout).m[0][0] = 1.0f;
   1205     D3DX_U(*pout).m[1][1] = 1.0f;
   1206     D3DX_U(*pout).m[2][2] = 1.0f;
   1207     D3DX_U(*pout).m[3][3] = 1.0f;
   1208     return pout;
   1209 }
   1210 
   1211 static inline WINBOOL D3DXMatrixIsIdentity(D3DXMATRIX *pm)
   1212 {
   1213     int i,j;
   1214     D3DXMATRIX testmatrix;
   1215 
   1216     if ( !pm ) return FALSE;
   1217     D3DXMatrixIdentity(&testmatrix);
   1218     for (i=0; i<4; i++)
   1219     {
   1220      for (j=0; j<4; j++)
   1221      {
   1222       if ( D3DX_U(*pm).m[i][j] != D3DX_U(testmatrix).m[i][j] ) return FALSE;
   1223      }
   1224     }
   1225     return TRUE;
   1226 }
   1227 #undef D3DX_U
   1228 
   1229 /*__________________D3DXPLANE____________________*/
   1230 
   1231 static inline FLOAT D3DXPlaneDot(CONST D3DXPLANE *pp, CONST D3DXVECTOR4 *pv)
   1232 {
   1233     if ( !pp || !pv ) return 0.0f;
   1234     return ( (pp->a) * (pv->x) + (pp->b) * (pv->y) + (pp->c) * (pv->z) + (pp->d) * (pv->w) );
   1235 }
   1236 
   1237 static inline FLOAT D3DXPlaneDotCoord(CONST D3DXPLANE *pp, CONST D3DXVECTOR4 *pv)
   1238 {
   1239     if ( !pp || !pv ) return 0.0f;
   1240     return ( (pp->a) * (pv->x) + (pp->b) * (pv->y) + (pp->c) * (pv->z) + (pp->d) );
   1241 }
   1242 
   1243 static inline FLOAT D3DXPlaneDotNormal(CONST D3DXPLANE *pp, CONST D3DXVECTOR4 *pv)
   1244 {
   1245     if ( !pp || !pv ) return 0.0f;
   1246     return ( (pp->a) * (pv->x) + (pp->b) * (pv->y) + (pp->c) * (pv->z) );
   1247 }
   1248 
   1249 /*__________________D3DXQUATERNION____________________*/
   1250 
   1251 static inline D3DXQUATERNION* D3DXQuaternionConjugate(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq)
   1252 {
   1253     if ( !pout || !pq) return NULL;
   1254     pout->x = -pq->x;
   1255     pout->y = -pq->y;
   1256     pout->z = -pq->z;
   1257     pout->w = pq->w;
   1258     return pout;
   1259 }
   1260 
   1261 static inline FLOAT D3DXQuaternionDot(CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2)
   1262 {
   1263     if ( !pq1 || !pq2 ) return 0.0f;
   1264     return (pq1->x) * (pq2->x) + (pq1->y) * (pq2->y) + (pq1->z) * (pq2->z) + (pq1->w) * (pq2->w);
   1265 }
   1266 
   1267 static inline D3DXQUATERNION* D3DXQuaternionIdentity(D3DXQUATERNION *pout)
   1268 {
   1269     if ( !pout) return NULL;
   1270     pout->x = 0.0f;
   1271     pout->y = 0.0f;
   1272     pout->z = 0.0f;
   1273     pout->w = 1.0f;
   1274     return pout;
   1275 }
   1276 
   1277 static inline WINBOOL D3DXQuaternionIsIdentity(D3DXQUATERNION *pq)
   1278 {
   1279     if ( !pq) return FALSE;
   1280     return ( (pq->x == 0.0f) && (pq->y == 0.0f) && (pq->z == 0.0f) && (pq->w == 1.0f) );
   1281 }
   1282 
   1283 static inline FLOAT D3DXQuaternionLength(CONST D3DXQUATERNION *pq)
   1284 {
   1285     if (!pq) return 0.0f;
   1286     return sqrtf( pq->x * pq->x + pq->y * pq->y + pq->z * pq->z + pq->w * pq->w );
   1287 }
   1288 
   1289 static inline FLOAT D3DXQuaternionLengthSq(CONST D3DXQUATERNION *pq)
   1290 {
   1291     if (!pq) return 0.0f;
   1292     return (pq->x) * (pq->x) + (pq->y) * (pq->y) + (pq->z) * (pq->z) + (pq->w) * (pq->w);
   1293 }
   1294 
   1295 #endif
   1296