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 26inline D3DXVECTOR2::D3DXVECTOR2() 27{ 28} 29 30inline D3DXVECTOR2::D3DXVECTOR2(const FLOAT *pf) 31{ 32 if(!pf) return; 33 x = pf[0]; 34 y = pf[1]; 35} 36 37inline D3DXVECTOR2::D3DXVECTOR2(FLOAT fx, FLOAT fy) 38{ 39 x = fx; 40 y = fy; 41} 42 43inline D3DXVECTOR2::operator FLOAT* () 44{ 45 return (FLOAT*)&x; 46} 47 48inline D3DXVECTOR2::operator const FLOAT* () const 49{ 50 return (const FLOAT*)&x; 51} 52 53inline D3DXVECTOR2& D3DXVECTOR2::operator += (const D3DXVECTOR2& v) 54{ 55 x += v.x; 56 y += v.y; 57 return *this; 58} 59 60inline D3DXVECTOR2& D3DXVECTOR2::operator -= (const D3DXVECTOR2& v) 61{ 62 x -= v.x; 63 y -= v.y; 64 return *this; 65} 66 67inline D3DXVECTOR2& D3DXVECTOR2::operator *= (FLOAT f) 68{ 69 x *= f; 70 y *= f; 71 return *this; 72} 73 74inline D3DXVECTOR2& D3DXVECTOR2::operator /= (FLOAT f) 75{ 76 x /= f; 77 y /= f; 78 return *this; 79} 80 81inline D3DXVECTOR2 D3DXVECTOR2::operator + () const 82{ 83 return *this; 84} 85 86inline D3DXVECTOR2 D3DXVECTOR2::operator - () const 87{ 88 return D3DXVECTOR2(-x, -y); 89} 90 91inline D3DXVECTOR2 D3DXVECTOR2::operator + (const D3DXVECTOR2& v) const 92{ 93 return D3DXVECTOR2(x + v.x, y + v.y); 94} 95 96inline D3DXVECTOR2 D3DXVECTOR2::operator - (const D3DXVECTOR2& v) const 97{ 98 return D3DXVECTOR2(x - v.x, y - v.y); 99} 100 101inline D3DXVECTOR2 D3DXVECTOR2::operator * (FLOAT f) const 102{ 103 return D3DXVECTOR2(x * f, y * f); 104} 105 106inline D3DXVECTOR2 D3DXVECTOR2::operator / (FLOAT f) const 107{ 108 return D3DXVECTOR2(x / f, y / f); 109} 110 111inline D3DXVECTOR2 operator * (FLOAT f, const D3DXVECTOR2& v) 112{ 113 return D3DXVECTOR2(f * v.x, f * v.y); 114} 115 116inline BOOL D3DXVECTOR2::operator == (const D3DXVECTOR2& v) const 117{ 118 return x == v.x && y == v.y; 119} 120 121inline BOOL D3DXVECTOR2::operator != (const D3DXVECTOR2& v) const 122{ 123 return x != v.x || y != v.y; 124} 125 126inline D3DXVECTOR3::D3DXVECTOR3() 127{ 128} 129 130inline D3DXVECTOR3::D3DXVECTOR3(const FLOAT *pf) 131{ 132 if(!pf) return; 133 x = pf[0]; 134 y = pf[1]; 135 z = pf[2]; 136} 137 138inline D3DXVECTOR3::D3DXVECTOR3(const D3DVECTOR& v) 139{ 140 x = v.x; 141 y = v.y; 142 z = v.z; 143} 144 145inline D3DXVECTOR3::D3DXVECTOR3(FLOAT fx, FLOAT fy, FLOAT fz) 146{ 147 x = fx; 148 y = fy; 149 z = fz; 150} 151 152inline D3DXVECTOR3::operator FLOAT* () 153{ 154 return (FLOAT*)&x; 155} 156 157inline D3DXVECTOR3::operator const FLOAT* () const 158{ 159 return (const FLOAT*)&x; 160} 161 162inline D3DXVECTOR3& D3DXVECTOR3::operator += (const D3DXVECTOR3& v) 163{ 164 x += v.x; 165 y += v.y; 166 z += v.z; 167 return *this; 168} 169 170inline D3DXVECTOR3& D3DXVECTOR3::operator -= (const D3DXVECTOR3& v) 171{ 172 x -= v.x; 173 y -= v.y; 174 z -= v.z; 175 return *this; 176} 177 178inline D3DXVECTOR3& D3DXVECTOR3::operator *= (FLOAT f) 179{ 180 x *= f; 181 y *= f; 182 z *= f; 183 return *this; 184} 185 186inline D3DXVECTOR3& D3DXVECTOR3::operator /= (FLOAT f) 187{ 188 x /= f; 189 y /= f; 190 z /= f; 191 return *this; 192} 193 194inline D3DXVECTOR3 D3DXVECTOR3::operator + () const 195{ 196 return *this; 197} 198 199inline D3DXVECTOR3 D3DXVECTOR3::operator - () const 200{ 201 return D3DXVECTOR3(-x, -y, -z); 202} 203 204inline D3DXVECTOR3 D3DXVECTOR3::operator + (const D3DXVECTOR3& v) const 205{ 206 return D3DXVECTOR3(x + v.x, y + v.y, z + v.z); 207} 208 209inline D3DXVECTOR3 D3DXVECTOR3::operator - (const D3DXVECTOR3& v) const 210{ 211 return D3DXVECTOR3(x - v.x, y - v.y, z - v.z); 212} 213 214inline D3DXVECTOR3 D3DXVECTOR3::operator * (FLOAT f) const 215{ 216 return D3DXVECTOR3(x * f, y * f, z * f); 217} 218 219inline D3DXVECTOR3 D3DXVECTOR3::operator / (FLOAT f) const 220{ 221 return D3DXVECTOR3(x / f, y / f, z / f); 222} 223 224inline D3DXVECTOR3 operator * (FLOAT f, const D3DXVECTOR3& v) 225{ 226 return D3DXVECTOR3(f * v.x, f * v.y, f * v.z); 227} 228 229inline BOOL D3DXVECTOR3::operator == (const D3DXVECTOR3& v) const 230{ 231 return x == v.x && y == v.y && z == v.z; 232} 233 234inline BOOL D3DXVECTOR3::operator != (const D3DXVECTOR3& v) const 235{ 236 return x != v.x || y != v.y || z != v.z; 237} 238 239inline D3DXVECTOR4::D3DXVECTOR4() 240{ 241} 242 243inline 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 252inline 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 260inline D3DXVECTOR4::operator FLOAT* () 261{ 262 return (FLOAT*)&x; 263} 264 265inline D3DXVECTOR4::operator const FLOAT* () const 266{ 267 return (const FLOAT*)&x; 268} 269 270inline 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 279inline 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 288inline D3DXVECTOR4& D3DXVECTOR4::operator *= (FLOAT f) 289{ 290 x *= f; 291 y *= f; 292 z *= f; 293 w *= f; 294 return *this; 295} 296 297inline D3DXVECTOR4& D3DXVECTOR4::operator /= (FLOAT f) 298{ 299 x /= f; 300 y /= f; 301 z /= f; 302 w /= f; 303 return *this; 304} 305 306inline D3DXVECTOR4 D3DXVECTOR4::operator + () const 307{ 308 return *this; 309} 310 311inline D3DXVECTOR4 D3DXVECTOR4::operator - () const 312{ 313 return D3DXVECTOR4(-x, -y, -z, -w); 314} 315 316inline 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 321inline 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 326inline D3DXVECTOR4 D3DXVECTOR4::operator * (FLOAT f) const 327{ 328 return D3DXVECTOR4(x * f, y * f, z * f, w * f); 329} 330 331inline D3DXVECTOR4 D3DXVECTOR4::operator / (FLOAT f) const 332{ 333 return D3DXVECTOR4(x / f, y / f, z / f, w / f); 334} 335 336inline 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 341inline BOOL D3DXVECTOR4::operator == (const D3DXVECTOR4& v) const 342{ 343 return x == v.x && y == v.y && z == v.z && w == v.w; 344} 345 346inline BOOL D3DXVECTOR4::operator != (const D3DXVECTOR4& v) const 347{ 348 return x != v.x || y != v.y || z != v.z || w != v.w; 349} 350 351inline D3DXMATRIX::D3DXMATRIX() 352{ 353} 354 355inline D3DXMATRIX::D3DXMATRIX(const FLOAT *pf) 356{ 357 if(!pf) return; 358 memcpy(&_11, pf, sizeof(D3DXMATRIX)); 359} 360 361inline D3DXMATRIX::D3DXMATRIX(const D3DMATRIX& mat) 362{ 363 memcpy(&_11, &mat, sizeof(D3DXMATRIX)); 364} 365 366inline 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 377inline FLOAT& D3DXMATRIX::operator () (UINT row, UINT col) 378{ 379 return m[row][col]; 380} 381 382inline FLOAT D3DXMATRIX::operator () (UINT row, UINT col) const 383{ 384 return m[row][col]; 385} 386 387inline D3DXMATRIX::operator FLOAT* () 388{ 389 return (FLOAT*)&_11; 390} 391 392inline D3DXMATRIX::operator const FLOAT* () const 393{ 394 return (const FLOAT*)&_11; 395} 396 397inline D3DXMATRIX& D3DXMATRIX::operator *= (const D3DXMATRIX& mat) 398{ 399 D3DXMatrixMultiply(this, this, &mat); 400 return *this; 401} 402 403inline 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 412inline 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 421inline 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 430inline 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 440inline D3DXMATRIX D3DXMATRIX::operator + () const 441{ 442 return *this; 443} 444 445inline 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 453inline D3DXMATRIX D3DXMATRIX::operator * (const D3DXMATRIX& mat) const 454{ 455 D3DXMATRIX buf; 456 D3DXMatrixMultiply(&buf, this, &mat); 457 return buf; 458} 459 460inline 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 468inline 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 476inline 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 484inline 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 493inline 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 501inline BOOL D3DXMATRIX::operator == (const D3DXMATRIX& mat) const 502{ 503 return (memcmp(this, &mat, sizeof(D3DXMATRIX)) == 0); 504} 505 506inline BOOL D3DXMATRIX::operator != (const D3DXMATRIX& mat) const 507{ 508 return (memcmp(this, &mat, sizeof(D3DXMATRIX)) != 0); 509} 510 511inline D3DXQUATERNION::D3DXQUATERNION() 512{ 513} 514 515inline 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 524inline 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 532inline D3DXQUATERNION::operator FLOAT* () 533{ 534 return (FLOAT*)&x; 535} 536 537inline D3DXQUATERNION::operator const FLOAT* () const 538{ 539 return (const FLOAT*)&x; 540} 541 542inline 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 551inline 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 560inline D3DXQUATERNION& D3DXQUATERNION::operator *= (const D3DXQUATERNION& quat) 561{ 562 D3DXQuaternionMultiply(this, this, &quat); 563 return *this; 564} 565 566inline D3DXQUATERNION& D3DXQUATERNION::operator *= (FLOAT f) 567{ 568 x *= f; 569 y *= f; 570 z *= f; 571 w *= f; 572 return *this; 573} 574 575inline 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 585inline D3DXQUATERNION D3DXQUATERNION::operator + () const 586{ 587 return *this; 588} 589 590inline D3DXQUATERNION D3DXQUATERNION::operator - () const 591{ 592 return D3DXQUATERNION(-x, -y, -z, -w); 593} 594 595inline 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 600inline 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 605inline D3DXQUATERNION D3DXQUATERNION::operator * (const D3DXQUATERNION& quat) const 606{ 607 D3DXQUATERNION buf; 608 D3DXQuaternionMultiply(&buf, this, &quat); 609 return buf; 610} 611 612inline D3DXQUATERNION D3DXQUATERNION::operator * (FLOAT f) const 613{ 614 return D3DXQUATERNION(x * f, y * f, z * f, w * f); 615} 616 617inline 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 623inline 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 628inline BOOL D3DXQUATERNION::operator == (const D3DXQUATERNION& quat) const 629{ 630 return x == quat.x && y == quat.y && z == quat.z && w == quat.w; 631} 632 633inline BOOL D3DXQUATERNION::operator != (const D3DXQUATERNION& quat) const 634{ 635 return x != quat.x || y != quat.y || z != quat.z || w != quat.w; 636} 637 638inline D3DXPLANE::D3DXPLANE() 639{ 640} 641 642inline 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 651inline 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 659inline D3DXPLANE::operator FLOAT* () 660{ 661 return (FLOAT*)&a; 662} 663 664inline D3DXPLANE::operator const FLOAT* () const 665{ 666 return (const FLOAT*)&a; 667} 668 669inline D3DXPLANE D3DXPLANE::operator + () const 670{ 671 return *this; 672} 673 674inline D3DXPLANE D3DXPLANE::operator - () const 675{ 676 return D3DXPLANE(-a, -b, -c, -d); 677} 678 679inline BOOL D3DXPLANE::operator == (const D3DXPLANE& pl) const 680{ 681 return a == pl.a && b == pl.b && c == pl.c && d == pl.d; 682} 683 684inline BOOL D3DXPLANE::operator != (const D3DXPLANE& pl) const 685{ 686 return a != pl.a || b != pl.b || c != pl.c || d != pl.d; 687} 688 689inline D3DXCOLOR::D3DXCOLOR() 690{ 691} 692 693inline 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 702inline 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 711inline D3DXCOLOR::D3DXCOLOR(const D3DCOLORVALUE& col) 712{ 713 r = col.r; 714 g = col.g; 715 b = col.b; 716 a = col.a; 717} 718 719inline 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 727inline 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 737inline D3DXCOLOR::operator FLOAT * () 738{ 739 return (FLOAT*)&r; 740} 741 742inline D3DXCOLOR::operator const FLOAT * () const 743{ 744 return (const FLOAT*)&r; 745} 746 747inline D3DXCOLOR::operator D3DCOLORVALUE * () 748{ 749 return (D3DCOLORVALUE*)&r; 750} 751 752inline D3DXCOLOR::operator const D3DCOLORVALUE * () const 753{ 754 return (const D3DCOLORVALUE*)&r; 755} 756 757inline D3DXCOLOR::operator D3DCOLORVALUE& () 758{ 759 return *((D3DCOLORVALUE*)&r); 760} 761 762inline D3DXCOLOR::operator const D3DCOLORVALUE& () const 763{ 764 return *((const D3DCOLORVALUE*)&r); 765} 766 767inline 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 776inline 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 785inline D3DXCOLOR& D3DXCOLOR::operator *= (FLOAT f) 786{ 787 r *= f; 788 g *= f; 789 b *= f; 790 a *= f; 791 return *this; 792} 793 794inline 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 804inline D3DXCOLOR D3DXCOLOR::operator + () const 805{ 806 return *this; 807} 808 809inline D3DXCOLOR D3DXCOLOR::operator - () const 810{ 811 return D3DXCOLOR(-r, -g, -b, -a); 812} 813 814inline 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 819inline 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 824inline D3DXCOLOR D3DXCOLOR::operator * (FLOAT f) const 825{ 826 return D3DXCOLOR(r * f, g * f, b * f, a * f); 827} 828 829inline 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 835inline 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 840inline BOOL D3DXCOLOR::operator == (const D3DXCOLOR& col) const 841{ 842 return r == col.r && g == col.g && b == col.b && a == col.a; 843} 844 845inline BOOL D3DXCOLOR::operator != (const D3DXCOLOR& col) const 846{ 847 return r != col.r || g != col.g || b != col.b || a != col.a; 848} 849 850inline D3DXFLOAT16::D3DXFLOAT16() 851{ 852} 853 854inline D3DXFLOAT16::D3DXFLOAT16(FLOAT f) 855{ 856 D3DXFloat32To16Array(this, &f, 1); 857} 858 859inline D3DXFLOAT16::D3DXFLOAT16(const D3DXFLOAT16 &f) 860{ 861 value = f.value; 862} 863 864inline D3DXFLOAT16::operator FLOAT () 865{ 866 FLOAT f; 867 D3DXFloat16To32Array(&f, this, 1); 868 return f; 869} 870 871inline BOOL D3DXFLOAT16::operator == (const D3DXFLOAT16 &f) const 872{ 873 return value == f.value; 874} 875 876inline BOOL D3DXFLOAT16::operator != (const D3DXFLOAT16 &f) const 877{ 878 return value != f.value; 879} 880 881#endif /* __cplusplus */ 882 883/*_______________D3DXCOLOR_____________________*/ 884 885static 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 895static 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 905static 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 915static 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 925static 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 935static 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 947static 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 955static 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 961static 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 967static 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 973static 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 979static 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 987static 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 995static 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 1003static 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 1011static 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 1021static 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 1030static 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 1042static 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 1048static 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 1054static 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 1060static 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 1069static 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 1078static 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 1087static 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 1096static 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 1106static 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 1116static 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 1122static 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 1128static 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 1134static 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 1145static 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 1155static 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 1165static 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 1175static 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 1192static 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 1214static 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 1234static 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 1240static 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 1246static 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 1254static 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 1264static 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 1270static 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 1280static 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 1286static 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 1292static 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 1299