include/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 /* TODO: uncomment this when D3DXQuaternionMultiply has been implemented
 561 inline D3DXQUATERNION& D3DXQUATERNION::operator *= (CONST D3DXQUATERNION& quat)
 562 {
 563     D3DXQuaternionMultiply(this, this, &quat);
 564     return *this;
 565 }
 566 */
 567
 568 inline D3DXQUATERNION& D3DXQUATERNION::operator *= (FLOAT f)
 569 {
 570     x *= f;
 571     y *= f;
 572     z *= f;
 573     w *= f;
 574     return *this;
 575 }
 576
 577 inline D3DXQUATERNION& D3DXQUATERNION::operator /= (FLOAT f)
 578 {
 579     FLOAT inv = 1.0f / f;
 580     x *= inv;
 581     y *= inv;
 582     z *= inv;
 583     w *= inv;
 584     return *this;
 585 }
 586
 587 inline D3DXQUATERNION D3DXQUATERNION::operator + () const
 588 {
 589     return *this;
 590 }
 591
 592 inline D3DXQUATERNION D3DXQUATERNION::operator - () const
 593 {
 594     return D3DXQUATERNION(-x, -y, -z, -w);
 595 }
 596
 597 inline D3DXQUATERNION D3DXQUATERNION::operator + (CONST D3DXQUATERNION& quat) const
 598 {
 599     return D3DXQUATERNION(x + quat.x, y + quat.y, z + quat.z, w + quat.w);
 600 }
 601
 602 inline D3DXQUATERNION D3DXQUATERNION::operator - (CONST D3DXQUATERNION& quat) const
 603 {
 604     return D3DXQUATERNION(x - quat.x, y - quat.y, z - quat.z, w - quat.w);
 605 }
 606
 607 /* TODO: uncomment this when D3DXQuaternionMultiply has been implemented
 608 inline D3DXQUATERNION D3DXQUATERNION::operator * (CONST D3DXQUATERNION& quat) const
 609 {
 610     D3DXQUATERNION buf;
 611     D3DXQuaternionMultiply(&buf, this, &quat);
 612     return buf;
 613 }
 614 */
 615
 616 inline D3DXQUATERNION D3DXQUATERNION::operator * (FLOAT f) const
 617 {
 618     return D3DXQUATERNION(x * f, y * f, z * f, w * f);
 619 }
 620
 621 inline D3DXQUATERNION D3DXQUATERNION::operator / (FLOAT f) const
 622 {
 623     FLOAT inv = 1.0f / f;
 624     return D3DXQUATERNION(x * inv, y * inv, z * inv, w * inv);
 625 }
 626
 627 inline D3DXQUATERNION operator * (FLOAT f, CONST D3DXQUATERNION& quat)
 628 {
 629     return D3DXQUATERNION(f * quat.x, f * quat.y, f * quat.z, f * quat.w);
 630 }
 631
 632 inline BOOL D3DXQUATERNION::operator == (CONST D3DXQUATERNION& quat) const
 633 {
 634     return x == quat.x && y == quat.y && z == quat.z && w == quat.w;
 635 }
 636
 637 inline BOOL D3DXQUATERNION::operator != (CONST D3DXQUATERNION& quat) const
 638 {
 639     return x != quat.x || y != quat.y || z != quat.z || w != quat.w;
 640 }
 641
 642 inline D3DXPLANE::D3DXPLANE()
 643 {
 644 }
 645
 646 inline D3DXPLANE::D3DXPLANE(CONST FLOAT *pf)
 647 {
 648     if(!pf) return;
 649     a = pf[0];
 650     b = pf[1];
 651     c = pf[2];
 652     d = pf[3];
 653 }
 654
 655 inline D3DXPLANE::D3DXPLANE(FLOAT fa, FLOAT fb, FLOAT fc, FLOAT fd)
 656 {
 657     a = fa;
 658     b = fb;
 659     c = fc;
 660     d = fd;
 661 }
 662
 663 inline D3DXPLANE::operator FLOAT* ()
 664 {
 665     return (FLOAT*)&a;
 666 }
 667
 668 inline D3DXPLANE::operator CONST FLOAT* () const
 669 {
 670     return (CONST FLOAT*)&a;
 671 }
 672
 673 inline D3DXPLANE D3DXPLANE::operator + () const
 674 {
 675     return *this;
 676 }
 677
 678 inline D3DXPLANE D3DXPLANE::operator - () const
 679 {
 680     return D3DXPLANE(-a, -b, -c, -d);
 681 }
 682
 683 inline BOOL D3DXPLANE::operator == (CONST D3DXPLANE& pl) const
 684 {
 685     return a == pl.a && b == pl.b && c == pl.c && d == pl.d;
 686 }
 687
 688 inline BOOL D3DXPLANE::operator != (CONST D3DXPLANE& pl) const
 689 {
 690     return a != pl.a || b != pl.b || c != pl.c || d != pl.d;
 691 }
 692
 693 inline D3DXCOLOR::D3DXCOLOR()
 694 {
 695 }
 696
 697 inline D3DXCOLOR::D3DXCOLOR(DWORD col)
 698 {
 699     CONST FLOAT f = 1.0f / 255.0f;
 700     r = f * (FLOAT)(unsigned char)(col >> 16);
 701     g = f * (FLOAT)(unsigned char)(col >>  8);
 702     b = f * (FLOAT)(unsigned char)col;
 703     a = f * (FLOAT)(unsigned char)(col >> 24);
 704 }
 705
 706 inline D3DXCOLOR::D3DXCOLOR(CONST FLOAT *pf)
 707 {
 708     if(!pf) return;
 709     r = pf[0];
 710     g = pf[1];
 711     b = pf[2];
 712     a = pf[3];
 713 }
 714
 715 inline D3DXCOLOR::D3DXCOLOR(CONST D3DCOLORVALUE& col)
 716 {
 717     r = col.r;
 718     g = col.g;
 719     b = col.b;
 720     a = col.a;
 721 }
 722
 723 inline D3DXCOLOR::D3DXCOLOR(FLOAT fr, FLOAT fg, FLOAT fb, FLOAT fa)
 724 {
 725     r = fr;
 726     g = fg;
 727     b = fb;
 728     a = fa;
 729 }
 730
 731 inline D3DXCOLOR::operator DWORD () const
 732 {
 733     DWORD _r = r >= 1.0f ? 0xff : r <= 0.0f ? 0x00 : (DWORD)(r * 255.0f + 0.5f);
 734     DWORD _g = g >= 1.0f ? 0xff : g <= 0.0f ? 0x00 : (DWORD)(g * 255.0f + 0.5f);
 735     DWORD _b = b >= 1.0f ? 0xff : b <= 0.0f ? 0x00 : (DWORD)(b * 255.0f + 0.5f);
 736     DWORD _a = a >= 1.0f ? 0xff : a <= 0.0f ? 0x00 : (DWORD)(a * 255.0f + 0.5f);
 737
 738     return (_a << 24) | (_r << 16) | (_g << 8) | _b;
 739 }
 740
 741 inline D3DXCOLOR::operator FLOAT * ()
 742 {
 743     return (FLOAT*)&r;
 744 }
 745
 746 inline D3DXCOLOR::operator CONST FLOAT * () const
 747 {
 748     return (CONST FLOAT*)&r;
 749 }
 750
 751 inline D3DXCOLOR::operator D3DCOLORVALUE * ()
 752 {
 753     return (D3DCOLORVALUE*)&r;
 754 }
 755
 756 inline D3DXCOLOR::operator CONST D3DCOLORVALUE * () const
 757 {
 758     return (CONST D3DCOLORVALUE*)&r;
 759 }
 760
 761 inline D3DXCOLOR::operator D3DCOLORVALUE& ()
 762 {
 763     return *((D3DCOLORVALUE*)&r);
 764 }
 765
 766 inline D3DXCOLOR::operator CONST D3DCOLORVALUE& () const
 767 {
 768     return *((CONST D3DCOLORVALUE*)&r);
 769 }
 770
 771 inline D3DXCOLOR& D3DXCOLOR::operator += (CONST D3DXCOLOR& col)
 772 {
 773     r += col.r;
 774     g += col.g;
 775     b += col.b;
 776     a += col.a;
 777     return *this;
 778 }
 779
 780 inline D3DXCOLOR& D3DXCOLOR::operator -= (CONST D3DXCOLOR& col)
 781 {
 782     r -= col.r;
 783     g -= col.g;
 784     b -= col.b;
 785     a -= col.a;
 786     return *this;
 787 }
 788
 789 inline D3DXCOLOR& D3DXCOLOR::operator *= (FLOAT f)
 790 {
 791     r *= f;
 792     g *= f;
 793     b *= f;
 794     a *= f;
 795     return *this;
 796 }
 797
 798 inline D3DXCOLOR& D3DXCOLOR::operator /= (FLOAT f)
 799 {
 800     FLOAT inv = 1.0f / f;
 801     r *= inv;
 802     g *= inv;
 803     b *= inv;
 804     a *= inv;
 805     return *this;
 806 }
 807
 808 inline D3DXCOLOR D3DXCOLOR::operator + () const
 809 {
 810     return *this;
 811 }
 812
 813 inline D3DXCOLOR D3DXCOLOR::operator - () const
 814 {
 815     return D3DXCOLOR(-r, -g, -b, -a);
 816 }
 817
 818 inline D3DXCOLOR D3DXCOLOR::operator + (CONST D3DXCOLOR& col) const
 819 {
 820     return D3DXCOLOR(r + col.r, g + col.g, b + col.b, a + col.a);
 821 }
 822
 823 inline D3DXCOLOR D3DXCOLOR::operator - (CONST D3DXCOLOR& col) const
 824 {
 825     return D3DXCOLOR(r - col.r, g - col.g, b - col.b, a - col.a);
 826 }
 827
 828 inline D3DXCOLOR D3DXCOLOR::operator * (FLOAT f) const
 829 {
 830     return D3DXCOLOR(r * f, g * f, b * f, a * f);
 831 }
 832
 833 inline D3DXCOLOR D3DXCOLOR::operator / (FLOAT f) const
 834 {
 835     FLOAT inv = 1.0f / f;
 836     return D3DXCOLOR(r * inv, g * inv, b * inv, a * inv);
 837 }
 838
 839 inline D3DXCOLOR operator * (FLOAT f, CONST D3DXCOLOR& col)
 840 {
 841     return D3DXCOLOR(f * col.r, f * col.g, f * col.b, f * col.a);
 842 }
 843
 844 inline BOOL D3DXCOLOR::operator == (CONST D3DXCOLOR& col) const
 845 {
 846     return r == col.r && g == col.g && b == col.b && a == col.a;
 847 }
 848
 849 inline BOOL D3DXCOLOR::operator != (CONST D3DXCOLOR& col) const
 850 {
 851     return r != col.r || g != col.g || b != col.b || a != col.a;
 852 }
 853
 854 inline D3DXFLOAT16::D3DXFLOAT16()
 855 {
 856 }
 857
 858 inline D3DXFLOAT16::D3DXFLOAT16(FLOAT f)
 859 {
 860     D3DXFloat32To16Array(this, &f, 1);
 861 }
 862
 863 inline D3DXFLOAT16::D3DXFLOAT16(CONST D3DXFLOAT16 &f)
 864 {
 865     value = f.value;
 866 }
 867
 868 inline D3DXFLOAT16::operator FLOAT ()
 869 {
 870     FLOAT f;
 871     D3DXFloat16To32Array(&f, this, 1);
 872     return f;
 873 }
 874
 875 inline BOOL D3DXFLOAT16::operator == (CONST D3DXFLOAT16 &f) const
 876 {
 877     return value == f.value;
 878 }
 879
 880 inline BOOL D3DXFLOAT16::operator != (CONST D3DXFLOAT16 &f) const
 881 {
 882     return value != f.value;
 883 }
 884
 885 #endif /* __cplusplus */
 886
 887 /*_______________D3DXCOLOR_____________________*/
 888
 889 static inline D3DXCOLOR* D3DXColorAdd(D3DXCOLOR *pout, CONST D3DXCOLOR *pc1, CONST D3DXCOLOR *pc2)
 890 {
 891     if ( !pout || !pc1 || !pc2 ) return NULL;
 892     pout->r = (pc1->r) + (pc2->r);
 893     pout->g = (pc1->g) + (pc2->g);
 894     pout->b = (pc1->b) + (pc2->b);
 895     pout->a = (pc1->a) + (pc2->a);
 896     return pout;
 897 }
 898
 899 static inline D3DXCOLOR* D3DXColorLerp(D3DXCOLOR *pout, CONST D3DXCOLOR *pc1, CONST D3DXCOLOR *pc2, FLOAT s)
 900 {
 901     if ( !pout || !pc1 || !pc2 ) return NULL;
 902     pout->r = (1-s) * (pc1->r) + s *(pc2->r);
 903     pout->g = (1-s) * (pc1->g) + s *(pc2->g);
 904     pout->b = (1-s) * (pc1->b) + s *(pc2->b);
 905     pout->a = (1-s) * (pc1->a) + s *(pc2->a);
 906     return pout;
 907 }
 908
 909 static inline D3DXCOLOR* D3DXColorModulate(D3DXCOLOR *pout, CONST D3DXCOLOR *pc1, CONST D3DXCOLOR *pc2)
 910 {
 911     if ( !pout || !pc1 || !pc2 ) return NULL;
 912     pout->r = (pc1->r) * (pc2->r);
 913     pout->g = (pc1->g) * (pc2->g);
 914     pout->b = (pc1->b) * (pc2->b);
 915     pout->a = (pc1->a) * (pc2->a);
 916     return pout;
 917 }
 918
 919 static inline D3DXCOLOR* D3DXColorNegative(D3DXCOLOR *pout, CONST D3DXCOLOR *pc)
 920 {
 921     if ( !pout || !pc ) return NULL;
 922     pout->r = 1.0f - pc->r;
 923     pout->g = 1.0f - pc->g;
 924     pout->b = 1.0f - pc->b;
 925     pout->a = pc->a;
 926     return pout;
 927 }
 928
 929 static inline D3DXCOLOR* D3DXColorScale(D3DXCOLOR *pout, CONST D3DXCOLOR *pc, FLOAT s)
 930 {
 931     if ( !pout || !pc ) return NULL;
 932     pout->r = s* (pc->r);
 933     pout->g = s* (pc->g);
 934     pout->b = s* (pc->b);
 935     pout->a = s* (pc->a);
 936     return pout;
 937 }
 938
 939 static inline D3DXCOLOR* D3DXColorSubtract(D3DXCOLOR *pout, CONST D3DXCOLOR *pc1, CONST D3DXCOLOR *pc2)
 940 {
 941     if ( !pout || !pc1 || !pc2 ) return NULL;
 942     pout->r = (pc1->r) - (pc2->r);
 943     pout->g = (pc1->g) - (pc2->g);
 944     pout->b = (pc1->b) - (pc2->b);
 945     pout->a = (pc1->a) - (pc2->a);
 946     return pout;
 947 }
 948
 949 /*_______________D3DXVECTOR2________________________*/
 950
 951 static inline D3DXVECTOR2* D3DXVec2Add(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2)
 952 {
 953     if ( !pout || !pv1 || !pv2) return NULL;
 954     pout->x = pv1->x + pv2->x;
 955     pout->y = pv1->y + pv2->y;
 956     return pout;
 957 }
 958
 959 static inline FLOAT D3DXVec2CCW(CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2)
 960 {
 961     if ( !pv1 || !pv2) return 0.0f;
 962     return ( (pv1->x) * (pv2->y) - (pv1->y) * (pv2->x) );
 963 }
 964
 965 static inline FLOAT D3DXVec2Dot(CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2)
 966 {
 967     if ( !pv1 || !pv2) return 0.0f;
 968     return ( (pv1->x * pv2->x + pv1->y * pv2->y) );
 969 }
 970
 971 static inline FLOAT D3DXVec2Length(CONST D3DXVECTOR2 *pv)
 972 {
 973     if (!pv) return 0.0f;
 974     return sqrt( (pv->x) * (pv->x) + (pv->y) * (pv->y) );
 975 }
 976
 977 static inline FLOAT D3DXVec2LengthSq(CONST D3DXVECTOR2 *pv)
 978 {
 979     if (!pv) return 0.0f;
 980     return( (pv->x) * (pv->x) + (pv->y) * (pv->y) );
 981 }
 982
 983 static inline D3DXVECTOR2* D3DXVec2Lerp(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2, FLOAT s)
 984 {
 985     if ( !pout || !pv1 || !pv2) return NULL;
 986     pout->x = (1-s) * (pv1->x) + s * (pv2->x);
 987     pout->y = (1-s) * (pv1->y) + s * (pv2->y);
 988     return pout;
 989 }
 990
 991 static inline D3DXVECTOR2* D3DXVec2Maximize(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2)
 992 {
 993     if ( !pout || !pv1 || !pv2) return NULL;
 994     pout->x = pv1->x > pv2->x ? pv1->x : pv2->x;
 995     pout->y = pv1->y > pv2->y ? pv1->y : pv2->y;
 996     return pout;
 997 }
 998
 999 static inline D3DXVECTOR2* D3DXVec2Minimize(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2)
1000 {
1001     if ( !pout || !pv1 || !pv2) return NULL;
1002     pout->x = pv1->x < pv2->x ? pv1->x : pv2->x;
1003     pout->y = pv1->y < pv2->y ? pv1->y : pv2->y;
1004     return pout;
1005 }
1006
1007 static inline D3DXVECTOR2* D3DXVec2Scale(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv, FLOAT s)
1008 {
1009     if ( !pout || !pv) return NULL;
1010     pout->x = s * (pv->x);
1011     pout->y = s * (pv->y);
1012     return pout;
1013 }
1014
1015 static inline D3DXVECTOR2* D3DXVec2Subtract(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2)
1016 {
1017     if ( !pout || !pv1 || !pv2) return NULL;
1018     pout->x = pv1->x - pv2->x;
1019     pout->y = pv1->y - pv2->y;
1020     return pout;
1021 }
1022
1023 /*__________________D3DXVECTOR3_______________________*/
1024
1025 static inline D3DXVECTOR3* D3DXVec3Add(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
1026 {
1027     if ( !pout || !pv1 || !pv2) return NULL;
1028     pout->x = pv1->x + pv2->x;
1029     pout->y = pv1->y + pv2->y;
1030     pout->z = pv1->z + pv2->z;
1031     return pout;
1032 }
1033
1034 static inline D3DXVECTOR3* D3DXVec3Cross(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
1035 {
1036     if ( !pout || !pv1 || !pv2) return NULL;
1037     pout->x = (pv1->y) * (pv2->z) - (pv1->z) * (pv2->y);
1038     pout->y = (pv1->z) * (pv2->x) - (pv1->x) * (pv2->z);
1039     pout->z = (pv1->x) * (pv2->y) - (pv1->y) * (pv2->x);
1040     return pout;
1041 }
1042
1043 static inline FLOAT D3DXVec3Dot(CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
1044 {
1045     if ( !pv1 || !pv2 ) return 0.0f;
1046     return (pv1->x) * (pv2->x) + (pv1->y) * (pv2->y) + (pv1->z) * (pv2->z);
1047 }
1048
1049 static inline FLOAT D3DXVec3Length(CONST D3DXVECTOR3 *pv)
1050 {
1051     if (!pv) return 0.0f;
1052     return sqrt( (pv->x) * (pv->x) + (pv->y) * (pv->y) + (pv->z) * (pv->z) );
1053 }
1054
1055 static inline FLOAT D3DXVec3LengthSq(CONST D3DXVECTOR3 *pv)
1056 {
1057     if (!pv) return 0.0f;
1058     return (pv->x) * (pv->x) + (pv->y) * (pv->y) + (pv->z) * (pv->z);
1059 }
1060
1061 static inline D3DXVECTOR3* D3DXVec3Lerp(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, FLOAT s)
1062 {
1063     if ( !pout || !pv1 || !pv2) return NULL;
1064     pout->x = (1-s) * (pv1->x) + s * (pv2->x);
1065     pout->y = (1-s) * (pv1->y) + s * (pv2->y);
1066     pout->z = (1-s) * (pv1->z) + s * (pv2->z);
1067     return pout;
1068 }
1069
1070 static inline D3DXVECTOR3* D3DXVec3Maximize(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
1071 {
1072     if ( !pout || !pv1 || !pv2) return NULL;
1073     pout->x = pv1->x > pv2->x ? pv1->x : pv2->x;
1074     pout->y = pv1->y > pv2->y ? pv1->y : pv2->y;
1075     pout->z = pv1->z > pv2->z ? pv1->z : pv2->z;
1076     return pout;
1077 }
1078
1079 static inline D3DXVECTOR3* D3DXVec3Minimize(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
1080 {
1081     if ( !pout || !pv1 || !pv2) return NULL;
1082     pout->x = pv1->x < pv2->x ? pv1->x : pv2->x;
1083     pout->y = pv1->y < pv2->y ? pv1->y : pv2->y;
1084     pout->z = pv1->z < pv2->z ? pv1->z : pv2->z;
1085     return pout;
1086 }
1087
1088 static inline D3DXVECTOR3* D3DXVec3Scale(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, FLOAT s)
1089 {
1090     if ( !pout || !pv) return NULL;
1091     pout->x = s * (pv->x);
1092     pout->y = s * (pv->y);
1093     pout->z = s * (pv->z);
1094     return pout;
1095 }
1096
1097 static inline D3DXVECTOR3* D3DXVec3Subtract(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
1098 {
1099     if ( !pout || !pv1 || !pv2) return NULL;
1100     pout->x = pv1->x - pv2->x;
1101     pout->y = pv1->y - pv2->y;
1102     pout->z = pv1->z - pv2->z;
1103     return pout;
1104 }
1105 /*__________________D3DXVECTOR4_______________________*/
1106
1107 static inline D3DXVECTOR4* D3DXVec4Add(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2)
1108 {
1109     if ( !pout || !pv1 || !pv2) return NULL;
1110     pout->x = pv1->x + pv2->x;
1111     pout->y = pv1->y + pv2->y;
1112     pout->z = pv1->z + pv2->z;
1113     pout->w = pv1->w + pv2->w;
1114     return pout;
1115 }
1116
1117 static inline FLOAT D3DXVec4Dot(CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2)
1118 {
1119     if (!pv1 || !pv2 ) return 0.0f;
1120     return (pv1->x) * (pv2->x) + (pv1->y) * (pv2->y) + (pv1->z) * (pv2->z) + (pv1->w) * (pv2->w);
1121 }
1122
1123 static inline FLOAT D3DXVec4Length(CONST D3DXVECTOR4 *pv)
1124 {
1125     if (!pv) return 0.0f;
1126     return sqrt( (pv->x) * (pv->x) + (pv->y) * (pv->y) + (pv->z) * (pv->z) + (pv->w) * (pv->w) );
1127 }
1128
1129 static inline FLOAT D3DXVec4LengthSq(CONST D3DXVECTOR4 *pv)
1130 {
1131     if (!pv) return 0.0f;
1132     return (pv->x) * (pv->x) + (pv->y) * (pv->y) + (pv->z) * (pv->z) + (pv->w) * (pv->w);
1133 }
1134
1135 static inline D3DXVECTOR4* D3DXVec4Lerp(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, FLOAT s)
1136 {
1137     if ( !pout || !pv1 || !pv2) return NULL;
1138     pout->x = (1-s) * (pv1->x) + s * (pv2->x);
1139     pout->y = (1-s) * (pv1->y) + s * (pv2->y);
1140     pout->z = (1-s) * (pv1->z) + s * (pv2->z);
1141     pout->w = (1-s) * (pv1->w) + s * (pv2->w);
1142     return pout;
1143 }
1144
1145
1146 static inline D3DXVECTOR4* D3DXVec4Maximize(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2)
1147 {
1148     if ( !pout || !pv1 || !pv2) return NULL;
1149     pout->x = pv1->x > pv2->x ? pv1->x : pv2->x;
1150     pout->y = pv1->y > pv2->y ? pv1->y : pv2->y;
1151     pout->z = pv1->z > pv2->z ? pv1->z : pv2->z;
1152     pout->w = pv1->w > pv2->w ? pv1->w : pv2->w;
1153     return pout;
1154 }
1155
1156 static inline D3DXVECTOR4* D3DXVec4Minimize(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2)
1157 {
1158     if ( !pout || !pv1 || !pv2) return NULL;
1159     pout->x = pv1->x < pv2->x ? pv1->x : pv2->x;
1160     pout->y = pv1->y < pv2->y ? pv1->y : pv2->y;
1161     pout->z = pv1->z < pv2->z ? pv1->z : pv2->z;
1162     pout->w = pv1->w < pv2->w ? pv1->w : pv2->w;
1163     return pout;
1164 }
1165
1166 static inline D3DXVECTOR4* D3DXVec4Scale(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv, FLOAT s)
1167 {
1168     if ( !pout || !pv) return NULL;
1169     pout->x = s * (pv->x);
1170     pout->y = s * (pv->y);
1171     pout->z = s * (pv->z);
1172     pout->w = s * (pv->w);
1173     return pout;
1174 }
1175
1176 static inline D3DXVECTOR4* D3DXVec4Subtract(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2)
1177 {
1178     if ( !pout || !pv1 || !pv2) return NULL;
1179     pout->x = pv1->x - pv2->x;
1180     pout->y = pv1->y - pv2->y;
1181     pout->z = pv1->z - pv2->z;
1182     pout->w = pv1->w - pv2->w;
1183     return pout;
1184 }
1185
1186 /*__________________D3DXMatrix____________________*/
1187 #ifdef NONAMELESSUNION
1188 # define D3DX_U(x)  (x).u
1189 #else
1190 # define D3DX_U(x)  (x)
1191 #endif
1192
1193 static inline D3DXMATRIX* D3DXMatrixIdentity(D3DXMATRIX *pout)
1194 {
1195     if ( !pout ) return NULL;
1196     D3DX_U(*pout).m[0][1] = 0.0f;
1197     D3DX_U(*pout).m[0][2] = 0.0f;
1198     D3DX_U(*pout).m[0][3] = 0.0f;
1199     D3DX_U(*pout).m[1][0] = 0.0f;
1200     D3DX_U(*pout).m[1][2] = 0.0f;
1201     D3DX_U(*pout).m[1][3] = 0.0f;
1202     D3DX_U(*pout).m[2][0] = 0.0f;
1203     D3DX_U(*pout).m[2][1] = 0.0f;
1204     D3DX_U(*pout).m[2][3] = 0.0f;
1205     D3DX_U(*pout).m[3][0] = 0.0f;
1206     D3DX_U(*pout).m[3][1] = 0.0f;
1207     D3DX_U(*pout).m[3][2] = 0.0f;
1208     D3DX_U(*pout).m[0][0] = 1.0f;
1209     D3DX_U(*pout).m[1][1] = 1.0f;
1210     D3DX_U(*pout).m[2][2] = 1.0f;
1211     D3DX_U(*pout).m[3][3] = 1.0f;
1212     return pout;
1213 }
1214
1215 static inline BOOL D3DXMatrixIsIdentity(D3DXMATRIX *pm)
1216 {
1217     int i,j;
1218     D3DXMATRIX testmatrix;
1219
1220     if ( !pm ) return FALSE;
1221     D3DXMatrixIdentity(&testmatrix);
1222     for (i=0; i<4; i++)
1223     {
1224      for (j=0; j<4; j++)
1225      {
1226       if ( D3DX_U(*pm).m[i][j] != D3DX_U(testmatrix).m[i][j] ) return FALSE;
1227      }
1228     }
1229     return TRUE;
1230 }
1231 #undef D3DX_U
1232
1233 /*__________________D3DXPLANE____________________*/
1234
1235 static inline FLOAT D3DXPlaneDot(CONST D3DXPLANE *pp, CONST D3DXVECTOR4 *pv)
1236 {
1237     if ( !pp || !pv ) return 0.0f;
1238     return ( (pp->a) * (pv->x) + (pp->b) * (pv->y) + (pp->c) * (pv->z) + (pp->d) * (pv->w) );
1239 }
1240
1241 static inline FLOAT D3DXPlaneDotCoord(CONST D3DXPLANE *pp, CONST D3DXVECTOR4 *pv)
1242 {
1243     if ( !pp || !pv ) return 0.0f;
1244     return ( (pp->a) * (pv->x) + (pp->b) * (pv->y) + (pp->c) * (pv->z) + (pp->d) );
1245 }
1246
1247 static inline FLOAT D3DXPlaneDotNormal(CONST D3DXPLANE *pp, CONST D3DXVECTOR4 *pv)
1248 {
1249     if ( !pp || !pv ) return 0.0f;
1250     return ( (pp->a) * (pv->x) + (pp->b) * (pv->y) + (pp->c) * (pv->z) );
1251 }
1252
1253 /*__________________D3DXQUATERNION____________________*/
1254
1255 static inline D3DXQUATERNION* D3DXQuaternionConjugate(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq)
1256 {
1257     if ( !pout || !pq) return NULL;
1258     pout->x = -pq->x;
1259     pout->y = -pq->y;
1260     pout->z = -pq->z;
1261     pout->w = pq->w;
1262     return pout;
1263 }
1264
1265 static inline FLOAT D3DXQuaternionDot(CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2)
1266 {
1267     if ( !pq1 || !pq2 ) return 0.0f;
1268     return (pq1->x) * (pq2->x) + (pq1->y) * (pq2->y) + (pq1->z) * (pq2->z) + (pq1->w) * (pq2->w);
1269 }
1270
1271 static inline D3DXQUATERNION* D3DXQuaternionIdentity(D3DXQUATERNION *pout)
1272 {
1273     if ( !pout) return NULL;
1274     pout->x = 0.0f;
1275     pout->y = 0.0f;
1276     pout->z = 0.0f;
1277     pout->w = 1.0f;
1278     return pout;
1279 }
1280
1281 static inline BOOL D3DXQuaternionIsIdentity(D3DXQUATERNION *pq)
1282 {
1283     if ( !pq) return FALSE;
1284     return ( (pq->x == 0.0f) && (pq->y == 0.0f) && (pq->z == 0.0f) && (pq->w == 1.0f) );
1285 }
1286
1287 static inline FLOAT D3DXQuaternionLength(CONST D3DXQUATERNION *pq)
1288 {
1289     if (!pq) return 0.0f;
1290     return sqrt( (pq->x) * (pq->x) + (pq->y) * (pq->y) + (pq->z) * (pq->z) + (pq->w) * (pq->w) );
1291 }
1292
1293 static inline FLOAT D3DXQuaternionLengthSq(CONST D3DXQUATERNION *pq)
1294 {
1295     if (!pq) return 0.0f;
1296     return (pq->x) * (pq->x) + (pq->y) * (pq->y) + (pq->z) * (pq->z) + (pq->w) * (pq->w);
1297 }
1298
1299 #endif