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