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