reactos/include/dxsdk/d3dx9math.inl

   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 BOOL D3DXVECTOR2::operator == (CONST D3DXVECTOR2& v) const
 117 {
 118     return x == v.x && y == v.y;
 119 }
 120
 121 inline BOOL 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 BOOL D3DXVECTOR3::operator == (CONST D3DXVECTOR3& v) const
 230 {
 231     return x == v.x && y == v.y && z == v.z;
 232 }
 233
 234 inline BOOL 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 BOOL 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 BOOL 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 BOOL D3DXMATRIX::operator == (CONST D3DXMATRIX& mat) const
 502 {
 503     return (memcmp(this, &mat, sizeof(D3DXMATRIX)) == 0);
 504 }
 505
 506 inline BOOL 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 BOOL 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 BOOL 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 BOOL 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 BOOL 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 BOOL 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 BOOL 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 BOOL D3DXFLOAT16::operator == (CONST D3DXFLOAT16 &f) const
 872 {
 873     return value == f.value;
 874 }
 875
 876 inline BOOL 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     D3DXVECTOR3 temp;
1033
1034     if ( !pout || !pv1 || !pv2) return NULL;
1035     temp.x = (pv1->y) * (pv2->z) - (pv1->z) * (pv2->y);
1036     temp.y = (pv1->z) * (pv2->x) - (pv1->x) * (pv2->z);
1037     temp.z = (pv1->x) * (pv2->y) - (pv1->y) * (pv2->x);
1038     *pout = temp;
1039     return pout;
1040 }
1041
1042 static inline FLOAT D3DXVec3Dot(CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
1043 {
1044     if ( !pv1 || !pv2 ) return 0.0f;
1045     return (pv1->x) * (pv2->x) + (pv1->y) * (pv2->y) + (pv1->z) * (pv2->z);
1046 }
1047
1048 static inline FLOAT D3DXVec3Length(CONST D3DXVECTOR3 *pv)
1049 {
1050     if (!pv) return 0.0f;
1051     return sqrtf( pv->x * pv->x + pv->y * pv->y + pv->z * pv->z );
1052 }
1053
1054 static inline FLOAT D3DXVec3LengthSq(CONST D3DXVECTOR3 *pv)
1055 {
1056     if (!pv) return 0.0f;
1057     return (pv->x) * (pv->x) + (pv->y) * (pv->y) + (pv->z) * (pv->z);
1058 }
1059
1060 static inline D3DXVECTOR3* D3DXVec3Lerp(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, FLOAT s)
1061 {
1062     if ( !pout || !pv1 || !pv2) return NULL;
1063     pout->x = (1-s) * (pv1->x) + s * (pv2->x);
1064     pout->y = (1-s) * (pv1->y) + s * (pv2->y);
1065     pout->z = (1-s) * (pv1->z) + s * (pv2->z);
1066     return pout;
1067 }
1068
1069 static inline D3DXVECTOR3* D3DXVec3Maximize(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
1070 {
1071     if ( !pout || !pv1 || !pv2) return NULL;
1072     pout->x = pv1->x > pv2->x ? pv1->x : pv2->x;
1073     pout->y = pv1->y > pv2->y ? pv1->y : pv2->y;
1074     pout->z = pv1->z > pv2->z ? pv1->z : pv2->z;
1075     return pout;
1076 }
1077
1078 static inline D3DXVECTOR3* D3DXVec3Minimize(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
1079 {
1080     if ( !pout || !pv1 || !pv2) return NULL;
1081     pout->x = pv1->x < pv2->x ? pv1->x : pv2->x;
1082     pout->y = pv1->y < pv2->y ? pv1->y : pv2->y;
1083     pout->z = pv1->z < pv2->z ? pv1->z : pv2->z;
1084     return pout;
1085 }
1086
1087 static inline D3DXVECTOR3* D3DXVec3Scale(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, FLOAT s)
1088 {
1089     if ( !pout || !pv) return NULL;
1090     pout->x = s * (pv->x);
1091     pout->y = s * (pv->y);
1092     pout->z = s * (pv->z);
1093     return pout;
1094 }
1095
1096 static inline D3DXVECTOR3* D3DXVec3Subtract(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
1097 {
1098     if ( !pout || !pv1 || !pv2) return NULL;
1099     pout->x = pv1->x - pv2->x;
1100     pout->y = pv1->y - pv2->y;
1101     pout->z = pv1->z - pv2->z;
1102     return pout;
1103 }
1104 /*__________________D3DXVECTOR4_______________________*/
1105
1106 static inline D3DXVECTOR4* D3DXVec4Add(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2)
1107 {
1108     if ( !pout || !pv1 || !pv2) return NULL;
1109     pout->x = pv1->x + pv2->x;
1110     pout->y = pv1->y + pv2->y;
1111     pout->z = pv1->z + pv2->z;
1112     pout->w = pv1->w + pv2->w;
1113     return pout;
1114 }
1115
1116 static inline FLOAT D3DXVec4Dot(CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2)
1117 {
1118     if (!pv1 || !pv2 ) return 0.0f;
1119     return (pv1->x) * (pv2->x) + (pv1->y) * (pv2->y) + (pv1->z) * (pv2->z) + (pv1->w) * (pv2->w);
1120 }
1121
1122 static inline FLOAT D3DXVec4Length(CONST D3DXVECTOR4 *pv)
1123 {
1124     if (!pv) return 0.0f;
1125     return sqrtf( pv->x * pv->x + pv->y * pv->y + pv->z * pv->z + pv->w * pv->w );
1126 }
1127
1128 static inline FLOAT D3DXVec4LengthSq(CONST D3DXVECTOR4 *pv)
1129 {
1130     if (!pv) return 0.0f;
1131     return (pv->x) * (pv->x) + (pv->y) * (pv->y) + (pv->z) * (pv->z) + (pv->w) * (pv->w);
1132 }
1133
1134 static inline D3DXVECTOR4* D3DXVec4Lerp(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, FLOAT s)
1135 {
1136     if ( !pout || !pv1 || !pv2) return NULL;
1137     pout->x = (1-s) * (pv1->x) + s * (pv2->x);
1138     pout->y = (1-s) * (pv1->y) + s * (pv2->y);
1139     pout->z = (1-s) * (pv1->z) + s * (pv2->z);
1140     pout->w = (1-s) * (pv1->w) + s * (pv2->w);
1141     return pout;
1142 }
1143
1144
1145 static inline D3DXVECTOR4* D3DXVec4Maximize(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2)
1146 {
1147     if ( !pout || !pv1 || !pv2) return NULL;
1148     pout->x = pv1->x > pv2->x ? pv1->x : pv2->x;
1149     pout->y = pv1->y > pv2->y ? pv1->y : pv2->y;
1150     pout->z = pv1->z > pv2->z ? pv1->z : pv2->z;
1151     pout->w = pv1->w > pv2->w ? pv1->w : pv2->w;
1152     return pout;
1153 }
1154
1155 static inline D3DXVECTOR4* D3DXVec4Minimize(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2)
1156 {
1157     if ( !pout || !pv1 || !pv2) return NULL;
1158     pout->x = pv1->x < pv2->x ? pv1->x : pv2->x;
1159     pout->y = pv1->y < pv2->y ? pv1->y : pv2->y;
1160     pout->z = pv1->z < pv2->z ? pv1->z : pv2->z;
1161     pout->w = pv1->w < pv2->w ? pv1->w : pv2->w;
1162     return pout;
1163 }
1164
1165 static inline D3DXVECTOR4* D3DXVec4Scale(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv, FLOAT s)
1166 {
1167     if ( !pout || !pv) return NULL;
1168     pout->x = s * (pv->x);
1169     pout->y = s * (pv->y);
1170     pout->z = s * (pv->z);
1171     pout->w = s * (pv->w);
1172     return pout;
1173 }
1174
1175 static inline D3DXVECTOR4* D3DXVec4Subtract(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2)
1176 {
1177     if ( !pout || !pv1 || !pv2) return NULL;
1178     pout->x = pv1->x - pv2->x;
1179     pout->y = pv1->y - pv2->y;
1180     pout->z = pv1->z - pv2->z;
1181     pout->w = pv1->w - pv2->w;
1182     return pout;
1183 }
1184
1185 /*__________________D3DXMatrix____________________*/
1186 #ifdef NONAMELESSUNION
1187 # define D3DX_U(x)  (x).u
1188 #else
1189 # define D3DX_U(x)  (x)
1190 #endif
1191
1192 static inline D3DXMATRIX* D3DXMatrixIdentity(D3DXMATRIX *pout)
1193 {
1194     if ( !pout ) return NULL;
1195     D3DX_U(*pout).m[0][1] = 0.0f;
1196     D3DX_U(*pout).m[0][2] = 0.0f;
1197     D3DX_U(*pout).m[0][3] = 0.0f;
1198     D3DX_U(*pout).m[1][0] = 0.0f;
1199     D3DX_U(*pout).m[1][2] = 0.0f;
1200     D3DX_U(*pout).m[1][3] = 0.0f;
1201     D3DX_U(*pout).m[2][0] = 0.0f;
1202     D3DX_U(*pout).m[2][1] = 0.0f;
1203     D3DX_U(*pout).m[2][3] = 0.0f;
1204     D3DX_U(*pout).m[3][0] = 0.0f;
1205     D3DX_U(*pout).m[3][1] = 0.0f;
1206     D3DX_U(*pout).m[3][2] = 0.0f;
1207     D3DX_U(*pout).m[0][0] = 1.0f;
1208     D3DX_U(*pout).m[1][1] = 1.0f;
1209     D3DX_U(*pout).m[2][2] = 1.0f;
1210     D3DX_U(*pout).m[3][3] = 1.0f;
1211     return pout;
1212 }
1213
1214 static inline BOOL D3DXMatrixIsIdentity(D3DXMATRIX *pm)
1215 {
1216     int i,j;
1217     D3DXMATRIX testmatrix;
1218
1219     if ( !pm ) return FALSE;
1220     D3DXMatrixIdentity(&testmatrix);
1221     for (i=0; i<4; i++)
1222     {
1223      for (j=0; j<4; j++)
1224      {
1225       if ( D3DX_U(*pm).m[i][j] != D3DX_U(testmatrix).m[i][j] ) return FALSE;
1226      }
1227     }
1228     return TRUE;
1229 }
1230 #undef D3DX_U
1231
1232 /*__________________D3DXPLANE____________________*/
1233
1234 static inline FLOAT D3DXPlaneDot(CONST D3DXPLANE *pp, CONST D3DXVECTOR4 *pv)
1235 {
1236     if ( !pp || !pv ) return 0.0f;
1237     return ( (pp->a) * (pv->x) + (pp->b) * (pv->y) + (pp->c) * (pv->z) + (pp->d) * (pv->w) );
1238 }
1239
1240 static inline FLOAT D3DXPlaneDotCoord(CONST D3DXPLANE *pp, CONST D3DXVECTOR4 *pv)
1241 {
1242     if ( !pp || !pv ) return 0.0f;
1243     return ( (pp->a) * (pv->x) + (pp->b) * (pv->y) + (pp->c) * (pv->z) + (pp->d) );
1244 }
1245
1246 static inline FLOAT D3DXPlaneDotNormal(CONST D3DXPLANE *pp, CONST D3DXVECTOR4 *pv)
1247 {
1248     if ( !pp || !pv ) return 0.0f;
1249     return ( (pp->a) * (pv->x) + (pp->b) * (pv->y) + (pp->c) * (pv->z) );
1250 }
1251
1252 /*__________________D3DXQUATERNION____________________*/
1253
1254 static inline D3DXQUATERNION* D3DXQuaternionConjugate(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq)
1255 {
1256     if ( !pout || !pq) return NULL;
1257     pout->x = -pq->x;
1258     pout->y = -pq->y;
1259     pout->z = -pq->z;
1260     pout->w = pq->w;
1261     return pout;
1262 }
1263
1264 static inline FLOAT D3DXQuaternionDot(CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2)
1265 {
1266     if ( !pq1 || !pq2 ) return 0.0f;
1267     return (pq1->x) * (pq2->x) + (pq1->y) * (pq2->y) + (pq1->z) * (pq2->z) + (pq1->w) * (pq2->w);
1268 }
1269
1270 static inline D3DXQUATERNION* D3DXQuaternionIdentity(D3DXQUATERNION *pout)
1271 {
1272     if ( !pout) return NULL;
1273     pout->x = 0.0f;
1274     pout->y = 0.0f;
1275     pout->z = 0.0f;
1276     pout->w = 1.0f;
1277     return pout;
1278 }
1279
1280 static inline BOOL D3DXQuaternionIsIdentity(D3DXQUATERNION *pq)
1281 {
1282     if ( !pq) return FALSE;
1283     return ( (pq->x == 0.0f) && (pq->y == 0.0f) && (pq->z == 0.0f) && (pq->w == 1.0f) );
1284 }
1285
1286 static inline FLOAT D3DXQuaternionLength(CONST D3DXQUATERNION *pq)
1287 {
1288     if (!pq) return 0.0f;
1289     return sqrtf( pq->x * pq->x + pq->y * pq->y + pq->z * pq->z + pq->w * pq->w );
1290 }
1291
1292 static inline FLOAT D3DXQuaternionLengthSq(CONST D3DXQUATERNION *pq)
1293 {
1294     if (!pq) return 0.0f;
1295     return (pq->x) * (pq->x) + (pq->y) * (pq->y) + (pq->z) * (pq->z) + (pq->w) * (pq->w);
1296 }
1297
1298 #endif