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