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