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 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 sqrt( (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 sqrt( (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 sqrt( (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 BOOL 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 BOOL 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 sqrt( (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