1 /************************************************************************
3 * XNAMath.h -- SIMD C++ Math library for Windows and Xbox 360 *
5 * Copyright (c) Microsoft Corp. All rights reserved. *
7 ************************************************************************/
9 #if defined(_MSC_VER) && (_MSC_VER > 1000)
17 #error XNAMATH and XBOXMATH are incompatible in the same compilation module. Use one or the other.
20 #define XNAMATH_VERSION 205
22 #if !defined(_XM_X64_) && !defined(_XM_X86_)
23 #if defined(_M_AMD64) || defined(_AMD64_)
25 #elif defined(_M_IX86) || defined(_X86_)
31 #if !defined(_XM_BIGENDIAN_) && !defined(_XM_LITTLEENDIAN_)
32 #if defined(_XM_X64_) || defined(_XM_X86_)
33 #define _XM_LITTLEENDIAN_
34 #elif defined(_XBOX_VER)
35 #define _XM_BIGENDIAN_
37 #error xnamath.h does not support this target
41 #if defined(_XM_X86_) || defined(_XM_X64_)
42 #define _XM_SSE_INTRINSICS_
43 #if !defined(__cplusplus) && !defined(_XM_NO_INTRINSICS_)
44 #error xnamath.h only supports C compliation for Xbox 360 targets and no intrinsics cases for x86/x64
46 #elif defined(_XBOX_VER)
47 #if !defined(__VMX128_SUPPORTED) && !defined(_XM_NO_INTRINSICS_)
48 #error xnamath.h requires VMX128 compiler support for XBOX 360
49 #endif // !__VMX128_SUPPORTED && !_XM_NO_INTRINSICS_
50 #define _XM_VMX128_INTRINSICS_
51 #elif !defined(_XM_NO_INTRINSICS_)
52 #error xnamath.h does not support this target
56 #if defined(_XM_SSE_INTRINSICS_)
57 #ifndef _XM_NO_INTRINSICS_
58 #include <xmmintrin.h>
59 #include <emmintrin.h>
61 #elif defined(_XM_VMX128_INTRINSICS_)
62 #error This version of xnamath.h does not support Xbox 360
65 #if defined(_XM_SSE_INTRINSICS_)
67 #pragma warning(disable:4985)
70 #if defined(_XM_SSE_INTRINSICS_)
78 #if !defined(XMINLINE)
79 #if !defined(XM_NO_MISALIGNED_VECTOR_ACCESS)
80 #define XMINLINE __inline
82 #define XMINLINE __forceinline
86 #if !defined(XMFINLINE)
87 #define XMFINLINE __forceinline
96 #if !defined(XMASSERT)
97 #if defined(_PREFAST_)
98 #define XMASSERT(Expression) __analysis_assume((Expression))
99 #elif defined(XMDEBUG) // !_PREFAST_
100 #define XMASSERT(Expression) ((VOID)((Expression) || (XMAssert(#Expression, __FILE__, __LINE__), 0)))
102 #define XMASSERT(Expression) ((VOID)0)
106 #if !defined(XM_NO_ALIGNMENT)
107 #define _DECLSPEC_ALIGN_16_ __declspec(align(16))
109 #define _DECLSPEC_ALIGN_16_
113 #if defined(_MSC_VER) && (_MSC_VER<1500) && (_MSC_VER>=1400)
114 #define _XM_ISVS2005_
117 /****************************************************************************
119 * Constant definitions
121 ****************************************************************************/
123 #define XM_PI 3.141592654f
124 #define XM_2PI 6.283185307f
125 #define XM_1DIVPI 0.318309886f
126 #define XM_1DIV2PI 0.159154943f
127 #define XM_PIDIV2 1.570796327f
128 #define XM_PIDIV4 0.785398163f
130 #define XM_SELECT_0 0x00000000
131 #define XM_SELECT_1 0xFFFFFFFF
133 #define XM_PERMUTE_0X 0x00010203
134 #define XM_PERMUTE_0Y 0x04050607
135 #define XM_PERMUTE_0Z 0x08090A0B
136 #define XM_PERMUTE_0W 0x0C0D0E0F
137 #define XM_PERMUTE_1X 0x10111213
138 #define XM_PERMUTE_1Y 0x14151617
139 #define XM_PERMUTE_1Z 0x18191A1B
140 #define XM_PERMUTE_1W 0x1C1D1E1F
142 #define XM_CRMASK_CR6 0x000000F0
143 #define XM_CRMASK_CR6TRUE 0x00000080
144 #define XM_CRMASK_CR6FALSE 0x00000020
145 #define XM_CRMASK_CR6BOUNDS XM_CRMASK_CR6FALSE
148 #define XM_CACHE_LINE_SIZE 64
150 /****************************************************************************
154 ****************************************************************************/
158 XMFINLINE FLOAT XMConvertToRadians(FLOAT fDegrees) { return fDegrees * (XM_PI / 180.0f); }
159 XMFINLINE FLOAT XMConvertToDegrees(FLOAT fRadians) { return fRadians * (180.0f / XM_PI); }
161 // Condition register evaluation proceeding a recording (Rc) comparison
163 #define XMComparisonAllTrue(CR) (((CR) & XM_CRMASK_CR6TRUE) == XM_CRMASK_CR6TRUE)
164 #define XMComparisonAnyTrue(CR) (((CR) & XM_CRMASK_CR6FALSE) != XM_CRMASK_CR6FALSE)
165 #define XMComparisonAllFalse(CR) (((CR) & XM_CRMASK_CR6FALSE) == XM_CRMASK_CR6FALSE)
166 #define XMComparisonAnyFalse(CR) (((CR) & XM_CRMASK_CR6TRUE) != XM_CRMASK_CR6TRUE)
167 #define XMComparisonMixed(CR) (((CR) & XM_CRMASK_CR6) == 0)
168 #define XMComparisonAllInBounds(CR) (((CR) & XM_CRMASK_CR6BOUNDS) == XM_CRMASK_CR6BOUNDS)
169 #define XMComparisonAnyOutOfBounds(CR) (((CR) & XM_CRMASK_CR6BOUNDS) != XM_CRMASK_CR6BOUNDS)
172 #define XMMin(a, b) (((a) < (b)) ? (a) : (b))
173 #define XMMax(a, b) (((a) > (b)) ? (a) : (b))
175 /****************************************************************************
179 ****************************************************************************/
181 #pragma warning(push)
182 #pragma warning(disable:4201 4365 4324)
184 #ifdef _XM_BIGENDIAN_
185 #pragma bitfield_order(push)
186 #pragma bitfield_order(lsb_to_msb)
189 //------------------------------------------------------------------------------
190 #if defined(_XM_NO_INTRINSICS_) && !defined(_XBOX_VER)
191 // The __vector4 structure is an intrinsic on Xbox but must be separately defined
193 typedef struct __vector4
197 float vector4_f32[4];
198 unsigned int vector4_u32[4];
199 #ifndef XM_STRICT_VECTOR4
209 #endif // !XM_STRICT_VECTOR4
212 #endif // _XM_NO_INTRINSICS_
214 //------------------------------------------------------------------------------
215 #if (defined (_XM_X86_) || defined(_XM_X64_)) && defined(_XM_NO_INTRINSICS_)
216 typedef UINT __vector4i[4];
218 typedef __declspec(align(16)) UINT __vector4i[4];
221 //------------------------------------------------------------------------------
222 // Vector intrinsic: Four 32 bit floating point components aligned on a 16 byte
223 // boundary and mapped to hardware vector registers
224 #if defined(_XM_SSE_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
225 typedef __m128 XMVECTOR;
227 typedef __vector4 XMVECTOR;
230 // Fix-up for (1st-3rd) XMVECTOR parameters that are pass-in-register for x86 and Xbox 360, but not for other targets
231 #if defined(_XM_VMX128_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
232 typedef const XMVECTOR FXMVECTOR;
233 #elif defined(_XM_X86_) && !defined(_XM_NO_INTRINSICS_)
234 typedef const XMVECTOR FXMVECTOR;
235 #elif defined(__cplusplus)
236 typedef const XMVECTOR& FXMVECTOR;
238 typedef const XMVECTOR FXMVECTOR;
241 // Fix-up for (4th+) XMVECTOR parameters to pass in-register for Xbox 360 and by reference otherwise
242 #if defined(_XM_VMX128_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
243 typedef const XMVECTOR CXMVECTOR;
244 #elif defined(__cplusplus)
245 typedef const XMVECTOR& CXMVECTOR;
247 typedef const XMVECTOR CXMVECTOR;
250 //------------------------------------------------------------------------------
251 // Conversion types for constants
252 typedef _DECLSPEC_ALIGN_16_ struct XMVECTORF32 {
258 #if defined(__cplusplus)
259 inline operator XMVECTOR() const { return v; }
260 inline operator const float*() const { return f; }
261 #if !defined(_XM_NO_INTRINSICS_) && defined(_XM_SSE_INTRINSICS_)
262 inline operator __m128i() const { return reinterpret_cast<const __m128i *>(&v)[0]; }
263 inline operator __m128d() const { return reinterpret_cast<const __m128d *>(&v)[0]; }
265 #endif // __cplusplus
268 typedef _DECLSPEC_ALIGN_16_ struct XMVECTORI32 {
273 #if defined(__cplusplus)
274 inline operator XMVECTOR() const { return v; }
275 #if !defined(_XM_NO_INTRINSICS_) && defined(_XM_SSE_INTRINSICS_)
276 inline operator __m128i() const { return reinterpret_cast<const __m128i *>(&v)[0]; }
277 inline operator __m128d() const { return reinterpret_cast<const __m128d *>(&v)[0]; }
279 #endif // __cplusplus
282 typedef _DECLSPEC_ALIGN_16_ struct XMVECTORU8 {
287 #if defined(__cplusplus)
288 inline operator XMVECTOR() const { return v; }
289 #if !defined(_XM_NO_INTRINSICS_) && defined(_XM_SSE_INTRINSICS_)
290 inline operator __m128i() const { return reinterpret_cast<const __m128i *>(&v)[0]; }
291 inline operator __m128d() const { return reinterpret_cast<const __m128d *>(&v)[0]; }
293 #endif // __cplusplus
296 typedef _DECLSPEC_ALIGN_16_ struct XMVECTORU32 {
301 #if defined(__cplusplus)
302 inline operator XMVECTOR() const { return v; }
303 #if !defined(_XM_NO_INTRINSICS_) && defined(_XM_SSE_INTRINSICS_)
304 inline operator __m128i() const { return reinterpret_cast<const __m128i *>(&v)[0]; }
305 inline operator __m128d() const { return reinterpret_cast<const __m128d *>(&v)[0]; }
307 #endif // __cplusplus
310 //------------------------------------------------------------------------------
312 #if defined(__cplusplus) && !defined(XM_NO_OPERATOR_OVERLOADS)
314 XMVECTOR operator+ (FXMVECTOR V);
315 XMVECTOR operator- (FXMVECTOR V);
317 XMVECTOR& operator+= (XMVECTOR& V1, FXMVECTOR V2);
318 XMVECTOR& operator-= (XMVECTOR& V1, FXMVECTOR V2);
319 XMVECTOR& operator*= (XMVECTOR& V1, FXMVECTOR V2);
320 XMVECTOR& operator/= (XMVECTOR& V1, FXMVECTOR V2);
321 XMVECTOR& operator*= (XMVECTOR& V, FLOAT S);
322 XMVECTOR& operator/= (XMVECTOR& V, FLOAT S);
324 XMVECTOR operator+ (FXMVECTOR V1, FXMVECTOR V2);
325 XMVECTOR operator- (FXMVECTOR V1, FXMVECTOR V2);
326 XMVECTOR operator* (FXMVECTOR V1, FXMVECTOR V2);
327 XMVECTOR operator/ (FXMVECTOR V1, FXMVECTOR V2);
328 XMVECTOR operator* (FXMVECTOR V, FLOAT S);
329 XMVECTOR operator* (FLOAT S, FXMVECTOR V);
330 XMVECTOR operator/ (FXMVECTOR V, FLOAT S);
332 #endif // __cplusplus && !XM_NO_OPERATOR_OVERLOADS
334 //------------------------------------------------------------------------------
335 // Matrix type: Sixteen 32 bit floating point components aligned on a
336 // 16 byte boundary and mapped to four hardware vector registers
337 #if (defined(_XM_X86_) || defined(_XM_X64_)) && defined(_XM_NO_INTRINSICS_)
338 typedef struct _XMMATRIX
340 typedef _DECLSPEC_ALIGN_16_ struct _XMMATRIX
343 #if defined(_XM_NO_INTRINSICS_) || !defined(XM_STRICT_MATRIX)
349 FLOAT _11, _12, _13, _14;
350 FLOAT _21, _22, _23, _24;
351 FLOAT _31, _32, _33, _34;
352 FLOAT _41, _42, _43, _44;
363 _XMMATRIX(FXMVECTOR R0, FXMVECTOR R1, FXMVECTOR R2, CXMVECTOR R3);
364 _XMMATRIX(FLOAT m00, FLOAT m01, FLOAT m02, FLOAT m03,
365 FLOAT m10, FLOAT m11, FLOAT m12, FLOAT m13,
366 FLOAT m20, FLOAT m21, FLOAT m22, FLOAT m23,
367 FLOAT m30, FLOAT m31, FLOAT m32, FLOAT m33);
368 explicit _XMMATRIX(_In_count_c_(16) CONST FLOAT *pArray);
370 #if defined(_XM_NO_INTRINSICS_) || !defined(XM_STRICT_MATRIX)
371 FLOAT operator() (UINT Row, UINT Column) CONST { return m[Row][Column]; }
372 FLOAT& operator() (UINT Row, UINT Column) { return m[Row][Column]; }
375 _XMMATRIX& operator= (CONST _XMMATRIX& M);
377 #ifndef XM_NO_OPERATOR_OVERLOADS
378 _XMMATRIX& operator*= (CONST _XMMATRIX& M);
379 _XMMATRIX operator* (CONST _XMMATRIX& M) CONST;
380 #endif // !XM_NO_OPERATOR_OVERLOADS
382 #endif // __cplusplus
386 // Fix-up for XMMATRIX parameters to pass in-register on Xbox 360, by reference otherwise
387 #if defined(_XM_VMX128_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
388 typedef const XMMATRIX CXMMATRIX;
389 #elif defined(__cplusplus)
390 typedef const XMMATRIX& CXMMATRIX;
392 typedef const XMMATRIX CXMMATRIX;
395 //------------------------------------------------------------------------------
396 // 16 bit floating point number consisting of a sign bit, a 5 bit biased
397 // exponent, and a 10 bit mantissa
400 //------------------------------------------------------------------------------
401 // 2D Vector; 32 bit floating point components
402 typedef struct _XMFLOAT2
410 _XMFLOAT2(FLOAT _x, FLOAT _y) : x(_x), y(_y) {};
411 _XMFLOAT2(_In_count_c_(2) CONST FLOAT *pArray);
413 _XMFLOAT2& operator= (CONST _XMFLOAT2& Float2);
415 #endif // __cplusplus
419 // 2D Vector; 32 bit floating point components aligned on a 16 byte boundary
421 __declspec(align(16)) struct XMFLOAT2A : public XMFLOAT2
423 XMFLOAT2A() : XMFLOAT2() {};
424 XMFLOAT2A(FLOAT _x, FLOAT _y) : XMFLOAT2(_x, _y) {};
425 XMFLOAT2A(_In_count_c_(2) CONST FLOAT *pArray) : XMFLOAT2(pArray) {};
427 XMFLOAT2A& operator= (CONST XMFLOAT2A& Float2);
430 typedef __declspec(align(16)) XMFLOAT2 XMFLOAT2A;
431 #endif // __cplusplus
433 //------------------------------------------------------------------------------
434 // 2D Vector; 32 bit signed integer components
435 typedef struct _XMINT2
443 _XMINT2(INT _x, INT _y) : x(_x), y(_y) {};
444 explicit _XMINT2(_In_count_c_(2) CONST INT *pArray);
446 _XMINT2& operator= (CONST _XMINT2& Int2);
448 #endif // __cplusplus
452 // 2D Vector; 32 bit unsigned integer components
453 typedef struct _XMUINT2
461 _XMUINT2(UINT _x, UINT _y) : x(_x), y(_y) {};
462 explicit _XMUINT2(_In_count_c_(2) CONST UINT *pArray);
464 _XMUINT2& operator= (CONST _XMUINT2& UInt2);
466 #endif // __cplusplus
470 //------------------------------------------------------------------------------
471 // 2D Vector; 16 bit floating point components
472 typedef struct _XMHALF2
480 _XMHALF2(HALF _x, HALF _y) : x(_x), y(_y) {};
481 explicit _XMHALF2(_In_count_c_(2) CONST HALF *pArray);
482 _XMHALF2(FLOAT _x, FLOAT _y);
483 explicit _XMHALF2(_In_count_c_(2) CONST FLOAT *pArray);
485 _XMHALF2& operator= (CONST _XMHALF2& Half2);
487 #endif // __cplusplus
491 //------------------------------------------------------------------------------
492 // 2D Vector; 16 bit signed normalized integer components
493 typedef struct _XMSHORTN2
501 _XMSHORTN2(SHORT _x, SHORT _y) : x(_x), y(_y) {};
502 explicit _XMSHORTN2(_In_count_c_(2) CONST SHORT *pArray);
503 _XMSHORTN2(FLOAT _x, FLOAT _y);
504 explicit _XMSHORTN2(_In_count_c_(2) CONST FLOAT *pArray);
506 _XMSHORTN2& operator= (CONST _XMSHORTN2& ShortN2);
508 #endif // __cplusplus
512 // 2D Vector; 16 bit signed integer components
513 typedef struct _XMSHORT2
521 _XMSHORT2(SHORT _x, SHORT _y) : x(_x), y(_y) {};
522 explicit _XMSHORT2(_In_count_c_(2) CONST SHORT *pArray);
523 _XMSHORT2(FLOAT _x, FLOAT _y);
524 explicit _XMSHORT2(_In_count_c_(2) CONST FLOAT *pArray);
526 _XMSHORT2& operator= (CONST _XMSHORT2& Short2);
528 #endif // __cplusplus
532 // 2D Vector; 16 bit unsigned normalized integer components
533 typedef struct _XMUSHORTN2
541 _XMUSHORTN2(USHORT _x, USHORT _y) : x(_x), y(_y) {};
542 explicit _XMUSHORTN2(_In_count_c_(2) CONST USHORT *pArray);
543 _XMUSHORTN2(FLOAT _x, FLOAT _y);
544 explicit _XMUSHORTN2(_In_count_c_(2) CONST FLOAT *pArray);
546 _XMUSHORTN2& operator= (CONST _XMUSHORTN2& UShortN2);
548 #endif // __cplusplus
552 // 2D Vector; 16 bit unsigned integer components
553 typedef struct _XMUSHORT2
561 _XMUSHORT2(USHORT _x, USHORT _y) : x(_x), y(_y) {};
562 explicit _XMUSHORT2(_In_count_c_(2) CONST USHORT *pArray);
563 _XMUSHORT2(FLOAT _x, FLOAT _y);
564 explicit _XMUSHORT2(_In_count_c_(2) CONST FLOAT *pArray);
566 _XMUSHORT2& operator= (CONST _XMUSHORT2& UShort2);
568 #endif // __cplusplus
572 //------------------------------------------------------------------------------
573 // 2D Vector; 8 bit signed normalized integer components
574 typedef struct _XMBYTEN2
582 _XMBYTEN2(CHAR _x, CHAR _y) : x(_x), y(_y) {};
583 explicit _XMBYTEN2(_In_count_c_(2) CONST CHAR *pArray);
584 _XMBYTEN2(FLOAT _x, FLOAT _y);
585 explicit _XMBYTEN2(_In_count_c_(2) CONST FLOAT *pArray);
587 _XMBYTEN2& operator= (CONST _XMBYTEN2& ByteN2);
589 #endif // __cplusplus
593 // 2D Vector; 8 bit signed integer components
594 typedef struct _XMBYTE2
602 _XMBYTE2(CHAR _x, CHAR _y) : x(_x), y(_y) {};
603 explicit _XMBYTE2(_In_count_c_(2) CONST CHAR *pArray);
604 _XMBYTE2(FLOAT _x, FLOAT _y);
605 explicit _XMBYTE2(_In_count_c_(2) CONST FLOAT *pArray);
607 _XMBYTE2& operator= (CONST _XMBYTE2& Byte2);
609 #endif // __cplusplus
613 // 2D Vector; 8 bit unsigned normalized integer components
614 typedef struct _XMUBYTEN2
622 _XMUBYTEN2(BYTE _x, BYTE _y) : x(_x), y(_y) {};
623 explicit _XMUBYTEN2(_In_count_c_(2) CONST BYTE *pArray);
624 _XMUBYTEN2(FLOAT _x, FLOAT _y);
625 explicit _XMUBYTEN2(_In_count_c_(2) CONST FLOAT *pArray);
627 _XMUBYTEN2& operator= (CONST _XMUBYTEN2& UByteN2);
629 #endif // __cplusplus
634 // 2D Vector; 8 bit unsigned integer components
635 typedef struct _XMUBYTE2
643 _XMUBYTE2(BYTE _x, BYTE _y) : x(_x), y(_y) {};
644 explicit _XMUBYTE2(_In_count_c_(2) CONST BYTE *pArray);
645 _XMUBYTE2(FLOAT _x, FLOAT _y);
646 explicit _XMUBYTE2(_In_count_c_(2) CONST FLOAT *pArray);
648 _XMUBYTE2& operator= (CONST _XMUBYTE2& UByte2);
650 #endif // __cplusplus
654 //------------------------------------------------------------------------------
655 // 3D Vector; 32 bit floating point components
656 typedef struct _XMFLOAT3
665 _XMFLOAT3(FLOAT _x, FLOAT _y, FLOAT _z) : x(_x), y(_y), z(_z) {};
666 _XMFLOAT3(_In_count_c_(3) CONST FLOAT *pArray);
668 _XMFLOAT3& operator= (CONST _XMFLOAT3& Float3);
670 #endif // __cplusplus
674 // 3D Vector; 32 bit floating point components aligned on a 16 byte boundary
676 __declspec(align(16)) struct XMFLOAT3A : public XMFLOAT3
678 XMFLOAT3A() : XMFLOAT3() {};
679 XMFLOAT3A(FLOAT _x, FLOAT _y, FLOAT _z) : XMFLOAT3(_x, _y, _z) {};
680 XMFLOAT3A(_In_count_c_(3) CONST FLOAT *pArray) : XMFLOAT3(pArray) {};
682 XMFLOAT3A& operator= (CONST XMFLOAT3A& Float3);
685 typedef __declspec(align(16)) XMFLOAT3 XMFLOAT3A;
686 #endif // __cplusplus
688 //------------------------------------------------------------------------------
689 // 3D Vector; 32 bit signed integer components
690 typedef struct _XMINT3
699 _XMINT3(INT _x, INT _y, INT _z) : x(_x), y(_y), z(_z) {};
700 explicit _XMINT3(_In_count_c_(3) CONST INT *pArray);
702 _XMINT3& operator= (CONST _XMINT3& Int3);
704 #endif // __cplusplus
708 // 3D Vector; 32 bit unsigned integer components
709 typedef struct _XMUINT3
718 _XMUINT3(UINT _x, UINT _y, UINT _z) : x(_x), y(_y), z(_z) {};
719 explicit _XMUINT3(_In_count_c_(3) CONST UINT *pArray);
721 _XMUINT3& operator= (CONST _XMUINT3& UInt3);
723 #endif // __cplusplus
727 //------------------------------------------------------------------------------
728 // 3D Vector; 11-11-10 bit normalized components packed into a 32 bit integer
729 // The normalized 3D Vector is packed into 32 bits as follows: a 10 bit signed,
730 // normalized integer for the z component and 11 bit signed, normalized
731 // integers for the x and y components. The z component is stored in the
732 // most significant bits and the x component in the least significant bits
733 // (Z10Y11X11): [32] zzzzzzzz zzyyyyyy yyyyyxxx xxxxxxxx [0]
734 typedef struct _XMHENDN3
740 INT x : 11; // -1023/1023 to 1023/1023
741 INT y : 11; // -1023/1023 to 1023/1023
742 INT z : 10; // -511/511 to 511/511
750 explicit _XMHENDN3(UINT Packed) : v(Packed) {};
751 _XMHENDN3(FLOAT _x, FLOAT _y, FLOAT _z);
752 explicit _XMHENDN3(_In_count_c_(3) CONST FLOAT *pArray);
754 operator UINT () const { return v; }
756 _XMHENDN3& operator= (CONST _XMHENDN3& HenDN3);
757 _XMHENDN3& operator= (CONST UINT Packed);
759 #endif // __cplusplus
763 // 3D Vector; 11-11-10 bit components packed into a 32 bit integer
764 // The 3D Vector is packed into 32 bits as follows: a 10 bit signed,
765 // integer for the z component and 11 bit signed integers for the
766 // x and y components. The z component is stored in the
767 // most significant bits and the x component in the least significant bits
768 // (Z10Y11X11): [32] zzzzzzzz zzyyyyyy yyyyyxxx xxxxxxxx [0]
769 typedef struct _XMHEND3
775 INT x : 11; // -1023 to 1023
776 INT y : 11; // -1023 to 1023
777 INT z : 10; // -511 to 511
785 explicit _XMHEND3(UINT Packed) : v(Packed) {};
786 _XMHEND3(FLOAT _x, FLOAT _y, FLOAT _z);
787 explicit _XMHEND3(_In_count_c_(3) CONST FLOAT *pArray);
789 operator UINT () const { return v; }
791 _XMHEND3& operator= (CONST _XMHEND3& HenD3);
792 _XMHEND3& operator= (CONST UINT Packed);
794 #endif // __cplusplus
798 // 3D Vector; 11-11-10 bit normalized components packed into a 32 bit integer
799 // The normalized 3D Vector is packed into 32 bits as follows: a 10 bit unsigned,
800 // normalized integer for the z component and 11 bit unsigned, normalized
801 // integers for the x and y components. The z component is stored in the
802 // most significant bits and the x component in the least significant bits
803 // (Z10Y11X11): [32] zzzzzzzz zzyyyyyy yyyyyxxx xxxxxxxx [0]
804 typedef struct _XMUHENDN3
810 UINT x : 11; // 0/2047 to 2047/2047
811 UINT y : 11; // 0/2047 to 2047/2047
812 UINT z : 10; // 0/1023 to 1023/1023
820 explicit _XMUHENDN3(UINT Packed) : v(Packed) {};
821 _XMUHENDN3(FLOAT _x, FLOAT _y, FLOAT _z);
822 explicit _XMUHENDN3(_In_count_c_(3) CONST FLOAT *pArray);
824 operator UINT () const { return v; }
826 _XMUHENDN3& operator= (CONST _XMUHENDN3& UHenDN3);
827 _XMUHENDN3& operator= (CONST UINT Packed);
829 #endif // __cplusplus
833 // 3D Vector; 11-11-10 bit components packed into a 32 bit integer
834 // The 3D Vector is packed into 32 bits as follows: a 10 bit unsigned
835 // integer for the z component and 11 bit unsigned integers
836 // for the x and y components. The z component is stored in the
837 // most significant bits and the x component in the least significant bits
838 // (Z10Y11X11): [32] zzzzzzzz zzyyyyyy yyyyyxxx xxxxxxxx [0]
839 typedef struct _XMUHEND3
845 UINT x : 11; // 0 to 2047
846 UINT y : 11; // 0 to 2047
847 UINT z : 10; // 0 to 1023
855 explicit _XMUHEND3(UINT Packed) : v(Packed) {};
856 _XMUHEND3(FLOAT _x, FLOAT _y, FLOAT _z);
857 explicit _XMUHEND3(_In_count_c_(3) CONST FLOAT *pArray);
859 operator UINT () const { return v; }
861 _XMUHEND3& operator= (CONST _XMUHEND3& UHenD3);
862 _XMUHEND3& operator= (CONST UINT Packed);
864 #endif // __cplusplus
868 // 3D Vector; 10-11-11 bit normalized components packed into a 32 bit integer
869 // The normalized 3D Vector is packed into 32 bits as follows: a 10 bit signed,
870 // normalized integer for the x component and 11 bit signed, normalized
871 // integers for the y and z components. The z component is stored in the
872 // most significant bits and the x component in the least significant bits
873 // (Z11Y11X10): [32] zzzzzzzz zzzyyyyy yyyyyyxx xxxxxxxx [0]
874 typedef struct _XMDHENN3
880 INT x : 10; // -511/511 to 511/511
881 INT y : 11; // -1023/1023 to 1023/1023
882 INT z : 11; // -1023/1023 to 1023/1023
890 explicit _XMDHENN3(UINT Packed) : v(Packed) {};
891 _XMDHENN3(FLOAT _x, FLOAT _y, FLOAT _z);
892 explicit _XMDHENN3(_In_count_c_(3) CONST FLOAT *pArray);
894 operator UINT () const { return v; }
896 _XMDHENN3& operator= (CONST _XMDHENN3& DHenN3);
897 _XMDHENN3& operator= (CONST UINT Packed);
899 #endif // __cplusplus
903 // 3D Vector; 10-11-11 bit components packed into a 32 bit integer
904 // The 3D Vector is packed into 32 bits as follows: a 10 bit signed,
905 // integer for the x component and 11 bit signed integers for the
906 // y and z components. The w component is stored in the
907 // most significant bits and the x component in the least significant bits
908 // (Z11Y11X10): [32] zzzzzzzz zzzyyyyy yyyyyyxx xxxxxxxx [0]
909 typedef struct _XMDHEN3
915 INT x : 10; // -511 to 511
916 INT y : 11; // -1023 to 1023
917 INT z : 11; // -1023 to 1023
925 explicit _XMDHEN3(UINT Packed) : v(Packed) {};
926 _XMDHEN3(FLOAT _x, FLOAT _y, FLOAT _z);
927 explicit _XMDHEN3(_In_count_c_(3) CONST FLOAT *pArray);
929 operator UINT () const { return v; }
931 _XMDHEN3& operator= (CONST _XMDHEN3& DHen3);
932 _XMDHEN3& operator= (CONST UINT Packed);
934 #endif // __cplusplus
938 // 3D Vector; 10-11-11 bit normalized components packed into a 32 bit integer
939 // The normalized 3D Vector is packed into 32 bits as follows: a 10 bit unsigned,
940 // normalized integer for the x component and 11 bit unsigned, normalized
941 // integers for the y and z components. The w component is stored in the
942 // most significant bits and the x component in the least significant bits
943 // (Z11Y11X10): [32] zzzzzzzz zzzyyyyy yyyyyyxx xxxxxxxx [0]
944 typedef struct _XMUDHENN3
950 UINT x : 10; // 0/1023 to 1023/1023
951 UINT y : 11; // 0/2047 to 2047/2047
952 UINT z : 11; // 0/2047 to 2047/2047
960 explicit _XMUDHENN3(UINT Packed) : v(Packed) {};
961 _XMUDHENN3(FLOAT _x, FLOAT _y, FLOAT _z);
962 explicit _XMUDHENN3(_In_count_c_(3) CONST FLOAT *pArray);
964 operator UINT () const { return v; }
966 _XMUDHENN3& operator= (CONST _XMUDHENN3& UDHenN3);
967 _XMUDHENN3& operator= (CONST UINT Packed);
969 #endif // __cplusplus
973 // 3D Vector; 10-11-11 bit components packed into a 32 bit integer
974 // The 3D Vector is packed into 32 bits as follows: a 10 bit unsigned,
975 // integer for the x component and 11 bit unsigned integers
976 // for the y and z components. The w component is stored in the
977 // most significant bits and the x component in the least significant bits
978 // (Z11Y11X10): [32] zzzzzzzz zzzyyyyy yyyyyyxx xxxxxxxx [0]
979 typedef struct _XMUDHEN3
985 UINT x : 10; // 0 to 1023
986 UINT y : 11; // 0 to 2047
987 UINT z : 11; // 0 to 2047
995 explicit _XMUDHEN3(UINT Packed) : v(Packed) {};
996 _XMUDHEN3(FLOAT _x, FLOAT _y, FLOAT _z);
997 explicit _XMUDHEN3(_In_count_c_(3) CONST FLOAT *pArray);
999 operator UINT () const { return v; }
1001 _XMUDHEN3& operator= (CONST _XMUDHEN3& UDHen3);
1002 _XMUDHEN3& operator= (CONST UINT Packed);
1004 #endif // __cplusplus
1008 //------------------------------------------------------------------------------
1009 // 3D vector: 5/6/5 unsigned integer components
1010 typedef struct _XMU565
1026 explicit _XMU565(USHORT Packed) : v(Packed) {};
1027 _XMU565(CHAR _x, CHAR _y, CHAR _z) : x(_x), y(_y), z(_z) {};
1028 explicit _XMU565(_In_count_c_(3) CONST CHAR *pArray);
1029 _XMU565(FLOAT _x, FLOAT _y, FLOAT _z);
1030 explicit _XMU565(_In_count_c_(3) CONST FLOAT *pArray);
1032 operator USHORT () const { return v; }
1034 _XMU565& operator= (CONST _XMU565& U565);
1035 _XMU565& operator= (CONST USHORT Packed);
1037 #endif // __cplusplus
1041 //------------------------------------------------------------------------------
1042 // 3D vector: 11/11/10 floating-point components
1043 // The 3D vector is packed into 32 bits as follows: a 5-bit biased exponent
1044 // and 6-bit mantissa for x component, a 5-bit biased exponent and
1045 // 6-bit mantissa for y component, a 5-bit biased exponent and a 5-bit
1046 // mantissa for z. The z component is stored in the most significant bits
1047 // and the x component in the least significant bits. No sign bits so
1048 // all partial-precision numbers are positive.
1049 // (Z10Y11X11): [32] ZZZZZzzz zzzYYYYY yyyyyyXX XXXxxxxx [0]
1050 typedef struct _XMFLOAT3PK
1069 explicit _XMFLOAT3PK(UINT Packed) : v(Packed) {};
1070 _XMFLOAT3PK(FLOAT _x, FLOAT _y, FLOAT _z);
1071 explicit _XMFLOAT3PK(_In_count_c_(3) CONST FLOAT *pArray);
1073 operator UINT () const { return v; }
1075 _XMFLOAT3PK& operator= (CONST _XMFLOAT3PK& float3pk);
1076 _XMFLOAT3PK& operator= (CONST UINT Packed);
1078 #endif // __cplusplus
1082 //------------------------------------------------------------------------------
1083 // 3D vector: 9/9/9 floating-point components with shared 5-bit exponent
1084 // The 3D vector is packed into 32 bits as follows: a 5-bit biased exponent
1085 // with 9-bit mantissa for the x, y, and z component. The shared exponent
1086 // is stored in the most significant bits and the x component mantissa is in
1087 // the least significant bits. No sign bits so all partial-precision numbers
1089 // (E5Z9Y9X9): [32] EEEEEzzz zzzzzzyy yyyyyyyx xxxxxxxx [0]
1090 typedef struct _XMFLOAT3SE
1107 explicit _XMFLOAT3SE(UINT Packed) : v(Packed) {};
1108 _XMFLOAT3SE(FLOAT _x, FLOAT _y, FLOAT _z);
1109 explicit _XMFLOAT3SE(_In_count_c_(3) CONST FLOAT *pArray);
1111 operator UINT () const { return v; }
1113 _XMFLOAT3SE& operator= (CONST _XMFLOAT3SE& float3se);
1114 _XMFLOAT3SE& operator= (CONST UINT Packed);
1116 #endif // __cplusplus
1120 //------------------------------------------------------------------------------
1121 // 4D Vector; 32 bit floating point components
1122 typedef struct _XMFLOAT4
1132 _XMFLOAT4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w) : x(_x), y(_y), z(_z), w(_w) {};
1133 _XMFLOAT4(_In_count_c_(4) CONST FLOAT *pArray);
1135 _XMFLOAT4& operator= (CONST _XMFLOAT4& Float4);
1137 #endif // __cplusplus
1141 // 4D Vector; 32 bit floating point components aligned on a 16 byte boundary
1143 __declspec(align(16)) struct XMFLOAT4A : public XMFLOAT4
1145 XMFLOAT4A() : XMFLOAT4() {};
1146 XMFLOAT4A(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w) : XMFLOAT4(_x, _y, _z, _w) {};
1147 XMFLOAT4A(_In_count_c_(4) CONST FLOAT *pArray) : XMFLOAT4(pArray) {};
1149 XMFLOAT4A& operator= (CONST XMFLOAT4A& Float4);
1152 typedef __declspec(align(16)) XMFLOAT4 XMFLOAT4A;
1153 #endif // __cplusplus
1155 //------------------------------------------------------------------------------
1156 // 4D Vector; 32 bit signed integer components
1157 typedef struct _XMINT4
1167 _XMINT4(INT _x, INT _y, INT _z, INT _w) : x(_x), y(_y), z(_z), w(_w) {};
1168 explicit _XMINT4(_In_count_c_(4) CONST INT *pArray);
1170 _XMINT4& operator= (CONST _XMINT4& Int4);
1172 #endif // __cplusplus
1176 // 4D Vector; 32 bit unsigned integer components
1177 typedef struct _XMUINT4
1187 _XMUINT4(UINT _x, UINT _y, UINT _z, UINT _w) : x(_x), y(_y), z(_z), w(_w) {};
1188 explicit _XMUINT4(_In_count_c_(4) CONST UINT *pArray);
1190 _XMUINT4& operator= (CONST _XMUINT4& UInt4);
1192 #endif // __cplusplus
1196 //------------------------------------------------------------------------------
1197 // 4D Vector; 16 bit floating point components
1198 typedef struct _XMHALF4
1208 _XMHALF4(HALF _x, HALF _y, HALF _z, HALF _w) : x(_x), y(_y), z(_z), w(_w) {};
1209 explicit _XMHALF4(_In_count_c_(4) CONST HALF *pArray);
1210 _XMHALF4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
1211 explicit _XMHALF4(_In_count_c_(4) CONST FLOAT *pArray);
1213 _XMHALF4& operator= (CONST _XMHALF4& Half4);
1215 #endif // __cplusplus
1219 //------------------------------------------------------------------------------
1220 // 4D Vector; 16 bit signed normalized integer components
1221 typedef struct _XMSHORTN4
1231 _XMSHORTN4(SHORT _x, SHORT _y, SHORT _z, SHORT _w) : x(_x), y(_y), z(_z), w(_w) {};
1232 explicit _XMSHORTN4(_In_count_c_(4) CONST SHORT *pArray);
1233 _XMSHORTN4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
1234 explicit _XMSHORTN4(_In_count_c_(4) CONST FLOAT *pArray);
1236 _XMSHORTN4& operator= (CONST _XMSHORTN4& ShortN4);
1238 #endif // __cplusplus
1242 // 4D Vector; 16 bit signed integer components
1243 typedef struct _XMSHORT4
1253 _XMSHORT4(SHORT _x, SHORT _y, SHORT _z, SHORT _w) : x(_x), y(_y), z(_z), w(_w) {};
1254 explicit _XMSHORT4(_In_count_c_(4) CONST SHORT *pArray);
1255 _XMSHORT4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
1256 explicit _XMSHORT4(_In_count_c_(4) CONST FLOAT *pArray);
1258 _XMSHORT4& operator= (CONST _XMSHORT4& Short4);
1260 #endif // __cplusplus
1264 // 4D Vector; 16 bit unsigned normalized integer components
1265 typedef struct _XMUSHORTN4
1275 _XMUSHORTN4(USHORT _x, USHORT _y, USHORT _z, USHORT _w) : x(_x), y(_y), z(_z), w(_w) {};
1276 explicit _XMUSHORTN4(_In_count_c_(4) CONST USHORT *pArray);
1277 _XMUSHORTN4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
1278 explicit _XMUSHORTN4(_In_count_c_(4) CONST FLOAT *pArray);
1280 _XMUSHORTN4& operator= (CONST _XMUSHORTN4& UShortN4);
1282 #endif // __cplusplus
1286 // 4D Vector; 16 bit unsigned integer components
1287 typedef struct _XMUSHORT4
1297 _XMUSHORT4(USHORT _x, USHORT _y, USHORT _z, USHORT _w) : x(_x), y(_y), z(_z), w(_w) {};
1298 explicit _XMUSHORT4(_In_count_c_(4) CONST USHORT *pArray);
1299 _XMUSHORT4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
1300 explicit _XMUSHORT4(_In_count_c_(4) CONST FLOAT *pArray);
1302 _XMUSHORT4& operator= (CONST _XMUSHORT4& UShort4);
1304 #endif // __cplusplus
1308 //------------------------------------------------------------------------------
1309 // 4D Vector; 10-10-10-2 bit normalized components packed into a 32 bit integer
1310 // The normalized 4D Vector is packed into 32 bits as follows: a 2 bit unsigned,
1311 // normalized integer for the w component and 10 bit signed, normalized
1312 // integers for the z, y, and x components. The w component is stored in the
1313 // most significant bits and the x component in the least significant bits
1314 // (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
1315 typedef struct _XMXDECN4
1321 INT x : 10; // -511/511 to 511/511
1322 INT y : 10; // -511/511 to 511/511
1323 INT z : 10; // -511/511 to 511/511
1324 UINT w : 2; // 0/3 to 3/3
1332 explicit _XMXDECN4(UINT Packed) : v(Packed) {};
1333 _XMXDECN4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
1334 explicit _XMXDECN4(_In_count_c_(4) CONST FLOAT *pArray);
1336 operator UINT () const { return v; }
1338 _XMXDECN4& operator= (CONST _XMXDECN4& XDecN4);
1339 _XMXDECN4& operator= (CONST UINT Packed);
1341 #endif // __cplusplus
1345 // 4D Vector; 10-10-10-2 bit components packed into a 32 bit integer
1346 // The normalized 4D Vector is packed into 32 bits as follows: a 2 bit unsigned
1347 // integer for the w component and 10 bit signed integers for the
1348 // z, y, and x components. The w component is stored in the
1349 // most significant bits and the x component in the least significant bits
1350 // (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
1351 typedef struct _XMXDEC4
1357 INT x : 10; // -511 to 511
1358 INT y : 10; // -511 to 511
1359 INT z : 10; // -511 to 511
1360 UINT w : 2; // 0 to 3
1368 explicit _XMXDEC4(UINT Packed) : v(Packed) {};
1369 _XMXDEC4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
1370 explicit _XMXDEC4(_In_count_c_(4) CONST FLOAT *pArray);
1372 operator UINT () const { return v; }
1374 _XMXDEC4& operator= (CONST _XMXDEC4& XDec4);
1375 _XMXDEC4& operator= (CONST UINT Packed);
1377 #endif // __cplusplus
1381 // 4D Vector; 10-10-10-2 bit normalized components packed into a 32 bit integer
1382 // The normalized 4D Vector is packed into 32 bits as follows: a 2 bit signed,
1383 // normalized integer for the w component and 10 bit signed, normalized
1384 // integers for the z, y, and x components. The w component is stored in the
1385 // most significant bits and the x component in the least significant bits
1386 // (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
1387 typedef struct _XMDECN4
1393 INT x : 10; // -511/511 to 511/511
1394 INT y : 10; // -511/511 to 511/511
1395 INT z : 10; // -511/511 to 511/511
1396 INT w : 2; // -1/1 to 1/1
1404 explicit _XMDECN4(UINT Packed) : v(Packed) {};
1405 _XMDECN4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
1406 explicit _XMDECN4(_In_count_c_(4) CONST FLOAT *pArray);
1408 operator UINT () const { return v; }
1410 _XMDECN4& operator= (CONST _XMDECN4& DecN4);
1411 _XMDECN4& operator= (CONST UINT Packed);
1413 #endif // __cplusplus
1417 // 4D Vector; 10-10-10-2 bit components packed into a 32 bit integer
1418 // The 4D Vector is packed into 32 bits as follows: a 2 bit signed,
1419 // integer for the w component and 10 bit signed integers for the
1420 // z, y, and x components. The w component is stored in the
1421 // most significant bits and the x component in the least significant bits
1422 // (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
1423 typedef struct _XMDEC4
1429 INT x : 10; // -511 to 511
1430 INT y : 10; // -511 to 511
1431 INT z : 10; // -511 to 511
1432 INT w : 2; // -1 to 1
1440 explicit _XMDEC4(UINT Packed) : v(Packed) {};
1441 _XMDEC4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
1442 explicit _XMDEC4(_In_count_c_(4) CONST FLOAT *pArray);
1444 operator UINT () const { return v; }
1446 _XMDEC4& operator= (CONST _XMDEC4& Dec4);
1447 _XMDEC4& operator= (CONST UINT Packed);
1449 #endif // __cplusplus
1453 // 4D Vector; 10-10-10-2 bit normalized components packed into a 32 bit integer
1454 // The normalized 4D Vector is packed into 32 bits as follows: a 2 bit unsigned,
1455 // normalized integer for the w component and 10 bit unsigned, normalized
1456 // integers for the z, y, and x components. The w component is stored in the
1457 // most significant bits and the x component in the least significant bits
1458 // (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
1459 typedef struct _XMUDECN4
1465 UINT x : 10; // 0/1023 to 1023/1023
1466 UINT y : 10; // 0/1023 to 1023/1023
1467 UINT z : 10; // 0/1023 to 1023/1023
1468 UINT w : 2; // 0/3 to 3/3
1476 explicit _XMUDECN4(UINT Packed) : v(Packed) {};
1477 _XMUDECN4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
1478 explicit _XMUDECN4(_In_count_c_(4) CONST FLOAT *pArray);
1480 operator UINT () const { return v; }
1482 _XMUDECN4& operator= (CONST _XMUDECN4& UDecN4);
1483 _XMUDECN4& operator= (CONST UINT Packed);
1485 #endif // __cplusplus
1489 // 4D Vector; 10-10-10-2 bit components packed into a 32 bit integer
1490 // The 4D Vector is packed into 32 bits as follows: a 2 bit unsigned,
1491 // integer for the w component and 10 bit unsigned integers
1492 // for the z, y, and x components. The w component is stored in the
1493 // most significant bits and the x component in the least significant bits
1494 // (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
1495 typedef struct _XMUDEC4
1501 UINT x : 10; // 0 to 1023
1502 UINT y : 10; // 0 to 1023
1503 UINT z : 10; // 0 to 1023
1504 UINT w : 2; // 0 to 3
1512 explicit _XMUDEC4(UINT Packed) : v(Packed) {};
1513 _XMUDEC4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
1514 explicit _XMUDEC4(_In_count_c_(4) CONST FLOAT *pArray);
1516 operator UINT () const { return v; }
1518 _XMUDEC4& operator= (CONST _XMUDEC4& UDec4);
1519 _XMUDEC4& operator= (CONST UINT Packed);
1521 #endif // __cplusplus
1525 //------------------------------------------------------------------------------
1526 // 4D Vector; 20-20-20-4 bit normalized components packed into a 64 bit integer
1527 // The normalized 4D Vector is packed into 64 bits as follows: a 4 bit unsigned,
1528 // normalized integer for the w component and 20 bit signed, normalized
1529 // integers for the z, y, and x components. The w component is stored in the
1530 // most significant bits and the x component in the least significant bits
1531 // (W4Z20Y20X20): [64] wwwwzzzz zzzzzzzz zzzzzzzz yyyyyyyy yyyyyyyy yyyyxxxx xxxxxxxx xxxxxxxx [0]
1532 typedef struct _XMXICON4
1538 INT64 x : 20; // -524287/524287 to 524287/524287
1539 INT64 y : 20; // -524287/524287 to 524287/524287
1540 INT64 z : 20; // -524287/524287 to 524287/524287
1541 UINT64 w : 4; // 0/15 to 15/15
1549 explicit _XMXICON4(UINT64 Packed) : v(Packed) {};
1550 _XMXICON4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
1551 explicit _XMXICON4(_In_count_c_(4) CONST FLOAT *pArray);
1553 operator UINT64 () const { return v; }
1555 _XMXICON4& operator= (CONST _XMXICON4& XIcoN4);
1556 _XMXICON4& operator= (CONST UINT64 Packed);
1558 #endif // __cplusplus
1562 // 4D Vector; 20-20-20-4 bit components packed into a 64 bit integer
1563 // The 4D Vector is packed into 64 bits as follows: a 4 bit unsigned
1564 // integer for the w component and 20 bit signed integers for the
1565 // z, y, and x components. The w component is stored in the
1566 // most significant bits and the x component in the least significant bits
1567 // (W4Z20Y20X20): [64] wwwwzzzz zzzzzzzz zzzzzzzz yyyyyyyy yyyyyyyy yyyyxxxx xxxxxxxx xxxxxxxx [0]
1568 typedef struct _XMXICO4
1574 INT64 x : 20; // -524287 to 524287
1575 INT64 y : 20; // -524287 to 524287
1576 INT64 z : 20; // -524287 to 524287
1577 UINT64 w : 4; // 0 to 15
1585 explicit _XMXICO4(UINT64 Packed) : v(Packed) {};
1586 _XMXICO4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
1587 explicit _XMXICO4(_In_count_c_(4) CONST FLOAT *pArray);
1589 operator UINT64 () const { return v; }
1591 _XMXICO4& operator= (CONST _XMXICO4& XIco4);
1592 _XMXICO4& operator= (CONST UINT64 Packed);
1594 #endif // __cplusplus
1598 // 4D Vector; 20-20-20-4 bit normalized components packed into a 64 bit integer
1599 // The normalized 4D Vector is packed into 64 bits as follows: a 4 bit signed,
1600 // normalized integer for the w component and 20 bit signed, normalized
1601 // integers for the z, y, and x components. The w component is stored in the
1602 // most significant bits and the x component in the least significant bits
1603 // (W4Z20Y20X20): [64] wwwwzzzz zzzzzzzz zzzzzzzz yyyyyyyy yyyyyyyy yyyyxxxx xxxxxxxx xxxxxxxx [0]
1604 typedef struct _XMICON4
1610 INT64 x : 20; // -524287/524287 to 524287/524287
1611 INT64 y : 20; // -524287/524287 to 524287/524287
1612 INT64 z : 20; // -524287/524287 to 524287/524287
1613 INT64 w : 4; // -7/7 to 7/7
1621 explicit _XMICON4(UINT64 Packed) : v(Packed) {};
1622 _XMICON4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
1623 explicit _XMICON4(_In_count_c_(4) CONST FLOAT *pArray);
1625 operator UINT64 () const { return v; }
1627 _XMICON4& operator= (CONST _XMICON4& IcoN4);
1628 _XMICON4& operator= (CONST UINT64 Packed);
1630 #endif // __cplusplus
1634 // 4D Vector; 20-20-20-4 bit components packed into a 64 bit integer
1635 // The 4D Vector is packed into 64 bits as follows: a 4 bit signed,
1636 // integer for the w component and 20 bit signed integers for the
1637 // z, y, and x components. The w component is stored in the
1638 // most significant bits and the x component in the least significant bits
1639 // (W4Z20Y20X20): [64] wwwwzzzz zzzzzzzz zzzzzzzz yyyyyyyy yyyyyyyy yyyyxxxx xxxxxxxx xxxxxxxx [0]
1640 typedef struct _XMICO4
1646 INT64 x : 20; // -524287 to 524287
1647 INT64 y : 20; // -524287 to 524287
1648 INT64 z : 20; // -524287 to 524287
1649 INT64 w : 4; // -7 to 7
1657 explicit _XMICO4(UINT64 Packed) : v(Packed) {};
1658 _XMICO4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
1659 explicit _XMICO4(_In_count_c_(4) CONST FLOAT *pArray);
1661 operator UINT64 () const { return v; }
1663 _XMICO4& operator= (CONST _XMICO4& Ico4);
1664 _XMICO4& operator= (CONST UINT64 Packed);
1666 #endif // __cplusplus
1670 // 4D Vector; 20-20-20-4 bit normalized components packed into a 64 bit integer
1671 // The normalized 4D Vector is packed into 64 bits as follows: a 4 bit unsigned,
1672 // normalized integer for the w component and 20 bit unsigned, normalized
1673 // integers for the z, y, and x components. The w component is stored in the
1674 // most significant bits and the x component in the least significant bits
1675 // (W4Z20Y20X20): [64] wwwwzzzz zzzzzzzz zzzzzzzz yyyyyyyy yyyyyyyy yyyyxxxx xxxxxxxx xxxxxxxx [0]
1676 typedef struct _XMUICON4
1682 UINT64 x : 20; // 0/1048575 to 1048575/1048575
1683 UINT64 y : 20; // 0/1048575 to 1048575/1048575
1684 UINT64 z : 20; // 0/1048575 to 1048575/1048575
1685 UINT64 w : 4; // 0/15 to 15/15
1693 explicit _XMUICON4(UINT64 Packed) : v(Packed) {};
1694 _XMUICON4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
1695 explicit _XMUICON4(_In_count_c_(4) CONST FLOAT *pArray);
1697 operator UINT64 () const { return v; }
1699 _XMUICON4& operator= (CONST _XMUICON4& UIcoN4);
1700 _XMUICON4& operator= (CONST UINT64 Packed);
1702 #endif // __cplusplus
1706 // 4D Vector; 20-20-20-4 bit components packed into a 64 bit integer
1707 // The 4D Vector is packed into 64 bits as follows: a 4 bit unsigned
1708 // integer for the w component and 20 bit unsigned integers for the
1709 // z, y, and x components. The w component is stored in the
1710 // most significant bits and the x component in the least significant bits
1711 // (W4Z20Y20X20): [64] wwwwzzzz zzzzzzzz zzzzzzzz yyyyyyyy yyyyyyyy yyyyxxxx xxxxxxxx xxxxxxxx [0]
1712 typedef struct _XMUICO4
1718 UINT64 x : 20; // 0 to 1048575
1719 UINT64 y : 20; // 0 to 1048575
1720 UINT64 z : 20; // 0 to 1048575
1721 UINT64 w : 4; // 0 to 15
1729 explicit _XMUICO4(UINT64 Packed) : v(Packed) {};
1730 _XMUICO4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
1731 explicit _XMUICO4(_In_count_c_(4) CONST FLOAT *pArray);
1733 operator UINT64 () const { return v; }
1735 _XMUICO4& operator= (CONST _XMUICO4& UIco4);
1736 _XMUICO4& operator= (CONST UINT64 Packed);
1738 #endif // __cplusplus
1742 //------------------------------------------------------------------------------
1743 // ARGB Color; 8-8-8-8 bit unsigned normalized integer components packed into
1744 // a 32 bit integer. The normalized color is packed into 32 bits using 8 bit
1745 // unsigned, normalized integers for the alpha, red, green, and blue components.
1746 // The alpha component is stored in the most significant bits and the blue
1747 // component in the least significant bits (A8R8G8B8):
1748 // [32] aaaaaaaa rrrrrrrr gggggggg bbbbbbbb [0]
1749 typedef struct _XMCOLOR
1755 UINT b : 8; // Blue: 0/255 to 255/255
1756 UINT g : 8; // Green: 0/255 to 255/255
1757 UINT r : 8; // Red: 0/255 to 255/255
1758 UINT a : 8; // Alpha: 0/255 to 255/255
1766 _XMCOLOR(UINT Color) : c(Color) {};
1767 _XMCOLOR(FLOAT _r, FLOAT _g, FLOAT _b, FLOAT _a);
1768 explicit _XMCOLOR(_In_count_c_(4) CONST FLOAT *pArray);
1770 operator UINT () const { return c; }
1772 _XMCOLOR& operator= (CONST _XMCOLOR& Color);
1773 _XMCOLOR& operator= (CONST UINT Color);
1775 #endif // __cplusplus
1779 //------------------------------------------------------------------------------
1780 // 4D Vector; 8 bit signed normalized integer components
1781 typedef struct _XMBYTEN4
1798 _XMBYTEN4(CHAR _x, CHAR _y, CHAR _z, CHAR _w) : x(_x), y(_y), z(_z), w(_w) {};
1799 explicit _XMBYTEN4(UINT Packed) : v(Packed) {};
1800 explicit _XMBYTEN4(_In_count_c_(4) CONST CHAR *pArray);
1801 _XMBYTEN4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
1802 explicit _XMBYTEN4(_In_count_c_(4) CONST FLOAT *pArray);
1804 _XMBYTEN4& operator= (CONST _XMBYTEN4& ByteN4);
1805 _XMBYTEN4& operator= (UINT Packed) { v = Packed; return *this; }
1807 #endif // __cplusplus
1811 // 4D Vector; 8 bit signed integer components
1812 typedef struct _XMBYTE4
1829 _XMBYTE4(CHAR _x, CHAR _y, CHAR _z, CHAR _w) : x(_x), y(_y), z(_z), w(_w) {};
1830 explicit _XMBYTE4(UINT Packed) : v(Packed) {};
1831 explicit _XMBYTE4(_In_count_c_(4) CONST CHAR *pArray);
1832 _XMBYTE4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
1833 explicit _XMBYTE4(_In_count_c_(4) CONST FLOAT *pArray);
1835 _XMBYTE4& operator= (CONST _XMBYTE4& Byte4);
1836 _XMBYTE4& operator= (UINT Packed) { v = Packed; return *this; }
1838 #endif // __cplusplus
1842 // 4D Vector; 8 bit unsigned normalized integer components
1843 typedef struct _XMUBYTEN4
1860 _XMUBYTEN4(BYTE _x, BYTE _y, BYTE _z, BYTE _w) : x(_x), y(_y), z(_z), w(_w) {};
1861 explicit _XMUBYTEN4(UINT Packed) : v(Packed) {};
1862 explicit _XMUBYTEN4(_In_count_c_(4) CONST BYTE *pArray);
1863 _XMUBYTEN4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
1864 explicit _XMUBYTEN4(_In_count_c_(4) CONST FLOAT *pArray);
1866 _XMUBYTEN4& operator= (CONST _XMUBYTEN4& UByteN4);
1867 _XMUBYTEN4& operator= (UINT Packed) { v = Packed; return *this; }
1869 #endif // __cplusplus
1873 // 4D Vector; 8 bit unsigned integer components
1874 typedef struct _XMUBYTE4
1891 _XMUBYTE4(BYTE _x, BYTE _y, BYTE _z, BYTE _w) : x(_x), y(_y), z(_z), w(_w) {};
1892 explicit _XMUBYTE4(UINT Packed) : v(Packed) {};
1893 explicit _XMUBYTE4(_In_count_c_(4) CONST BYTE *pArray);
1894 _XMUBYTE4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
1895 explicit _XMUBYTE4(_In_count_c_(4) CONST FLOAT *pArray);
1897 _XMUBYTE4& operator= (CONST _XMUBYTE4& UByte4);
1898 _XMUBYTE4& operator= (UINT Packed) { v = Packed; return *this; }
1900 #endif // __cplusplus
1904 //------------------------------------------------------------------------------
1905 // 4D vector; 4 bit unsigned integer components
1906 typedef struct _XMUNIBBLE4
1923 explicit _XMUNIBBLE4(USHORT Packed) : v(Packed) {};
1924 _XMUNIBBLE4(CHAR _x, CHAR _y, CHAR _z, CHAR _w) : x(_x), y(_y), z(_z), w(_w) {};
1925 explicit _XMUNIBBLE4(_In_count_c_(4) CONST CHAR *pArray);
1926 _XMUNIBBLE4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
1927 explicit _XMUNIBBLE4(_In_count_c_(4) CONST FLOAT *pArray);
1929 operator USHORT () const { return v; }
1931 _XMUNIBBLE4& operator= (CONST _XMUNIBBLE4& UNibble4);
1932 _XMUNIBBLE4& operator= (CONST USHORT Packed);
1934 #endif // __cplusplus
1938 //------------------------------------------------------------------------------
1939 // 4D vector: 5/5/5/1 unsigned integer components
1940 typedef struct _XMU555
1957 explicit _XMU555(USHORT Packed) : v(Packed) {};
1958 _XMU555(CHAR _x, CHAR _y, CHAR _z, BOOL _w) : x(_x), y(_y), z(_z), w(_w ? 0x1 : 0) {};
1959 _XMU555(_In_count_c_(3) CONST CHAR *pArray, BOOL _w);
1960 _XMU555(FLOAT _x, FLOAT _y, FLOAT _z, BOOL _w);
1961 _XMU555(_In_count_c_(3) CONST FLOAT *pArray, BOOL _w);
1963 operator USHORT () const { return v; }
1965 _XMU555& operator= (CONST _XMU555& U555);
1966 _XMU555& operator= (CONST USHORT Packed);
1968 #endif // __cplusplus
1972 //------------------------------------------------------------------------------
1973 // 3x3 Matrix: 32 bit floating point components
1974 typedef struct _XMFLOAT3X3
1980 FLOAT _11, _12, _13;
1981 FLOAT _21, _22, _23;
1982 FLOAT _31, _32, _33;
1990 _XMFLOAT3X3(FLOAT m00, FLOAT m01, FLOAT m02,
1991 FLOAT m10, FLOAT m11, FLOAT m12,
1992 FLOAT m20, FLOAT m21, FLOAT m22);
1993 explicit _XMFLOAT3X3(_In_count_c_(9) CONST FLOAT *pArray);
1995 FLOAT operator() (UINT Row, UINT Column) CONST { return m[Row][Column]; }
1996 FLOAT& operator() (UINT Row, UINT Column) { return m[Row][Column]; }
1998 _XMFLOAT3X3& operator= (CONST _XMFLOAT3X3& Float3x3);
2000 #endif // __cplusplus
2004 //------------------------------------------------------------------------------
2005 // 4x3 Matrix: 32 bit floating point components
2006 typedef struct _XMFLOAT4X3
2012 FLOAT _11, _12, _13;
2013 FLOAT _21, _22, _23;
2014 FLOAT _31, _32, _33;
2015 FLOAT _41, _42, _43;
2023 _XMFLOAT4X3(FLOAT m00, FLOAT m01, FLOAT m02,
2024 FLOAT m10, FLOAT m11, FLOAT m12,
2025 FLOAT m20, FLOAT m21, FLOAT m22,
2026 FLOAT m30, FLOAT m31, FLOAT m32);
2027 explicit _XMFLOAT4X3(_In_count_c_(12) CONST FLOAT *pArray);
2029 FLOAT operator() (UINT Row, UINT Column) CONST { return m[Row][Column]; }
2030 FLOAT& operator() (UINT Row, UINT Column) { return m[Row][Column]; }
2032 _XMFLOAT4X3& operator= (CONST _XMFLOAT4X3& Float4x3);
2034 #endif // __cplusplus
2038 // 4x3 Matrix: 32 bit floating point components aligned on a 16 byte boundary
2040 __declspec(align(16)) struct XMFLOAT4X3A : public XMFLOAT4X3
2042 XMFLOAT4X3A() : XMFLOAT4X3() {};
2043 XMFLOAT4X3A(FLOAT m00, FLOAT m01, FLOAT m02,
2044 FLOAT m10, FLOAT m11, FLOAT m12,
2045 FLOAT m20, FLOAT m21, FLOAT m22,
2046 FLOAT m30, FLOAT m31, FLOAT m32) :
2047 XMFLOAT4X3(m00,m01,m02,m10,m11,m12,m20,m21,m22,m30,m31,m32) {};
2048 explicit XMFLOAT4X3A(_In_count_c_(12) CONST FLOAT *pArray) : XMFLOAT4X3(pArray) {}
2050 FLOAT operator() (UINT Row, UINT Column) CONST { return m[Row][Column]; }
2051 FLOAT& operator() (UINT Row, UINT Column) { return m[Row][Column]; }
2053 XMFLOAT4X3A& operator= (CONST XMFLOAT4X3A& Float4x3);
2056 typedef __declspec(align(16)) XMFLOAT4X3 XMFLOAT4X3A;
2057 #endif // __cplusplus
2059 //------------------------------------------------------------------------------
2060 // 4x4 Matrix: 32 bit floating point components
2061 typedef struct _XMFLOAT4X4
2067 FLOAT _11, _12, _13, _14;
2068 FLOAT _21, _22, _23, _24;
2069 FLOAT _31, _32, _33, _34;
2070 FLOAT _41, _42, _43, _44;
2078 _XMFLOAT4X4(FLOAT m00, FLOAT m01, FLOAT m02, FLOAT m03,
2079 FLOAT m10, FLOAT m11, FLOAT m12, FLOAT m13,
2080 FLOAT m20, FLOAT m21, FLOAT m22, FLOAT m23,
2081 FLOAT m30, FLOAT m31, FLOAT m32, FLOAT m33);
2082 explicit _XMFLOAT4X4(_In_count_c_(16) CONST FLOAT *pArray);
2084 FLOAT operator() (UINT Row, UINT Column) CONST { return m[Row][Column]; }
2085 FLOAT& operator() (UINT Row, UINT Column) { return m[Row][Column]; }
2087 _XMFLOAT4X4& operator= (CONST _XMFLOAT4X4& Float4x4);
2089 #endif // __cplusplus
2093 // 4x4 Matrix: 32 bit floating point components aligned on a 16 byte boundary
2095 __declspec(align(16)) struct XMFLOAT4X4A : public XMFLOAT4X4
2097 XMFLOAT4X4A() : XMFLOAT4X4() {};
2098 XMFLOAT4X4A(FLOAT m00, FLOAT m01, FLOAT m02, FLOAT m03,
2099 FLOAT m10, FLOAT m11, FLOAT m12, FLOAT m13,
2100 FLOAT m20, FLOAT m21, FLOAT m22, FLOAT m23,
2101 FLOAT m30, FLOAT m31, FLOAT m32, FLOAT m33)
2102 : XMFLOAT4X4(m00,m01,m02,m03,m10,m11,m12,m13,m20,m21,m22,m23,m30,m31,m32,m33) {};
2103 explicit XMFLOAT4X4A(_In_count_c_(16) CONST FLOAT *pArray) : XMFLOAT4X4(pArray) {}
2105 FLOAT operator() (UINT Row, UINT Column) CONST { return m[Row][Column]; }
2106 FLOAT& operator() (UINT Row, UINT Column) { return m[Row][Column]; }
2108 XMFLOAT4X4A& operator= (CONST XMFLOAT4X4A& Float4x4);
2111 typedef __declspec(align(16)) XMFLOAT4X4 XMFLOAT4X4A;
2112 #endif // __cplusplus
2115 #ifdef _XM_BIGENDIAN_
2116 #pragma bitfield_order(pop)
2119 #pragma warning(pop)
2121 /****************************************************************************
2123 * Data conversion operations
2125 ****************************************************************************/
2127 #if !defined(_XM_NO_INTRINSICS_) && defined(_XM_VMX128_INTRINSICS_)
2129 XMVECTOR XMConvertVectorIntToFloat(FXMVECTOR VInt, UINT DivExponent);
2130 XMVECTOR XMConvertVectorFloatToInt(FXMVECTOR VFloat, UINT MulExponent);
2131 XMVECTOR XMConvertVectorUIntToFloat(FXMVECTOR VUInt, UINT DivExponent);
2132 XMVECTOR XMConvertVectorFloatToUInt(FXMVECTOR VFloat, UINT MulExponent);
2135 FLOAT XMConvertHalfToFloat(HALF Value);
2136 FLOAT* XMConvertHalfToFloatStream(_Out_bytecap_x_(sizeof(FLOAT)+OutputStride*(HalfCount-1)) FLOAT* pOutputStream,
2137 _In_ size_t OutputStride,
2138 _In_bytecount_x_(sizeof(HALF)+InputStride*(HalfCount-1)) CONST HALF* pInputStream,
2139 _In_ size_t InputStride, _In_ size_t HalfCount);
2140 HALF XMConvertFloatToHalf(FLOAT Value);
2141 HALF* XMConvertFloatToHalfStream(_Out_bytecap_x_(sizeof(HALF)+OutputStride*(FloatCount-1)) HALF* pOutputStream,
2142 _In_ size_t OutputStride,
2143 _In_bytecount_x_(sizeof(FLOAT)+InputStride*(FloatCount-1)) CONST FLOAT* pInputStream,
2144 _In_ size_t InputStride, _In_ size_t FloatCount);
2146 #if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_)
2147 XMVECTOR XMVectorSetBinaryConstant(UINT C0, UINT C1, UINT C2, UINT C3);
2148 XMVECTOR XMVectorSplatConstant(INT IntConstant, UINT DivExponent);
2149 XMVECTOR XMVectorSplatConstantInt(INT IntConstant);
2151 // VMX128 versions defined below as macros
2154 /****************************************************************************
2158 ****************************************************************************/
2160 XMVECTOR XMLoadInt(_In_ CONST UINT* pSource);
2161 XMVECTOR XMLoadFloat(_In_ CONST FLOAT* pSource);
2163 XMVECTOR XMLoadInt2(_In_count_c_(2) CONST UINT* pSource);
2164 XMVECTOR XMLoadInt2A(_In_count_c_(2) CONST UINT* PSource);
2165 XMVECTOR XMLoadFloat2(_In_ CONST XMFLOAT2* pSource);
2166 XMVECTOR XMLoadFloat2A(_In_ CONST XMFLOAT2A* pSource);
2167 XMVECTOR XMLoadSInt2(_In_ CONST XMINT2* pSource);
2168 XMVECTOR XMLoadUInt2(_In_ CONST XMUINT2* pSource);
2169 XMVECTOR XMLoadHalf2(_In_ CONST XMHALF2* pSource);
2170 XMVECTOR XMLoadShortN2(_In_ CONST XMSHORTN2* pSource);
2171 XMVECTOR XMLoadShort2(_In_ CONST XMSHORT2* pSource);
2172 XMVECTOR XMLoadUShortN2(_In_ CONST XMUSHORTN2* pSource);
2173 XMVECTOR XMLoadUShort2(_In_ CONST XMUSHORT2* pSource);
2174 XMVECTOR XMLoadByteN2(_In_ CONST XMBYTEN2* pSource);
2175 XMVECTOR XMLoadByte2(_In_ CONST XMBYTE2* pSource);
2176 XMVECTOR XMLoadUByteN2(_In_ CONST XMUBYTEN2* pSource);
2177 XMVECTOR XMLoadUByte2(_In_ CONST XMUBYTE2* pSource);
2179 XMVECTOR XMLoadInt3(_In_count_c_(3) CONST UINT* pSource);
2180 XMVECTOR XMLoadInt3A(_In_count_c_(3) CONST UINT* pSource);
2181 XMVECTOR XMLoadFloat3(_In_ CONST XMFLOAT3* pSource);
2182 XMVECTOR XMLoadFloat3A(_In_ CONST XMFLOAT3A* pSource);
2183 XMVECTOR XMLoadSInt3(_In_ CONST XMINT3* pSource);
2184 XMVECTOR XMLoadUInt3(_In_ CONST XMUINT3* pSource);
2185 XMVECTOR XMLoadHenDN3(_In_ CONST XMHENDN3* pSource);
2186 XMVECTOR XMLoadHenD3(_In_ CONST XMHEND3* pSource);
2187 XMVECTOR XMLoadUHenDN3(_In_ CONST XMUHENDN3* pSource);
2188 XMVECTOR XMLoadUHenD3(_In_ CONST XMUHEND3* pSource);
2189 XMVECTOR XMLoadDHenN3(_In_ CONST XMDHENN3* pSource);
2190 XMVECTOR XMLoadDHen3(_In_ CONST XMDHEN3* pSource);
2191 XMVECTOR XMLoadUDHenN3(_In_ CONST XMUDHENN3* pSource);
2192 XMVECTOR XMLoadUDHen3(_In_ CONST XMUDHEN3* pSource);
2193 XMVECTOR XMLoadU565(_In_ CONST XMU565* pSource);
2194 XMVECTOR XMLoadFloat3PK(_In_ CONST XMFLOAT3PK* pSource);
2195 XMVECTOR XMLoadFloat3SE(_In_ CONST XMFLOAT3SE* pSource);
2197 XMVECTOR XMLoadInt4(_In_count_c_(4) CONST UINT* pSource);
2198 XMVECTOR XMLoadInt4A(_In_count_c_(4) CONST UINT* pSource);
2199 XMVECTOR XMLoadFloat4(_In_ CONST XMFLOAT4* pSource);
2200 XMVECTOR XMLoadFloat4A(_In_ CONST XMFLOAT4A* pSource);
2201 XMVECTOR XMLoadSInt4(_In_ CONST XMINT4* pSource);
2202 XMVECTOR XMLoadUInt4(_In_ CONST XMUINT4* pSource);
2203 XMVECTOR XMLoadHalf4(_In_ CONST XMHALF4* pSource);
2204 XMVECTOR XMLoadShortN4(_In_ CONST XMSHORTN4* pSource);
2205 XMVECTOR XMLoadShort4(_In_ CONST XMSHORT4* pSource);
2206 XMVECTOR XMLoadUShortN4(_In_ CONST XMUSHORTN4* pSource);
2207 XMVECTOR XMLoadUShort4(_In_ CONST XMUSHORT4* pSource);
2208 XMVECTOR XMLoadXIcoN4(_In_ CONST XMXICON4* pSource);
2209 XMVECTOR XMLoadXIco4(_In_ CONST XMXICO4* pSource);
2210 XMVECTOR XMLoadIcoN4(_In_ CONST XMICON4* pSource);
2211 XMVECTOR XMLoadIco4(_In_ CONST XMICO4* pSource);
2212 XMVECTOR XMLoadUIcoN4(_In_ CONST XMUICON4* pSource);
2213 XMVECTOR XMLoadUIco4(_In_ CONST XMUICO4* pSource);
2214 XMVECTOR XMLoadXDecN4(_In_ CONST XMXDECN4* pSource);
2215 XMVECTOR XMLoadXDec4(_In_ CONST XMXDEC4* pSource);
2216 XMVECTOR XMLoadDecN4(_In_ CONST XMDECN4* pSource);
2217 XMVECTOR XMLoadDec4(_In_ CONST XMDEC4* pSource);
2218 XMVECTOR XMLoadUDecN4(_In_ CONST XMUDECN4* pSource);
2219 XMVECTOR XMLoadUDec4(_In_ CONST XMUDEC4* pSource);
2220 XMVECTOR XMLoadByteN4(_In_ CONST XMBYTEN4* pSource);
2221 XMVECTOR XMLoadByte4(_In_ CONST XMBYTE4* pSource);
2222 XMVECTOR XMLoadUByteN4(_In_ CONST XMUBYTEN4* pSource);
2223 XMVECTOR XMLoadUByte4(_In_ CONST XMUBYTE4* pSource);
2224 XMVECTOR XMLoadUNibble4(_In_ CONST XMUNIBBLE4* pSource);
2225 XMVECTOR XMLoadU555(_In_ CONST XMU555* pSource);
2226 XMVECTOR XMLoadColor(_In_ CONST XMCOLOR* pSource);
2228 XMMATRIX XMLoadFloat3x3(_In_ CONST XMFLOAT3X3* pSource);
2229 XMMATRIX XMLoadFloat4x3(_In_ CONST XMFLOAT4X3* pSource);
2230 XMMATRIX XMLoadFloat4x3A(_In_ CONST XMFLOAT4X3A* pSource);
2231 XMMATRIX XMLoadFloat4x4(_In_ CONST XMFLOAT4X4* pSource);
2232 XMMATRIX XMLoadFloat4x4A(_In_ CONST XMFLOAT4X4A* pSource);
2234 /****************************************************************************
2238 ****************************************************************************/
2240 VOID XMStoreInt(_Out_ UINT* pDestination, FXMVECTOR V);
2241 VOID XMStoreFloat(_Out_ FLOAT* pDestination, FXMVECTOR V);
2243 VOID XMStoreInt2(_Out_cap_c_(2) UINT* pDestination, FXMVECTOR V);
2244 VOID XMStoreInt2A(_Out_cap_c_(2) UINT* pDestination, FXMVECTOR V);
2245 VOID XMStoreFloat2(_Out_ XMFLOAT2* pDestination, FXMVECTOR V);
2246 VOID XMStoreFloat2A(_Out_ XMFLOAT2A* pDestination, FXMVECTOR V);
2247 VOID XMStoreSInt2(_Out_ XMINT2* pDestination, FXMVECTOR V);
2248 VOID XMStoreUInt2(_Out_ XMUINT2* pDestination, FXMVECTOR V);
2249 VOID XMStoreHalf2(_Out_ XMHALF2* pDestination, FXMVECTOR V);
2250 VOID XMStoreShortN2(_Out_ XMSHORTN2* pDestination, FXMVECTOR V);
2251 VOID XMStoreShort2(_Out_ XMSHORT2* pDestination, FXMVECTOR V);
2252 VOID XMStoreUShortN2(_Out_ XMUSHORTN2* pDestination, FXMVECTOR V);
2253 VOID XMStoreUShort2(_Out_ XMUSHORT2* pDestination, FXMVECTOR V);
2254 VOID XMStoreByteN2(_Out_ XMBYTEN2* pDestination, FXMVECTOR V);
2255 VOID XMStoreByte2(_Out_ XMBYTE2* pDestination, FXMVECTOR V);
2256 VOID XMStoreUByteN2(_Out_ XMUBYTEN2* pDestination, FXMVECTOR V);
2257 VOID XMStoreUByte2(_Out_ XMUBYTE2* pDestination, FXMVECTOR V);
2259 VOID XMStoreInt3(_Out_cap_c_(3) UINT* pDestination, FXMVECTOR V);
2260 VOID XMStoreInt3A(_Out_cap_c_(3) UINT* pDestination, FXMVECTOR V);
2261 VOID XMStoreFloat3(_Out_ XMFLOAT3* pDestination, FXMVECTOR V);
2262 VOID XMStoreFloat3A(_Out_ XMFLOAT3A* pDestination, FXMVECTOR V);
2263 VOID XMStoreSInt3(_Out_ XMINT3* pDestination, FXMVECTOR V);
2264 VOID XMStoreUInt3(_Out_ XMUINT3* pDestination, FXMVECTOR V);
2265 VOID XMStoreHenDN3(_Out_ XMHENDN3* pDestination, FXMVECTOR V);
2266 VOID XMStoreHenD3(_Out_ XMHEND3* pDestination, FXMVECTOR V);
2267 VOID XMStoreUHenDN3(_Out_ XMUHENDN3* pDestination, FXMVECTOR V);
2268 VOID XMStoreUHenD3(_Out_ XMUHEND3* pDestination, FXMVECTOR V);
2269 VOID XMStoreDHenN3(_Out_ XMDHENN3* pDestination, FXMVECTOR V);
2270 VOID XMStoreDHen3(_Out_ XMDHEN3* pDestination, FXMVECTOR V);
2271 VOID XMStoreUDHenN3(_Out_ XMUDHENN3* pDestination, FXMVECTOR V);
2272 VOID XMStoreUDHen3(_Out_ XMUDHEN3* pDestination, FXMVECTOR V);
2273 VOID XMStoreU565(_Out_ XMU565* pDestination, FXMVECTOR V);
2274 VOID XMStoreFloat3PK(_Out_ XMFLOAT3PK* pDestination, FXMVECTOR V);
2275 VOID XMStoreFloat3SE(_Out_ XMFLOAT3SE* pDestination, FXMVECTOR V);
2277 VOID XMStoreInt4(_Out_cap_c_(4) UINT* pDestination, FXMVECTOR V);
2278 VOID XMStoreInt4A(_Out_cap_c_(4) UINT* pDestination, FXMVECTOR V);
2279 VOID XMStoreInt4NC(_Out_cap_c_(4) UINT* pDestination, FXMVECTOR V);
2280 VOID XMStoreFloat4(_Out_ XMFLOAT4* pDestination, FXMVECTOR V);
2281 VOID XMStoreFloat4A(_Out_ XMFLOAT4A* pDestination, FXMVECTOR V);
2282 VOID XMStoreFloat4NC(_Out_ XMFLOAT4* pDestination, FXMVECTOR V);
2283 VOID XMStoreSInt4(_Out_ XMINT4* pDestination, FXMVECTOR V);
2284 VOID XMStoreUInt4(_Out_ XMUINT4* pDestination, FXMVECTOR V);
2285 VOID XMStoreHalf4(_Out_ XMHALF4* pDestination, FXMVECTOR V);
2286 VOID XMStoreShortN4(_Out_ XMSHORTN4* pDestination, FXMVECTOR V);
2287 VOID XMStoreShort4(_Out_ XMSHORT4* pDestination, FXMVECTOR V);
2288 VOID XMStoreUShortN4(_Out_ XMUSHORTN4* pDestination, FXMVECTOR V);
2289 VOID XMStoreUShort4(_Out_ XMUSHORT4* pDestination, FXMVECTOR V);
2290 VOID XMStoreXIcoN4(_Out_ XMXICON4* pDestination, FXMVECTOR V);
2291 VOID XMStoreXIco4(_Out_ XMXICO4* pDestination, FXMVECTOR V);
2292 VOID XMStoreIcoN4(_Out_ XMICON4* pDestination, FXMVECTOR V);
2293 VOID XMStoreIco4(_Out_ XMICO4* pDestination, FXMVECTOR V);
2294 VOID XMStoreUIcoN4(_Out_ XMUICON4* pDestination, FXMVECTOR V);
2295 VOID XMStoreUIco4(_Out_ XMUICO4* pDestination, FXMVECTOR V);
2296 VOID XMStoreXDecN4(_Out_ XMXDECN4* pDestination, FXMVECTOR V);
2297 VOID XMStoreXDec4(_Out_ XMXDEC4* pDestination, FXMVECTOR V);
2298 VOID XMStoreDecN4(_Out_ XMDECN4* pDestination, FXMVECTOR V);
2299 VOID XMStoreDec4(_Out_ XMDEC4* pDestination, FXMVECTOR V);
2300 VOID XMStoreUDecN4(_Out_ XMUDECN4* pDestination, FXMVECTOR V);
2301 VOID XMStoreUDec4(_Out_ XMUDEC4* pDestination, FXMVECTOR V);
2302 VOID XMStoreByteN4(_Out_ XMBYTEN4* pDestination, FXMVECTOR V);
2303 VOID XMStoreByte4(_Out_ XMBYTE4* pDestination, FXMVECTOR V);
2304 VOID XMStoreUByteN4(_Out_ XMUBYTEN4* pDestination, FXMVECTOR V);
2305 VOID XMStoreUByte4(_Out_ XMUBYTE4* pDestination, FXMVECTOR V);
2306 VOID XMStoreUNibble4(_Out_ XMUNIBBLE4* pDestination, FXMVECTOR V);
2307 VOID XMStoreU555(_Out_ XMU555* pDestination, FXMVECTOR V);
2308 VOID XMStoreColor(_Out_ XMCOLOR* pDestination, FXMVECTOR V);
2310 VOID XMStoreFloat3x3(_Out_ XMFLOAT3X3* pDestination, CXMMATRIX M);
2311 VOID XMStoreFloat3x3NC(_Out_ XMFLOAT3X3* pDestination, CXMMATRIX M);
2312 VOID XMStoreFloat4x3(_Out_ XMFLOAT4X3* pDestination, CXMMATRIX M);
2313 VOID XMStoreFloat4x3A(_Out_ XMFLOAT4X3A* pDestination, CXMMATRIX M);
2314 VOID XMStoreFloat4x3NC(_Out_ XMFLOAT4X3* pDestination, CXMMATRIX M);
2315 VOID XMStoreFloat4x4(_Out_ XMFLOAT4X4* pDestination, CXMMATRIX M);
2316 VOID XMStoreFloat4x4A(_Out_ XMFLOAT4X4A* pDestination, CXMMATRIX M);
2317 VOID XMStoreFloat4x4NC(_Out_ XMFLOAT4X4* pDestination, CXMMATRIX M);
2319 /****************************************************************************
2321 * General vector operations
2323 ****************************************************************************/
2325 XMVECTOR XMVectorZero();
2326 XMVECTOR XMVectorSet(FLOAT x, FLOAT y, FLOAT z, FLOAT w);
2327 XMVECTOR XMVectorSetInt(UINT x, UINT y, UINT z, UINT w);
2328 XMVECTOR XMVectorReplicate(FLOAT Value);
2329 XMVECTOR XMVectorReplicatePtr(_In_ CONST FLOAT *pValue);
2330 XMVECTOR XMVectorReplicateInt(UINT Value);
2331 XMVECTOR XMVectorReplicateIntPtr(_In_ CONST UINT *pValue);
2332 XMVECTOR XMVectorTrueInt();
2333 XMVECTOR XMVectorFalseInt();
2334 XMVECTOR XMVectorSplatX(FXMVECTOR V);
2335 XMVECTOR XMVectorSplatY(FXMVECTOR V);
2336 XMVECTOR XMVectorSplatZ(FXMVECTOR V);
2337 XMVECTOR XMVectorSplatW(FXMVECTOR V);
2338 XMVECTOR XMVectorSplatOne();
2339 XMVECTOR XMVectorSplatInfinity();
2340 XMVECTOR XMVectorSplatQNaN();
2341 XMVECTOR XMVectorSplatEpsilon();
2342 XMVECTOR XMVectorSplatSignMask();
2344 FLOAT XMVectorGetByIndex(FXMVECTOR V,UINT i);
2345 FLOAT XMVectorGetX(FXMVECTOR V);
2346 FLOAT XMVectorGetY(FXMVECTOR V);
2347 FLOAT XMVectorGetZ(FXMVECTOR V);
2348 FLOAT XMVectorGetW(FXMVECTOR V);
2350 VOID XMVectorGetByIndexPtr(_Out_ FLOAT *f, FXMVECTOR V, UINT i);
2351 VOID XMVectorGetXPtr(_Out_ FLOAT *x, FXMVECTOR V);
2352 VOID XMVectorGetYPtr(_Out_ FLOAT *y, FXMVECTOR V);
2353 VOID XMVectorGetZPtr(_Out_ FLOAT *z, FXMVECTOR V);
2354 VOID XMVectorGetWPtr(_Out_ FLOAT *w, FXMVECTOR V);
2356 UINT XMVectorGetIntByIndex(FXMVECTOR V,UINT i);
2357 UINT XMVectorGetIntX(FXMVECTOR V);
2358 UINT XMVectorGetIntY(FXMVECTOR V);
2359 UINT XMVectorGetIntZ(FXMVECTOR V);
2360 UINT XMVectorGetIntW(FXMVECTOR V);
2362 VOID XMVectorGetIntByIndexPtr(_Out_ UINT *x,FXMVECTOR V, UINT i);
2363 VOID XMVectorGetIntXPtr(_Out_ UINT *x, FXMVECTOR V);
2364 VOID XMVectorGetIntYPtr(_Out_ UINT *y, FXMVECTOR V);
2365 VOID XMVectorGetIntZPtr(_Out_ UINT *z, FXMVECTOR V);
2366 VOID XMVectorGetIntWPtr(_Out_ UINT *w, FXMVECTOR V);
2368 XMVECTOR XMVectorSetByIndex(FXMVECTOR V,FLOAT f,UINT i);
2369 XMVECTOR XMVectorSetX(FXMVECTOR V, FLOAT x);
2370 XMVECTOR XMVectorSetY(FXMVECTOR V, FLOAT y);
2371 XMVECTOR XMVectorSetZ(FXMVECTOR V, FLOAT z);
2372 XMVECTOR XMVectorSetW(FXMVECTOR V, FLOAT w);
2374 XMVECTOR XMVectorSetByIndexPtr(FXMVECTOR V, _In_ CONST FLOAT *f, UINT i);
2375 XMVECTOR XMVectorSetXPtr(FXMVECTOR V, _In_ CONST FLOAT *x);
2376 XMVECTOR XMVectorSetYPtr(FXMVECTOR V, _In_ CONST FLOAT *y);
2377 XMVECTOR XMVectorSetZPtr(FXMVECTOR V, _In_ CONST FLOAT *z);
2378 XMVECTOR XMVectorSetWPtr(FXMVECTOR V, _In_ CONST FLOAT *w);
2380 XMVECTOR XMVectorSetIntByIndex(FXMVECTOR V, UINT x,UINT i);
2381 XMVECTOR XMVectorSetIntX(FXMVECTOR V, UINT x);
2382 XMVECTOR XMVectorSetIntY(FXMVECTOR V, UINT y);
2383 XMVECTOR XMVectorSetIntZ(FXMVECTOR V, UINT z);
2384 XMVECTOR XMVectorSetIntW(FXMVECTOR V, UINT w);
2386 XMVECTOR XMVectorSetIntByIndexPtr(FXMVECTOR V, _In_ CONST UINT *x, UINT i);
2387 XMVECTOR XMVectorSetIntXPtr(FXMVECTOR V, _In_ CONST UINT *x);
2388 XMVECTOR XMVectorSetIntYPtr(FXMVECTOR V, _In_ CONST UINT *y);
2389 XMVECTOR XMVectorSetIntZPtr(FXMVECTOR V, _In_ CONST UINT *z);
2390 XMVECTOR XMVectorSetIntWPtr(FXMVECTOR V, _In_ CONST UINT *w);
2392 XMVECTOR XMVectorPermuteControl(UINT ElementIndex0, UINT ElementIndex1, UINT ElementIndex2, UINT ElementIndex3);
2393 XMVECTOR XMVectorPermute(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR Control);
2394 XMVECTOR XMVectorSelectControl(UINT VectorIndex0, UINT VectorIndex1, UINT VectorIndex2, UINT VectorIndex3);
2395 XMVECTOR XMVectorSelect(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR Control);
2396 XMVECTOR XMVectorMergeXY(FXMVECTOR V1, FXMVECTOR V2);
2397 XMVECTOR XMVectorMergeZW(FXMVECTOR V1, FXMVECTOR V2);
2399 #if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_)
2400 XMVECTOR XMVectorShiftLeft(FXMVECTOR V1, FXMVECTOR V2, UINT Elements);
2401 XMVECTOR XMVectorRotateLeft(FXMVECTOR V, UINT Elements);
2402 XMVECTOR XMVectorRotateRight(FXMVECTOR V, UINT Elements);
2403 XMVECTOR XMVectorSwizzle(FXMVECTOR V, UINT E0, UINT E1, UINT E2, UINT E3);
2404 XMVECTOR XMVectorInsert(FXMVECTOR VD, FXMVECTOR VS, UINT VSLeftRotateElements,
2405 UINT Select0, UINT Select1, UINT Select2, UINT Select3);
2407 // VMX128 versions defined below as macros
2410 XMVECTOR XMVectorEqual(FXMVECTOR V1, FXMVECTOR V2);
2411 XMVECTOR XMVectorEqualR(_Out_ UINT* pCR, FXMVECTOR V1, FXMVECTOR V2);
2412 XMVECTOR XMVectorEqualInt(FXMVECTOR V1, FXMVECTOR V2);
2413 XMVECTOR XMVectorEqualIntR(_Out_ UINT* pCR, FXMVECTOR V, FXMVECTOR V2);
2414 XMVECTOR XMVectorNearEqual(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR Epsilon);
2415 XMVECTOR XMVectorNotEqual(FXMVECTOR V1, FXMVECTOR V2);
2416 XMVECTOR XMVectorNotEqualInt(FXMVECTOR V1, FXMVECTOR V2);
2417 XMVECTOR XMVectorGreater(FXMVECTOR V1, FXMVECTOR V2);
2418 XMVECTOR XMVectorGreaterR(_Out_ UINT* pCR, FXMVECTOR V1, FXMVECTOR V2);
2419 XMVECTOR XMVectorGreaterOrEqual(FXMVECTOR V1, FXMVECTOR V2);
2420 XMVECTOR XMVectorGreaterOrEqualR(_Out_ UINT* pCR, FXMVECTOR V1, FXMVECTOR V2);
2421 XMVECTOR XMVectorLess(FXMVECTOR V1, FXMVECTOR V2);
2422 XMVECTOR XMVectorLessOrEqual(FXMVECTOR V1, FXMVECTOR V2);
2423 XMVECTOR XMVectorInBounds(FXMVECTOR V, FXMVECTOR Bounds);
2424 XMVECTOR XMVectorInBoundsR(_Out_ UINT* pCR, FXMVECTOR V, FXMVECTOR Bounds);
2426 XMVECTOR XMVectorIsNaN(FXMVECTOR V);
2427 XMVECTOR XMVectorIsInfinite(FXMVECTOR V);
2429 XMVECTOR XMVectorMin(FXMVECTOR V1,FXMVECTOR V2);
2430 XMVECTOR XMVectorMax(FXMVECTOR V1, FXMVECTOR V2);
2431 XMVECTOR XMVectorRound(FXMVECTOR V);
2432 XMVECTOR XMVectorTruncate(FXMVECTOR V);
2433 XMVECTOR XMVectorFloor(FXMVECTOR V);
2434 XMVECTOR XMVectorCeiling(FXMVECTOR V);
2435 XMVECTOR XMVectorClamp(FXMVECTOR V, FXMVECTOR Min, FXMVECTOR Max);
2436 XMVECTOR XMVectorSaturate(FXMVECTOR V);
2438 XMVECTOR XMVectorAndInt(FXMVECTOR V1, FXMVECTOR V2);
2439 XMVECTOR XMVectorAndCInt(FXMVECTOR V1, FXMVECTOR V2);
2440 XMVECTOR XMVectorOrInt(FXMVECTOR V1, FXMVECTOR V2);
2441 XMVECTOR XMVectorNorInt(FXMVECTOR V1, FXMVECTOR V2);
2442 XMVECTOR XMVectorXorInt(FXMVECTOR V1, FXMVECTOR V2);
2444 XMVECTOR XMVectorNegate(FXMVECTOR V);
2445 XMVECTOR XMVectorAdd(FXMVECTOR V1, FXMVECTOR V2);
2446 XMVECTOR XMVectorAddAngles(FXMVECTOR V1, FXMVECTOR V2);
2447 XMVECTOR XMVectorSubtract(FXMVECTOR V1, FXMVECTOR V2);
2448 XMVECTOR XMVectorSubtractAngles(FXMVECTOR V1, FXMVECTOR V2);
2449 XMVECTOR XMVectorMultiply(FXMVECTOR V1, FXMVECTOR V2);
2450 XMVECTOR XMVectorMultiplyAdd(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR V3);
2451 XMVECTOR XMVectorDivide(FXMVECTOR V1, FXMVECTOR V2);
2452 XMVECTOR XMVectorNegativeMultiplySubtract(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR V3);
2453 XMVECTOR XMVectorScale(FXMVECTOR V, FLOAT ScaleFactor);
2454 XMVECTOR XMVectorReciprocalEst(FXMVECTOR V);
2455 XMVECTOR XMVectorReciprocal(FXMVECTOR V);
2456 XMVECTOR XMVectorSqrtEst(FXMVECTOR V);
2457 XMVECTOR XMVectorSqrt(FXMVECTOR V);
2458 XMVECTOR XMVectorReciprocalSqrtEst(FXMVECTOR V);
2459 XMVECTOR XMVectorReciprocalSqrt(FXMVECTOR V);
2460 XMVECTOR XMVectorExpEst(FXMVECTOR V);
2461 XMVECTOR XMVectorExp(FXMVECTOR V);
2462 XMVECTOR XMVectorLogEst(FXMVECTOR V);
2463 XMVECTOR XMVectorLog(FXMVECTOR V);
2464 XMVECTOR XMVectorPowEst(FXMVECTOR V1, FXMVECTOR V2);
2465 XMVECTOR XMVectorPow(FXMVECTOR V1, FXMVECTOR V2);
2466 XMVECTOR XMVectorAbs(FXMVECTOR V);
2467 XMVECTOR XMVectorMod(FXMVECTOR V1, FXMVECTOR V2);
2468 XMVECTOR XMVectorModAngles(FXMVECTOR Angles);
2469 XMVECTOR XMVectorSin(FXMVECTOR V);
2470 XMVECTOR XMVectorSinEst(FXMVECTOR V);
2471 XMVECTOR XMVectorCos(FXMVECTOR V);
2472 XMVECTOR XMVectorCosEst(FXMVECTOR V);
2473 VOID XMVectorSinCos(_Out_ XMVECTOR* pSin, _Out_ XMVECTOR* pCos, FXMVECTOR V);
2474 VOID XMVectorSinCosEst(_Out_ XMVECTOR* pSin, _Out_ XMVECTOR* pCos, FXMVECTOR V);
2475 XMVECTOR XMVectorTan(FXMVECTOR V);
2476 XMVECTOR XMVectorTanEst(FXMVECTOR V);
2477 XMVECTOR XMVectorSinH(FXMVECTOR V);
2478 XMVECTOR XMVectorSinHEst(FXMVECTOR V);
2479 XMVECTOR XMVectorCosH(FXMVECTOR V);
2480 XMVECTOR XMVectorCosHEst(FXMVECTOR V);
2481 XMVECTOR XMVectorTanH(FXMVECTOR V);
2482 XMVECTOR XMVectorTanHEst(FXMVECTOR V);
2483 XMVECTOR XMVectorASin(FXMVECTOR V);
2484 XMVECTOR XMVectorASinEst(FXMVECTOR V);
2485 XMVECTOR XMVectorACos(FXMVECTOR V);
2486 XMVECTOR XMVectorACosEst(FXMVECTOR V);
2487 XMVECTOR XMVectorATan(FXMVECTOR V);
2488 XMVECTOR XMVectorATanEst(FXMVECTOR V);
2489 XMVECTOR XMVectorATan2(FXMVECTOR Y, FXMVECTOR X);
2490 XMVECTOR XMVectorATan2Est(FXMVECTOR Y, FXMVECTOR X);
2491 XMVECTOR XMVectorLerp(FXMVECTOR V0, FXMVECTOR V1, FLOAT t);
2492 XMVECTOR XMVectorLerpV(FXMVECTOR V0, FXMVECTOR V1, FXMVECTOR T);
2493 XMVECTOR XMVectorHermite(FXMVECTOR Position0, FXMVECTOR Tangent0, FXMVECTOR Position1, CXMVECTOR Tangent1, FLOAT t);
2494 XMVECTOR XMVectorHermiteV(FXMVECTOR Position0, FXMVECTOR Tangent0, FXMVECTOR Position1, CXMVECTOR Tangent1, CXMVECTOR T);
2495 XMVECTOR XMVectorCatmullRom(FXMVECTOR Position0, FXMVECTOR Position1, FXMVECTOR Position2, CXMVECTOR Position3, FLOAT t);
2496 XMVECTOR XMVectorCatmullRomV(FXMVECTOR Position0, FXMVECTOR Position1, FXMVECTOR Position2, CXMVECTOR Position3, CXMVECTOR T);
2497 XMVECTOR XMVectorBaryCentric(FXMVECTOR Position0, FXMVECTOR Position1, FXMVECTOR Position2, FLOAT f, FLOAT g);
2498 XMVECTOR XMVectorBaryCentricV(FXMVECTOR Position0, FXMVECTOR Position1, FXMVECTOR Position2, CXMVECTOR F, CXMVECTOR G);
2500 /****************************************************************************
2502 * 2D vector operations
2504 ****************************************************************************/
2507 BOOL XMVector2Equal(FXMVECTOR V1, FXMVECTOR V2);
2508 UINT XMVector2EqualR(FXMVECTOR V1, FXMVECTOR V2);
2509 BOOL XMVector2EqualInt(FXMVECTOR V1, FXMVECTOR V2);
2510 UINT XMVector2EqualIntR(FXMVECTOR V1, FXMVECTOR V2);
2511 BOOL XMVector2NearEqual(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR Epsilon);
2512 BOOL XMVector2NotEqual(FXMVECTOR V1, FXMVECTOR V2);
2513 BOOL XMVector2NotEqualInt(FXMVECTOR V1, FXMVECTOR V2);
2514 BOOL XMVector2Greater(FXMVECTOR V1, FXMVECTOR V2);
2515 UINT XMVector2GreaterR(FXMVECTOR V1, FXMVECTOR V2);
2516 BOOL XMVector2GreaterOrEqual(FXMVECTOR V1, FXMVECTOR V2);
2517 UINT XMVector2GreaterOrEqualR(FXMVECTOR V1, FXMVECTOR V2);
2518 BOOL XMVector2Less(FXMVECTOR V1, FXMVECTOR V2);
2519 BOOL XMVector2LessOrEqual(FXMVECTOR V1, FXMVECTOR V2);
2520 BOOL XMVector2InBounds(FXMVECTOR V, FXMVECTOR Bounds);
2521 UINT XMVector2InBoundsR(FXMVECTOR V, FXMVECTOR Bounds);
2523 BOOL XMVector2IsNaN(FXMVECTOR V);
2524 BOOL XMVector2IsInfinite(FXMVECTOR V);
2526 XMVECTOR XMVector2Dot(FXMVECTOR V1, FXMVECTOR V2);
2527 XMVECTOR XMVector2Cross(FXMVECTOR V1, FXMVECTOR V2);
2528 XMVECTOR XMVector2LengthSq(FXMVECTOR V);
2529 XMVECTOR XMVector2ReciprocalLengthEst(FXMVECTOR V);
2530 XMVECTOR XMVector2ReciprocalLength(FXMVECTOR V);
2531 XMVECTOR XMVector2LengthEst(FXMVECTOR V);
2532 XMVECTOR XMVector2Length(FXMVECTOR V);
2533 XMVECTOR XMVector2NormalizeEst(FXMVECTOR V);
2534 XMVECTOR XMVector2Normalize(FXMVECTOR V);
2535 XMVECTOR XMVector2ClampLength(FXMVECTOR V, FLOAT LengthMin, FLOAT LengthMax);
2536 XMVECTOR XMVector2ClampLengthV(FXMVECTOR V, FXMVECTOR LengthMin, FXMVECTOR LengthMax);
2537 XMVECTOR XMVector2Reflect(FXMVECTOR Incident, FXMVECTOR Normal);
2538 XMVECTOR XMVector2Refract(FXMVECTOR Incident, FXMVECTOR Normal, FLOAT RefractionIndex);
2539 XMVECTOR XMVector2RefractV(FXMVECTOR Incident, FXMVECTOR Normal, FXMVECTOR RefractionIndex);
2540 XMVECTOR XMVector2Orthogonal(FXMVECTOR V);
2541 XMVECTOR XMVector2AngleBetweenNormalsEst(FXMVECTOR N1, FXMVECTOR N2);
2542 XMVECTOR XMVector2AngleBetweenNormals(FXMVECTOR N1, FXMVECTOR N2);
2543 XMVECTOR XMVector2AngleBetweenVectors(FXMVECTOR V1, FXMVECTOR V2);
2544 XMVECTOR XMVector2LinePointDistance(FXMVECTOR LinePoint1, FXMVECTOR LinePoint2, FXMVECTOR Point);
2545 XMVECTOR XMVector2IntersectLine(FXMVECTOR Line1Point1, FXMVECTOR Line1Point2, FXMVECTOR Line2Point1, CXMVECTOR Line2Point2);
2546 XMVECTOR XMVector2Transform(FXMVECTOR V, CXMMATRIX M);
2547 XMFLOAT4* XMVector2TransformStream(_Out_bytecap_x_(sizeof(XMFLOAT4)+OutputStride*(VectorCount-1)) XMFLOAT4* pOutputStream,
2548 _In_ size_t OutputStride,
2549 _In_bytecount_x_(sizeof(XMFLOAT2)+InputStride*(VectorCount-1)) CONST XMFLOAT2* pInputStream,
2550 _In_ size_t InputStride, _In_ size_t VectorCount, CXMMATRIX M);
2551 XMFLOAT4* XMVector2TransformStreamNC(_Out_bytecap_x_(sizeof(XMFLOAT4)+OutputStride*(VectorCount-1)) XMFLOAT4* pOutputStream,
2552 _In_ size_t OutputStride,
2553 _In_bytecount_x_(sizeof(XMFLOAT2)+InputStride*(VectorCount-1)) CONST XMFLOAT2* pInputStream,
2554 _In_ size_t InputStride, _In_ size_t VectorCount, CXMMATRIX M);
2555 XMVECTOR XMVector2TransformCoord(FXMVECTOR V, CXMMATRIX M);
2556 XMFLOAT2* XMVector2TransformCoordStream(_Out_bytecap_x_(sizeof(XMFLOAT2)+OutputStride*(VectorCount-1)) XMFLOAT2* pOutputStream,
2557 _In_ size_t OutputStride,
2558 _In_bytecount_x_(sizeof(XMFLOAT2)+InputStride*(VectorCount-1)) CONST XMFLOAT2* pInputStream,
2559 _In_ size_t InputStride, _In_ size_t VectorCount, CXMMATRIX M);
2560 XMVECTOR XMVector2TransformNormal(FXMVECTOR V, CXMMATRIX M);
2561 XMFLOAT2* XMVector2TransformNormalStream(_Out_bytecap_x_(sizeof(XMFLOAT2)+OutputStride*(VectorCount-1)) XMFLOAT2* pOutputStream,
2562 _In_ size_t OutputStride,
2563 _In_bytecount_x_(sizeof(XMFLOAT2)+InputStride*(VectorCount-1)) CONST XMFLOAT2* pInputStream,
2564 _In_ size_t InputStride, _In_ size_t VectorCount, CXMMATRIX M);
2566 /****************************************************************************
2568 * 3D vector operations
2570 ****************************************************************************/
2573 BOOL XMVector3Equal(FXMVECTOR V1, FXMVECTOR V2);
2574 UINT XMVector3EqualR(FXMVECTOR V1, FXMVECTOR V2);
2575 BOOL XMVector3EqualInt(FXMVECTOR V1, FXMVECTOR V2);
2576 UINT XMVector3EqualIntR(FXMVECTOR V1, FXMVECTOR V2);
2577 BOOL XMVector3NearEqual(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR Epsilon);
2578 BOOL XMVector3NotEqual(FXMVECTOR V1, FXMVECTOR V2);
2579 BOOL XMVector3NotEqualInt(FXMVECTOR V1, FXMVECTOR V2);
2580 BOOL XMVector3Greater(FXMVECTOR V1, FXMVECTOR V2);
2581 UINT XMVector3GreaterR(FXMVECTOR V1, FXMVECTOR V2);
2582 BOOL XMVector3GreaterOrEqual(FXMVECTOR V1, FXMVECTOR V2);
2583 UINT XMVector3GreaterOrEqualR(FXMVECTOR V1, FXMVECTOR V2);
2584 BOOL XMVector3Less(FXMVECTOR V1, FXMVECTOR V2);
2585 BOOL XMVector3LessOrEqual(FXMVECTOR V1, FXMVECTOR V2);
2586 BOOL XMVector3InBounds(FXMVECTOR V, FXMVECTOR Bounds);
2587 UINT XMVector3InBoundsR(FXMVECTOR V, FXMVECTOR Bounds);
2589 BOOL XMVector3IsNaN(FXMVECTOR V);
2590 BOOL XMVector3IsInfinite(FXMVECTOR V);
2592 XMVECTOR XMVector3Dot(FXMVECTOR V1, FXMVECTOR V2);
2593 XMVECTOR XMVector3Cross(FXMVECTOR V1, FXMVECTOR V2);
2594 XMVECTOR XMVector3LengthSq(FXMVECTOR V);
2595 XMVECTOR XMVector3ReciprocalLengthEst(FXMVECTOR V);
2596 XMVECTOR XMVector3ReciprocalLength(FXMVECTOR V);
2597 XMVECTOR XMVector3LengthEst(FXMVECTOR V);
2598 XMVECTOR XMVector3Length(FXMVECTOR V);
2599 XMVECTOR XMVector3NormalizeEst(FXMVECTOR V);
2600 XMVECTOR XMVector3Normalize(FXMVECTOR V);
2601 XMVECTOR XMVector3ClampLength(FXMVECTOR V, FLOAT LengthMin, FLOAT LengthMax);
2602 XMVECTOR XMVector3ClampLengthV(FXMVECTOR V, FXMVECTOR LengthMin, FXMVECTOR LengthMax);
2603 XMVECTOR XMVector3Reflect(FXMVECTOR Incident, FXMVECTOR Normal);
2604 XMVECTOR XMVector3Refract(FXMVECTOR Incident, FXMVECTOR Normal, FLOAT RefractionIndex);
2605 XMVECTOR XMVector3RefractV(FXMVECTOR Incident, FXMVECTOR Normal, FXMVECTOR RefractionIndex);
2606 XMVECTOR XMVector3Orthogonal(FXMVECTOR V);
2607 XMVECTOR XMVector3AngleBetweenNormalsEst(FXMVECTOR N1, FXMVECTOR N2);
2608 XMVECTOR XMVector3AngleBetweenNormals(FXMVECTOR N1, FXMVECTOR N2);
2609 XMVECTOR XMVector3AngleBetweenVectors(FXMVECTOR V1, FXMVECTOR V2);
2610 XMVECTOR XMVector3LinePointDistance(FXMVECTOR LinePoint1, FXMVECTOR LinePoint2, FXMVECTOR Point);
2611 VOID XMVector3ComponentsFromNormal(_Out_ XMVECTOR* pParallel, _Out_ XMVECTOR* pPerpendicular, FXMVECTOR V, FXMVECTOR Normal);
2612 XMVECTOR XMVector3Rotate(FXMVECTOR V, FXMVECTOR RotationQuaternion);
2613 XMVECTOR XMVector3InverseRotate(FXMVECTOR V, FXMVECTOR RotationQuaternion);
2614 XMVECTOR XMVector3Transform(FXMVECTOR V, CXMMATRIX M);
2615 XMFLOAT4* XMVector3TransformStream(_Out_bytecap_x_(sizeof(XMFLOAT4)+OutputStride*(VectorCount-1)) XMFLOAT4* pOutputStream,
2616 _In_ size_t OutputStride,
2617 _In_bytecount_x_(sizeof(XMFLOAT3)+InputStride*(VectorCount-1)) CONST XMFLOAT3* pInputStream,
2618 _In_ size_t InputStride, _In_ size_t VectorCount, CXMMATRIX M);
2619 XMFLOAT4* XMVector3TransformStreamNC(_Out_bytecap_x_(sizeof(XMFLOAT4)+OutputStride*(VectorCount-1)) XMFLOAT4* pOutputStream,
2620 _In_ size_t OutputStride,
2621 _In_bytecount_x_(sizeof(XMFLOAT3)+InputStride*(VectorCount-1)) CONST XMFLOAT3* pInputStream,
2622 _In_ size_t InputStride, _In_ size_t VectorCount, CXMMATRIX M);
2623 XMVECTOR XMVector3TransformCoord(FXMVECTOR V, CXMMATRIX M);
2624 XMFLOAT3* XMVector3TransformCoordStream(_Out_bytecap_x_(sizeof(XMFLOAT3)+OutputStride*(VectorCount-1)) XMFLOAT3* pOutputStream,
2625 _In_ size_t OutputStride,
2626 _In_bytecount_x_(sizeof(XMFLOAT3)+InputStride*(VectorCount-1)) CONST XMFLOAT3* pInputStream,
2627 _In_ size_t InputStride, _In_ size_t VectorCount, CXMMATRIX M);
2628 XMVECTOR XMVector3TransformNormal(FXMVECTOR V, CXMMATRIX M);
2629 XMFLOAT3* XMVector3TransformNormalStream(_Out_bytecap_x_(sizeof(XMFLOAT3)+OutputStride*(VectorCount-1)) XMFLOAT3* pOutputStream,
2630 _In_ size_t OutputStride,
2631 _In_bytecount_x_(sizeof(XMFLOAT3)+InputStride*(VectorCount-1)) CONST XMFLOAT3* pInputStream,
2632 _In_ size_t InputStride, _In_ size_t VectorCount, CXMMATRIX M);
2633 XMVECTOR XMVector3Project(FXMVECTOR V, FLOAT ViewportX, FLOAT ViewportY, FLOAT ViewportWidth, FLOAT ViewportHeight, FLOAT ViewportMinZ, FLOAT ViewportMaxZ,
2634 CXMMATRIX Projection, CXMMATRIX View, CXMMATRIX World);
2635 XMFLOAT3* XMVector3ProjectStream(_Out_bytecap_x_(sizeof(XMFLOAT3)+OutputStride*(VectorCount-1)) XMFLOAT3* pOutputStream,
2636 _In_ size_t OutputStride,
2637 _In_bytecount_x_(sizeof(XMFLOAT3)+InputStride*(VectorCount-1)) CONST XMFLOAT3* pInputStream,
2638 _In_ size_t InputStride, _In_ size_t VectorCount,
2639 FLOAT ViewportX, FLOAT ViewportY, FLOAT ViewportWidth, FLOAT ViewportHeight, FLOAT ViewportMinZ, FLOAT ViewportMaxZ,
2640 CXMMATRIX Projection, CXMMATRIX View, CXMMATRIX World);
2641 XMVECTOR XMVector3Unproject(FXMVECTOR V, FLOAT ViewportX, FLOAT ViewportY, FLOAT ViewportWidth, FLOAT ViewportHeight, FLOAT ViewportMinZ, FLOAT ViewportMaxZ,
2642 CXMMATRIX Projection, CXMMATRIX View, CXMMATRIX World);
2643 XMFLOAT3* XMVector3UnprojectStream(_Out_bytecap_x_(sizeof(XMFLOAT3)+OutputStride*(VectorCount-1)) XMFLOAT3* pOutputStream,
2644 _In_ size_t OutputStride,
2645 _In_bytecount_x_(sizeof(XMFLOAT3)+InputStride*(VectorCount-1)) CONST XMFLOAT3* pInputStream,
2646 _In_ size_t InputStride, _In_ size_t VectorCount,
2647 FLOAT ViewportX, FLOAT ViewportY, FLOAT ViewportWidth, FLOAT ViewportHeight, FLOAT ViewportMinZ, FLOAT ViewportMaxZ,
2648 CXMMATRIX Projection, CXMMATRIX View, CXMMATRIX World);
2650 /****************************************************************************
2652 * 4D vector operations
2654 ****************************************************************************/
2656 BOOL XMVector4Equal(FXMVECTOR V1, FXMVECTOR V2);
2657 UINT XMVector4EqualR(FXMVECTOR V1, FXMVECTOR V2);
2658 BOOL XMVector4EqualInt(FXMVECTOR V1, FXMVECTOR V2);
2659 UINT XMVector4EqualIntR(FXMVECTOR V1, FXMVECTOR V2);
2660 BOOL XMVector4NearEqual(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR Epsilon);
2661 BOOL XMVector4NotEqual(FXMVECTOR V1, FXMVECTOR V2);
2662 BOOL XMVector4NotEqualInt(FXMVECTOR V1, FXMVECTOR V2);
2663 BOOL XMVector4Greater(FXMVECTOR V1, FXMVECTOR V2);
2664 UINT XMVector4GreaterR(FXMVECTOR V1, FXMVECTOR V2);
2665 BOOL XMVector4GreaterOrEqual(FXMVECTOR V1, FXMVECTOR V2);
2666 UINT XMVector4GreaterOrEqualR(FXMVECTOR V1, FXMVECTOR V2);
2667 BOOL XMVector4Less(FXMVECTOR V1, FXMVECTOR V2);
2668 BOOL XMVector4LessOrEqual(FXMVECTOR V1, FXMVECTOR V2);
2669 BOOL XMVector4InBounds(FXMVECTOR V, FXMVECTOR Bounds);
2670 UINT XMVector4InBoundsR(FXMVECTOR V, FXMVECTOR Bounds);
2672 BOOL XMVector4IsNaN(FXMVECTOR V);
2673 BOOL XMVector4IsInfinite(FXMVECTOR V);
2675 XMVECTOR XMVector4Dot(FXMVECTOR V1, FXMVECTOR V2);
2676 XMVECTOR XMVector4Cross(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR V3);
2677 XMVECTOR XMVector4LengthSq(FXMVECTOR V);
2678 XMVECTOR XMVector4ReciprocalLengthEst(FXMVECTOR V);
2679 XMVECTOR XMVector4ReciprocalLength(FXMVECTOR V);
2680 XMVECTOR XMVector4LengthEst(FXMVECTOR V);
2681 XMVECTOR XMVector4Length(FXMVECTOR V);
2682 XMVECTOR XMVector4NormalizeEst(FXMVECTOR V);
2683 XMVECTOR XMVector4Normalize(FXMVECTOR V);
2684 XMVECTOR XMVector4ClampLength(FXMVECTOR V, FLOAT LengthMin, FLOAT LengthMax);
2685 XMVECTOR XMVector4ClampLengthV(FXMVECTOR V, FXMVECTOR LengthMin, FXMVECTOR LengthMax);
2686 XMVECTOR XMVector4Reflect(FXMVECTOR Incident, FXMVECTOR Normal);
2687 XMVECTOR XMVector4Refract(FXMVECTOR Incident, FXMVECTOR Normal, FLOAT RefractionIndex);
2688 XMVECTOR XMVector4RefractV(FXMVECTOR Incident, FXMVECTOR Normal, FXMVECTOR RefractionIndex);
2689 XMVECTOR XMVector4Orthogonal(FXMVECTOR V);
2690 XMVECTOR XMVector4AngleBetweenNormalsEst(FXMVECTOR N1, FXMVECTOR N2);
2691 XMVECTOR XMVector4AngleBetweenNormals(FXMVECTOR N1, FXMVECTOR N2);
2692 XMVECTOR XMVector4AngleBetweenVectors(FXMVECTOR V1, FXMVECTOR V2);
2693 XMVECTOR XMVector4Transform(FXMVECTOR V, CXMMATRIX M);
2694 XMFLOAT4* XMVector4TransformStream(_Out_bytecap_x_(sizeof(XMFLOAT4)+OutputStride*(VectorCount-1)) XMFLOAT4* pOutputStream,
2695 _In_ size_t OutputStride,
2696 _In_bytecount_x_(sizeof(XMFLOAT4)+InputStride*(VectorCount-1)) CONST XMFLOAT4* pInputStream,
2697 _In_ size_t InputStride, _In_ size_t VectorCount, CXMMATRIX M);
2699 /****************************************************************************
2703 ****************************************************************************/
2705 BOOL XMMatrixIsNaN(CXMMATRIX M);
2706 BOOL XMMatrixIsInfinite(CXMMATRIX M);
2707 BOOL XMMatrixIsIdentity(CXMMATRIX M);
2709 XMMATRIX XMMatrixMultiply(CXMMATRIX M1, CXMMATRIX M2);
2710 XMMATRIX XMMatrixMultiplyTranspose(CXMMATRIX M1, CXMMATRIX M2);
2711 XMMATRIX XMMatrixTranspose(CXMMATRIX M);
2712 XMMATRIX XMMatrixInverse(_Out_opt_ XMVECTOR* pDeterminant, CXMMATRIX M);
2713 XMVECTOR XMMatrixDeterminant(CXMMATRIX M);
2714 BOOL XMMatrixDecompose(_Out_ XMVECTOR *outScale, _Out_ XMVECTOR *outRotQuat, _Out_ XMVECTOR *outTrans, CXMMATRIX M);
2716 XMMATRIX XMMatrixIdentity();
2717 XMMATRIX XMMatrixSet(FLOAT m00, FLOAT m01, FLOAT m02, FLOAT m03,
2718 FLOAT m10, FLOAT m11, FLOAT m12, FLOAT m13,
2719 FLOAT m20, FLOAT m21, FLOAT m22, FLOAT m23,
2720 FLOAT m30, FLOAT m31, FLOAT m32, FLOAT m33);
2721 XMMATRIX XMMatrixTranslation(FLOAT OffsetX, FLOAT OffsetY, FLOAT OffsetZ);
2722 XMMATRIX XMMatrixTranslationFromVector(FXMVECTOR Offset);
2723 XMMATRIX XMMatrixScaling(FLOAT ScaleX, FLOAT ScaleY, FLOAT ScaleZ);
2724 XMMATRIX XMMatrixScalingFromVector(FXMVECTOR Scale);
2725 XMMATRIX XMMatrixRotationX(FLOAT Angle);
2726 XMMATRIX XMMatrixRotationY(FLOAT Angle);
2727 XMMATRIX XMMatrixRotationZ(FLOAT Angle);
2728 XMMATRIX XMMatrixRotationRollPitchYaw(FLOAT Pitch, FLOAT Yaw, FLOAT Roll);
2729 XMMATRIX XMMatrixRotationRollPitchYawFromVector(FXMVECTOR Angles);
2730 XMMATRIX XMMatrixRotationNormal(FXMVECTOR NormalAxis, FLOAT Angle);
2731 XMMATRIX XMMatrixRotationAxis(FXMVECTOR Axis, FLOAT Angle);
2732 XMMATRIX XMMatrixRotationQuaternion(FXMVECTOR Quaternion);
2733 XMMATRIX XMMatrixTransformation2D(FXMVECTOR ScalingOrigin, FLOAT ScalingOrientation, FXMVECTOR Scaling,
2734 FXMVECTOR RotationOrigin, FLOAT Rotation, CXMVECTOR Translation);
2735 XMMATRIX XMMatrixTransformation(FXMVECTOR ScalingOrigin, FXMVECTOR ScalingOrientationQuaternion, FXMVECTOR Scaling,
2736 CXMVECTOR RotationOrigin, CXMVECTOR RotationQuaternion, CXMVECTOR Translation);
2737 XMMATRIX XMMatrixAffineTransformation2D(FXMVECTOR Scaling, FXMVECTOR RotationOrigin, FLOAT Rotation, FXMVECTOR Translation);
2738 XMMATRIX XMMatrixAffineTransformation(FXMVECTOR Scaling, FXMVECTOR RotationOrigin, FXMVECTOR RotationQuaternion, CXMVECTOR Translation);
2739 XMMATRIX XMMatrixReflect(FXMVECTOR ReflectionPlane);
2740 XMMATRIX XMMatrixShadow(FXMVECTOR ShadowPlane, FXMVECTOR LightPosition);
2742 XMMATRIX XMMatrixLookAtLH(FXMVECTOR EyePosition, FXMVECTOR FocusPosition, FXMVECTOR UpDirection);
2743 XMMATRIX XMMatrixLookAtRH(FXMVECTOR EyePosition, FXMVECTOR FocusPosition, FXMVECTOR UpDirection);
2744 XMMATRIX XMMatrixLookToLH(FXMVECTOR EyePosition, FXMVECTOR EyeDirection, FXMVECTOR UpDirection);
2745 XMMATRIX XMMatrixLookToRH(FXMVECTOR EyePosition, FXMVECTOR EyeDirection, FXMVECTOR UpDirection);
2746 XMMATRIX XMMatrixPerspectiveLH(FLOAT ViewWidth, FLOAT ViewHeight, FLOAT NearZ, FLOAT FarZ);
2747 XMMATRIX XMMatrixPerspectiveRH(FLOAT ViewWidth, FLOAT ViewHeight, FLOAT NearZ, FLOAT FarZ);
2748 XMMATRIX XMMatrixPerspectiveFovLH(FLOAT FovAngleY, FLOAT AspectHByW, FLOAT NearZ, FLOAT FarZ);
2749 XMMATRIX XMMatrixPerspectiveFovRH(FLOAT FovAngleY, FLOAT AspectHByW, FLOAT NearZ, FLOAT FarZ);
2750 XMMATRIX XMMatrixPerspectiveOffCenterLH(FLOAT ViewLeft, FLOAT ViewRight, FLOAT ViewBottom, FLOAT ViewTop, FLOAT NearZ, FLOAT FarZ);
2751 XMMATRIX XMMatrixPerspectiveOffCenterRH(FLOAT ViewLeft, FLOAT ViewRight, FLOAT ViewBottom, FLOAT ViewTop, FLOAT NearZ, FLOAT FarZ);
2752 XMMATRIX XMMatrixOrthographicLH(FLOAT ViewWidth, FLOAT ViewHeight, FLOAT NearZ, FLOAT FarZ);
2753 XMMATRIX XMMatrixOrthographicRH(FLOAT ViewWidth, FLOAT ViewHeight, FLOAT NearZ, FLOAT FarZ);
2754 XMMATRIX XMMatrixOrthographicOffCenterLH(FLOAT ViewLeft, FLOAT ViewRight, FLOAT ViewBottom, FLOAT ViewTop, FLOAT NearZ, FLOAT FarZ);
2755 XMMATRIX XMMatrixOrthographicOffCenterRH(FLOAT ViewLeft, FLOAT ViewRight, FLOAT ViewBottom, FLOAT ViewTop, FLOAT NearZ, FLOAT FarZ);
2758 /****************************************************************************
2760 * Quaternion operations
2762 ****************************************************************************/
2764 BOOL XMQuaternionEqual(FXMVECTOR Q1, FXMVECTOR Q2);
2765 BOOL XMQuaternionNotEqual(FXMVECTOR Q1, FXMVECTOR Q2);
2767 BOOL XMQuaternionIsNaN(FXMVECTOR Q);
2768 BOOL XMQuaternionIsInfinite(FXMVECTOR Q);
2769 BOOL XMQuaternionIsIdentity(FXMVECTOR Q);
2771 XMVECTOR XMQuaternionDot(FXMVECTOR Q1, FXMVECTOR Q2);
2772 XMVECTOR XMQuaternionMultiply(FXMVECTOR Q1, FXMVECTOR Q2);
2773 XMVECTOR XMQuaternionLengthSq(FXMVECTOR Q);
2774 XMVECTOR XMQuaternionReciprocalLength(FXMVECTOR Q);
2775 XMVECTOR XMQuaternionLength(FXMVECTOR Q);
2776 XMVECTOR XMQuaternionNormalizeEst(FXMVECTOR Q);
2777 XMVECTOR XMQuaternionNormalize(FXMVECTOR Q);
2778 XMVECTOR XMQuaternionConjugate(FXMVECTOR Q);
2779 XMVECTOR XMQuaternionInverse(FXMVECTOR Q);
2780 XMVECTOR XMQuaternionLn(FXMVECTOR Q);
2781 XMVECTOR XMQuaternionExp(FXMVECTOR Q);
2782 XMVECTOR XMQuaternionSlerp(FXMVECTOR Q0, FXMVECTOR Q1, FLOAT t);
2783 XMVECTOR XMQuaternionSlerpV(FXMVECTOR Q0, FXMVECTOR Q1, FXMVECTOR T);
2784 XMVECTOR XMQuaternionSquad(FXMVECTOR Q0, FXMVECTOR Q1, FXMVECTOR Q2, CXMVECTOR Q3, FLOAT t);
2785 XMVECTOR XMQuaternionSquadV(FXMVECTOR Q0, FXMVECTOR Q1, FXMVECTOR Q2, CXMVECTOR Q3, CXMVECTOR T);
2786 VOID XMQuaternionSquadSetup(_Out_ XMVECTOR* pA, _Out_ XMVECTOR* pB, _Out_ XMVECTOR* pC, FXMVECTOR Q0, FXMVECTOR Q1, FXMVECTOR Q2, CXMVECTOR Q3);
2787 XMVECTOR XMQuaternionBaryCentric(FXMVECTOR Q0, FXMVECTOR Q1, FXMVECTOR Q2, FLOAT f, FLOAT g);
2788 XMVECTOR XMQuaternionBaryCentricV(FXMVECTOR Q0, FXMVECTOR Q1, FXMVECTOR Q2, CXMVECTOR F, CXMVECTOR G);
2790 XMVECTOR XMQuaternionIdentity();
2791 XMVECTOR XMQuaternionRotationRollPitchYaw(FLOAT Pitch, FLOAT Yaw, FLOAT Roll);
2792 XMVECTOR XMQuaternionRotationRollPitchYawFromVector(FXMVECTOR Angles);
2793 XMVECTOR XMQuaternionRotationNormal(FXMVECTOR NormalAxis, FLOAT Angle);
2794 XMVECTOR XMQuaternionRotationAxis(FXMVECTOR Axis, FLOAT Angle);
2795 XMVECTOR XMQuaternionRotationMatrix(CXMMATRIX M);
2797 VOID XMQuaternionToAxisAngle(_Out_ XMVECTOR* pAxis, _Out_ FLOAT* pAngle, FXMVECTOR Q);
2799 /****************************************************************************
2803 ****************************************************************************/
2805 BOOL XMPlaneEqual(FXMVECTOR P1, FXMVECTOR P2);
2806 BOOL XMPlaneNearEqual(FXMVECTOR P1, FXMVECTOR P2, FXMVECTOR Epsilon);
2807 BOOL XMPlaneNotEqual(FXMVECTOR P1, FXMVECTOR P2);
2809 BOOL XMPlaneIsNaN(FXMVECTOR P);
2810 BOOL XMPlaneIsInfinite(FXMVECTOR P);
2812 XMVECTOR XMPlaneDot(FXMVECTOR P, FXMVECTOR V);
2813 XMVECTOR XMPlaneDotCoord(FXMVECTOR P, FXMVECTOR V);
2814 XMVECTOR XMPlaneDotNormal(FXMVECTOR P, FXMVECTOR V);
2815 XMVECTOR XMPlaneNormalizeEst(FXMVECTOR P);
2816 XMVECTOR XMPlaneNormalize(FXMVECTOR P);
2817 XMVECTOR XMPlaneIntersectLine(FXMVECTOR P, FXMVECTOR LinePoint1, FXMVECTOR LinePoint2);
2818 VOID XMPlaneIntersectPlane(_Out_ XMVECTOR* pLinePoint1, _Out_ XMVECTOR* pLinePoint2, FXMVECTOR P1, FXMVECTOR P2);
2819 XMVECTOR XMPlaneTransform(FXMVECTOR P, CXMMATRIX M);
2820 XMFLOAT4* XMPlaneTransformStream(_Out_bytecap_x_(sizeof(XMFLOAT4)+OutputStride*(PlaneCount-1)) XMFLOAT4* pOutputStream,
2821 _In_ size_t OutputStride,
2822 _In_bytecount_x_(sizeof(XMFLOAT4)+InputStride*(PlaneCount-1)) CONST XMFLOAT4* pInputStream,
2823 _In_ size_t InputStride, _In_ size_t PlaneCount, CXMMATRIX M);
2825 XMVECTOR XMPlaneFromPointNormal(FXMVECTOR Point, FXMVECTOR Normal);
2826 XMVECTOR XMPlaneFromPoints(FXMVECTOR Point1, FXMVECTOR Point2, FXMVECTOR Point3);
2828 /****************************************************************************
2832 ****************************************************************************/
2834 BOOL XMColorEqual(FXMVECTOR C1, FXMVECTOR C2);
2835 BOOL XMColorNotEqual(FXMVECTOR C1, FXMVECTOR C2);
2836 BOOL XMColorGreater(FXMVECTOR C1, FXMVECTOR C2);
2837 BOOL XMColorGreaterOrEqual(FXMVECTOR C1, FXMVECTOR C2);
2838 BOOL XMColorLess(FXMVECTOR C1, FXMVECTOR C2);
2839 BOOL XMColorLessOrEqual(FXMVECTOR C1, FXMVECTOR C2);
2841 BOOL XMColorIsNaN(FXMVECTOR C);
2842 BOOL XMColorIsInfinite(FXMVECTOR C);
2844 XMVECTOR XMColorNegative(FXMVECTOR C);
2845 XMVECTOR XMColorModulate(FXMVECTOR C1, FXMVECTOR C2);
2846 XMVECTOR XMColorAdjustSaturation(FXMVECTOR C, FLOAT Saturation);
2847 XMVECTOR XMColorAdjustContrast(FXMVECTOR C, FLOAT Contrast);
2849 /****************************************************************************
2851 * Miscellaneous operations
2853 ****************************************************************************/
2855 BOOL XMVerifyCPUSupport();
2857 VOID XMAssert(_In_z_ CONST CHAR* pExpression, _In_z_ CONST CHAR* pFileName, UINT LineNumber);
2859 XMVECTOR XMFresnelTerm(FXMVECTOR CosIncidentAngle, FXMVECTOR RefractionIndex);
2861 BOOL XMScalarNearEqual(FLOAT S1, FLOAT S2, FLOAT Epsilon);
2862 FLOAT XMScalarModAngle(FLOAT Value);
2863 FLOAT XMScalarSin(FLOAT Value);
2864 FLOAT XMScalarCos(FLOAT Value);
2865 VOID XMScalarSinCos(_Out_ FLOAT* pSin, _Out_ FLOAT* pCos, FLOAT Value);
2866 FLOAT XMScalarASin(FLOAT Value);
2867 FLOAT XMScalarACos(FLOAT Value);
2868 FLOAT XMScalarSinEst(FLOAT Value);
2869 FLOAT XMScalarCosEst(FLOAT Value);
2870 VOID XMScalarSinCosEst(_Out_ FLOAT* pSin, _Out_ FLOAT* pCos, FLOAT Value);
2871 FLOAT XMScalarASinEst(FLOAT Value);
2872 FLOAT XMScalarACosEst(FLOAT Value);
2874 /****************************************************************************
2878 ****************************************************************************/
2880 #if defined(__cplusplus)
2882 #if defined(_XM_SSE_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
2884 // PermuteHelper internal template (SSE only)
2885 namespace XNAMathInternal
2887 // Slow path fallback for permutes that do not map to a single SSE shuffle opcode.
2888 template<UINT Shuffle, bool WhichX, bool WhichY, bool WhichZ, bool WhichW> struct PermuteHelper
2890 static XMVECTOR Permute(FXMVECTOR v1, FXMVECTOR v2)
2892 static const XMVECTORU32 selectMask =
2894 WhichX ? 0xFFFFFFFF : 0,
2895 WhichY ? 0xFFFFFFFF : 0,
2896 WhichZ ? 0xFFFFFFFF : 0,
2897 WhichW ? 0xFFFFFFFF : 0,
2900 XMVECTOR shuffled1 = _mm_shuffle_ps(v1, v1, Shuffle);
2901 XMVECTOR shuffled2 = _mm_shuffle_ps(v2, v2, Shuffle);
2903 XMVECTOR masked1 = _mm_andnot_ps(selectMask, shuffled1);
2904 XMVECTOR masked2 = _mm_and_ps(selectMask, shuffled2);
2906 return _mm_or_ps(masked1, masked2);
2910 // Fast path for permutes that only read from the first vector.
2911 template<UINT Shuffle> struct PermuteHelper<Shuffle, false, false, false, false>
2913 static XMVECTOR Permute(FXMVECTOR v1, FXMVECTOR v2) { (v2); return _mm_shuffle_ps(v1, v1, Shuffle); }
2916 // Fast path for permutes that only read from the second vector.
2917 template<UINT Shuffle> struct PermuteHelper<Shuffle, true, true, true, true>
2919 static XMVECTOR Permute(FXMVECTOR v1, FXMVECTOR v2){ (v1); return _mm_shuffle_ps(v2, v2, Shuffle); }
2922 // Fast path for permutes that read XY from the first vector, ZW from the second.
2923 template<UINT Shuffle> struct PermuteHelper<Shuffle, false, false, true, true>
2925 static XMVECTOR Permute(FXMVECTOR v1, FXMVECTOR v2) { return _mm_shuffle_ps(v1, v2, Shuffle); }
2928 // Fast path for permutes that read XY from the second vector, ZW from the first.
2929 template<UINT Shuffle> struct PermuteHelper<Shuffle, true, true, false, false>
2931 static XMVECTOR Permute(FXMVECTOR v1, FXMVECTOR v2) { return _mm_shuffle_ps(v2, v1, Shuffle); }
2935 #endif // _XM_SSE_INTRINSICS_ && !_XM_NO_INTRINSICS_
2937 // General permute template
2938 template<UINT PermuteX, UINT PermuteY, UINT PermuteZ, UINT PermuteW>
2939 inline XMVECTOR XMVectorPermute(FXMVECTOR V1, FXMVECTOR V2)
2941 #if defined(_MSC_VER) && (_MSC_VER >= 1600)
2942 static_assert(PermuteX <= 7, "PermuteX template parameter out of range");
2943 static_assert(PermuteY <= 7, "PermuteY template parameter out of range");
2944 static_assert(PermuteZ <= 7, "PermuteZ template parameter out of range");
2945 static_assert(PermuteW <= 7, "PermuteW template parameter out of range");
2947 XMASSERT(PermuteX <= 7);
2948 XMASSERT(PermuteY <= 7);
2949 XMASSERT(PermuteZ <= 7);
2950 XMASSERT(PermuteW <= 7);
2953 #if defined(_XM_SSE_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
2954 const UINT Shuffle = _MM_SHUFFLE(PermuteW & 3, PermuteZ & 3, PermuteY & 3, PermuteX & 3);
2956 const bool WhichX = PermuteX > 3;
2957 const bool WhichY = PermuteY > 3;
2958 const bool WhichZ = PermuteZ > 3;
2959 const bool WhichW = PermuteW > 3;
2961 return XNAMathInternal::PermuteHelper<Shuffle, WhichX, WhichY, WhichZ, WhichW>::Permute(V1, V2);
2964 XMVECTOR c = XMVectorPermuteControl( PermuteX, PermuteY, PermuteZ, PermuteW );
2965 return XMVectorPermute( V1, V2, c );
2970 // Special-case permute templates
2971 template<> inline XMVECTOR XMVectorPermute<0,1,2,3>(FXMVECTOR V1, FXMVECTOR V2) { (V2); return V1; }
2972 template<> inline XMVECTOR XMVectorPermute<4,5,6,7>(FXMVECTOR V1, FXMVECTOR V2) { (V1); return V2; }
2974 //------------------------------------------------------------------------------
2976 // General swizzle template
2977 template<UINT SwizzleX, UINT SwizzleY, UINT SwizzleZ, UINT SwizzleW>
2978 inline XMVECTOR XMVectorSwizzle(FXMVECTOR V)
2980 #if defined(_MSC_VER) && (_MSC_VER >= 1600)
2981 static_assert(SwizzleX <= 3, "SwizzleX template parameter out of range");
2982 static_assert(SwizzleY <= 3, "SwizzleY template parameter out of range");
2983 static_assert(SwizzleZ <= 3, "SwizzleZ template parameter out of range");
2984 static_assert(SwizzleW <= 3, "SwizzleW template parameter out of range");
2986 XMASSERT(SwizzleX <= 3);
2987 XMASSERT(SwizzleY <= 3);
2988 XMASSERT(SwizzleZ <= 3);
2989 XMASSERT(SwizzleW <= 3);
2992 #if defined(_XM_SSE_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
2993 return _mm_shuffle_ps( V, V, _MM_SHUFFLE( SwizzleW, SwizzleZ, SwizzleY, SwizzleX ) );
2994 #elif defined(_XM_VMX128_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
2995 return __vpermwi(V, ((SwizzleX & 3) << 6) | ((SwizzleY & 3) << 4) | ((SwizzleZ & 3) << 2) | (SwizzleW & 3) );
2998 return XMVectorSwizzle( V, SwizzleX, SwizzleY, SwizzleZ, SwizzleW );
3003 // Specialized swizzles
3004 template<> inline XMVECTOR XMVectorSwizzle<0,1,2,3>(FXMVECTOR V) { return V; }
3006 //------------------------------------------------------------------------------
3008 template<UINT Elements>
3009 inline XMVECTOR XMVectorShiftLeft(FXMVECTOR V1, FXMVECTOR V2)
3011 #if defined(_MSC_VER) && (_MSC_VER >= 1600)
3012 static_assert( Elements < 4, "Elements template parameter out of range" );
3014 XMASSERT( Elements < 4 );
3017 #if defined(_XM_VMX128_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
3019 return XMVectorPermute<Elements, (Elements + 1), (Elements + 2), (Elements + 3)>(V1, V2);
3023 template<UINT Elements>
3024 inline XMVECTOR XMVectorRotateLeft(FXMVECTOR V)
3026 #if defined(_MSC_VER) && (_MSC_VER >= 1600)
3027 static_assert( Elements < 4, "Elements template parameter out of range" );
3029 XMASSERT( Elements < 4 );
3032 #if defined(_XM_VMX128_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
3034 return XMVectorSwizzle<Elements & 3, (Elements + 1) & 3, (Elements + 2) & 3, (Elements + 3) & 3>(V);
3038 template<UINT Elements>
3039 inline XMVECTOR XMVectorRotateRight(FXMVECTOR V)
3041 #if defined(_MSC_VER) && (_MSC_VER >= 1600)
3042 static_assert( Elements < 4, "Elements template parameter out of range" );
3044 XMASSERT( Elements < 4 );
3047 #if defined(_XM_VMX128_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
3049 return XMVectorSwizzle<(4 - Elements) & 3, (5 - Elements) & 3, (6 - Elements) & 3, (7 - Elements) & 3>(V);
3053 template<UINT VSLeftRotateElements, UINT Select0, UINT Select1, UINT Select2, UINT Select3>
3054 inline XMVECTOR XMVectorInsert(FXMVECTOR VD, FXMVECTOR VS)
3056 #if defined(_XM_VMX128_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
3058 XMVECTOR Control = XMVectorSelectControl(Select0&1, Select1&1, Select2&1, Select3&1);
3059 return XMVectorSelect( VD, XMVectorRotateLeft<VSLeftRotateElements>(VS), Control );
3063 #endif // __cplusplus
3065 /****************************************************************************
3069 ****************************************************************************/
3071 // The purpose of the following global constants is to prevent redundant
3072 // reloading of the constants when they are referenced by more than one
3073 // separate inline math routine called within the same function. Declaring
3074 // a constant locally within a routine is sufficient to prevent redundant
3075 // reloads of that constant when that single routine is called multiple
3076 // times in a function, but if the constant is used (and declared) in a
3077 // separate math routine it would be reloaded.
3079 #define XMGLOBALCONST extern CONST __declspec(selectany)
3081 XMGLOBALCONST XMVECTORF32 g_XMSinCoefficients0 = {1.0f, -0.166666667f, 8.333333333e-3f, -1.984126984e-4f};
3082 XMGLOBALCONST XMVECTORF32 g_XMSinCoefficients1 = {2.755731922e-6f, -2.505210839e-8f, 1.605904384e-10f, -7.647163732e-13f};
3083 XMGLOBALCONST XMVECTORF32 g_XMSinCoefficients2 = {2.811457254e-15f, -8.220635247e-18f, 1.957294106e-20f, -3.868170171e-23f};
3084 XMGLOBALCONST XMVECTORF32 g_XMCosCoefficients0 = {1.0f, -0.5f, 4.166666667e-2f, -1.388888889e-3f};
3085 XMGLOBALCONST XMVECTORF32 g_XMCosCoefficients1 = {2.480158730e-5f, -2.755731922e-7f, 2.087675699e-9f, -1.147074560e-11f};
3086 XMGLOBALCONST XMVECTORF32 g_XMCosCoefficients2 = {4.779477332e-14f, -1.561920697e-16f, 4.110317623e-19f, -8.896791392e-22f};
3087 XMGLOBALCONST XMVECTORF32 g_XMTanCoefficients0 = {1.0f, 0.333333333f, 0.133333333f, 5.396825397e-2f};
3088 XMGLOBALCONST XMVECTORF32 g_XMTanCoefficients1 = {2.186948854e-2f, 8.863235530e-3f, 3.592128167e-3f, 1.455834485e-3f};
3089 XMGLOBALCONST XMVECTORF32 g_XMTanCoefficients2 = {5.900274264e-4f, 2.391290764e-4f, 9.691537707e-5f, 3.927832950e-5f};
3090 XMGLOBALCONST XMVECTORF32 g_XMASinCoefficients0 = {-0.05806367563904f, -0.41861972469416f, 0.22480114791621f, 2.17337241360606f};
3091 XMGLOBALCONST XMVECTORF32 g_XMASinCoefficients1 = {0.61657275907170f, 4.29696498283455f, -1.18942822255452f, -6.53784832094831f};
3092 XMGLOBALCONST XMVECTORF32 g_XMASinCoefficients2 = {-1.36926553863413f, -4.48179294237210f, 1.41810672941833f, 5.48179257935713f};
3093 XMGLOBALCONST XMVECTORF32 g_XMATanCoefficients0 = {1.0f, 0.333333334f, 0.2f, 0.142857143f};
3094 XMGLOBALCONST XMVECTORF32 g_XMATanCoefficients1 = {1.111111111e-1f, 9.090909091e-2f, 7.692307692e-2f, 6.666666667e-2f};
3095 XMGLOBALCONST XMVECTORF32 g_XMATanCoefficients2 = {5.882352941e-2f, 5.263157895e-2f, 4.761904762e-2f, 4.347826087e-2f};
3096 XMGLOBALCONST XMVECTORF32 g_XMSinEstCoefficients = {1.0f, -1.66521856991541e-1f, 8.199913018755e-3f, -1.61475937228e-4f};
3097 XMGLOBALCONST XMVECTORF32 g_XMCosEstCoefficients = {1.0f, -4.95348008918096e-1f, 3.878259962881e-2f, -9.24587976263e-4f};
3098 XMGLOBALCONST XMVECTORF32 g_XMTanEstCoefficients = {2.484f, -1.954923183e-1f, 2.467401101f, XM_1DIVPI};
3099 XMGLOBALCONST XMVECTORF32 g_XMATanEstCoefficients = {7.689891418951e-1f, 1.104742493348f, 8.661844266006e-1f, XM_PIDIV2};
3100 XMGLOBALCONST XMVECTORF32 g_XMASinEstCoefficients = {-1.36178272886711f, 2.37949493464538f, -8.08228565650486e-1f, 2.78440142746736e-1f};
3101 XMGLOBALCONST XMVECTORF32 g_XMASinEstConstants = {1.00000011921f, XM_PIDIV2, 0.0f, 0.0f};
3102 XMGLOBALCONST XMVECTORF32 g_XMPiConstants0 = {XM_PI, XM_2PI, XM_1DIVPI, XM_1DIV2PI};
3103 XMGLOBALCONST XMVECTORF32 g_XMIdentityR0 = {1.0f, 0.0f, 0.0f, 0.0f};
3104 XMGLOBALCONST XMVECTORF32 g_XMIdentityR1 = {0.0f, 1.0f, 0.0f, 0.0f};
3105 XMGLOBALCONST XMVECTORF32 g_XMIdentityR2 = {0.0f, 0.0f, 1.0f, 0.0f};
3106 XMGLOBALCONST XMVECTORF32 g_XMIdentityR3 = {0.0f, 0.0f, 0.0f, 1.0f};
3107 XMGLOBALCONST XMVECTORF32 g_XMNegIdentityR0 = {-1.0f,0.0f, 0.0f, 0.0f};
3108 XMGLOBALCONST XMVECTORF32 g_XMNegIdentityR1 = {0.0f,-1.0f, 0.0f, 0.0f};
3109 XMGLOBALCONST XMVECTORF32 g_XMNegIdentityR2 = {0.0f, 0.0f,-1.0f, 0.0f};
3110 XMGLOBALCONST XMVECTORF32 g_XMNegIdentityR3 = {0.0f, 0.0f, 0.0f,-1.0f};
3111 XMGLOBALCONST XMVECTORI32 g_XMNegativeZero = {0x80000000, 0x80000000, 0x80000000, 0x80000000};
3112 XMGLOBALCONST XMVECTORI32 g_XMNegate3 = {0x80000000, 0x80000000, 0x80000000, 0x00000000};
3113 XMGLOBALCONST XMVECTORI32 g_XMMask3 = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000};
3114 XMGLOBALCONST XMVECTORI32 g_XMMaskX = {0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000};
3115 XMGLOBALCONST XMVECTORI32 g_XMMaskY = {0x00000000, 0xFFFFFFFF, 0x00000000, 0x00000000};
3116 XMGLOBALCONST XMVECTORI32 g_XMMaskZ = {0x00000000, 0x00000000, 0xFFFFFFFF, 0x00000000};
3117 XMGLOBALCONST XMVECTORI32 g_XMMaskW = {0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF};
3118 XMGLOBALCONST XMVECTORF32 g_XMOne = { 1.0f, 1.0f, 1.0f, 1.0f};
3119 XMGLOBALCONST XMVECTORF32 g_XMOne3 = { 1.0f, 1.0f, 1.0f, 0.0f};
3120 XMGLOBALCONST XMVECTORF32 g_XMZero = { 0.0f, 0.0f, 0.0f, 0.0f};
3121 XMGLOBALCONST XMVECTORF32 g_XMNegativeOne = {-1.0f,-1.0f,-1.0f,-1.0f};
3122 XMGLOBALCONST XMVECTORF32 g_XMOneHalf = { 0.5f, 0.5f, 0.5f, 0.5f};
3123 XMGLOBALCONST XMVECTORF32 g_XMNegativeOneHalf = {-0.5f,-0.5f,-0.5f,-0.5f};
3124 XMGLOBALCONST XMVECTORF32 g_XMNegativeTwoPi = {-XM_2PI, -XM_2PI, -XM_2PI, -XM_2PI};
3125 XMGLOBALCONST XMVECTORF32 g_XMNegativePi = {-XM_PI, -XM_PI, -XM_PI, -XM_PI};
3126 XMGLOBALCONST XMVECTORF32 g_XMHalfPi = {XM_PIDIV2, XM_PIDIV2, XM_PIDIV2, XM_PIDIV2};
3127 XMGLOBALCONST XMVECTORF32 g_XMPi = {XM_PI, XM_PI, XM_PI, XM_PI};
3128 XMGLOBALCONST XMVECTORF32 g_XMReciprocalPi = {XM_1DIVPI, XM_1DIVPI, XM_1DIVPI, XM_1DIVPI};
3129 XMGLOBALCONST XMVECTORF32 g_XMTwoPi = {XM_2PI, XM_2PI, XM_2PI, XM_2PI};
3130 XMGLOBALCONST XMVECTORF32 g_XMReciprocalTwoPi = {XM_1DIV2PI, XM_1DIV2PI, XM_1DIV2PI, XM_1DIV2PI};
3131 XMGLOBALCONST XMVECTORF32 g_XMEpsilon = {1.192092896e-7f, 1.192092896e-7f, 1.192092896e-7f, 1.192092896e-7f};
3132 XMGLOBALCONST XMVECTORI32 g_XMInfinity = {0x7F800000, 0x7F800000, 0x7F800000, 0x7F800000};
3133 XMGLOBALCONST XMVECTORI32 g_XMQNaN = {0x7FC00000, 0x7FC00000, 0x7FC00000, 0x7FC00000};
3134 XMGLOBALCONST XMVECTORI32 g_XMQNaNTest = {0x007FFFFF, 0x007FFFFF, 0x007FFFFF, 0x007FFFFF};
3135 XMGLOBALCONST XMVECTORI32 g_XMAbsMask = {0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF};
3136 XMGLOBALCONST XMVECTORI32 g_XMFltMin = {0x00800000, 0x00800000, 0x00800000, 0x00800000};
3137 XMGLOBALCONST XMVECTORI32 g_XMFltMax = {0x7F7FFFFF, 0x7F7FFFFF, 0x7F7FFFFF, 0x7F7FFFFF};
3138 XMGLOBALCONST XMVECTORI32 g_XMNegOneMask = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
3139 XMGLOBALCONST XMVECTORI32 g_XMMaskA8R8G8B8 = {0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000};
3140 XMGLOBALCONST XMVECTORI32 g_XMFlipA8R8G8B8 = {0x00000000, 0x00000000, 0x00000000, 0x80000000};
3141 XMGLOBALCONST XMVECTORF32 g_XMFixAA8R8G8B8 = {0.0f,0.0f,0.0f,(float)(0x80000000U)};
3142 XMGLOBALCONST XMVECTORF32 g_XMNormalizeA8R8G8B8 = {1.0f/(255.0f*(float)(0x10000)),1.0f/(255.0f*(float)(0x100)),1.0f/255.0f,1.0f/(255.0f*(float)(0x1000000))};
3143 XMGLOBALCONST XMVECTORI32 g_XMMaskA2B10G10R10 = {0x000003FF, 0x000FFC00, 0x3FF00000, 0xC0000000};
3144 XMGLOBALCONST XMVECTORI32 g_XMFlipA2B10G10R10 = {0x00000200, 0x00080000, 0x20000000, 0x80000000};
3145 XMGLOBALCONST XMVECTORF32 g_XMFixAA2B10G10R10 = {-512.0f,-512.0f*(float)(0x400),-512.0f*(float)(0x100000),(float)(0x80000000U)};
3146 XMGLOBALCONST XMVECTORF32 g_XMNormalizeA2B10G10R10 = {1.0f/511.0f,1.0f/(511.0f*(float)(0x400)),1.0f/(511.0f*(float)(0x100000)),1.0f/(3.0f*(float)(0x40000000))};
3147 XMGLOBALCONST XMVECTORI32 g_XMMaskX16Y16 = {0x0000FFFF, 0xFFFF0000, 0x00000000, 0x00000000};
3148 XMGLOBALCONST XMVECTORI32 g_XMFlipX16Y16 = {0x00008000, 0x00000000, 0x00000000, 0x00000000};
3149 XMGLOBALCONST XMVECTORF32 g_XMFixX16Y16 = {-32768.0f,0.0f,0.0f,0.0f};
3150 XMGLOBALCONST XMVECTORF32 g_XMNormalizeX16Y16 = {1.0f/32767.0f,1.0f/(32767.0f*65536.0f),0.0f,0.0f};
3151 XMGLOBALCONST XMVECTORI32 g_XMMaskX16Y16Z16W16 = {0x0000FFFF, 0x0000FFFF, 0xFFFF0000, 0xFFFF0000};
3152 XMGLOBALCONST XMVECTORI32 g_XMFlipX16Y16Z16W16 = {0x00008000, 0x00008000, 0x00000000, 0x00000000};
3153 XMGLOBALCONST XMVECTORF32 g_XMFixX16Y16Z16W16 = {-32768.0f,-32768.0f,0.0f,0.0f};
3154 XMGLOBALCONST XMVECTORF32 g_XMNormalizeX16Y16Z16W16 = {1.0f/32767.0f,1.0f/32767.0f,1.0f/(32767.0f*65536.0f),1.0f/(32767.0f*65536.0f)};
3155 XMGLOBALCONST XMVECTORF32 g_XMNoFraction = {8388608.0f,8388608.0f,8388608.0f,8388608.0f};
3156 XMGLOBALCONST XMVECTORI32 g_XMMaskByte = {0x000000FF, 0x000000FF, 0x000000FF, 0x000000FF};
3157 XMGLOBALCONST XMVECTORF32 g_XMNegateX = {-1.0f, 1.0f, 1.0f, 1.0f};
3158 XMGLOBALCONST XMVECTORF32 g_XMNegateY = { 1.0f,-1.0f, 1.0f, 1.0f};
3159 XMGLOBALCONST XMVECTORF32 g_XMNegateZ = { 1.0f, 1.0f,-1.0f, 1.0f};
3160 XMGLOBALCONST XMVECTORF32 g_XMNegateW = { 1.0f, 1.0f, 1.0f,-1.0f};
3161 XMGLOBALCONST XMVECTORI32 g_XMSelect0101 = {XM_SELECT_0, XM_SELECT_1, XM_SELECT_0, XM_SELECT_1};
3162 XMGLOBALCONST XMVECTORI32 g_XMSelect1010 = {XM_SELECT_1, XM_SELECT_0, XM_SELECT_1, XM_SELECT_0};
3163 XMGLOBALCONST XMVECTORI32 g_XMOneHalfMinusEpsilon = { 0x3EFFFFFD, 0x3EFFFFFD, 0x3EFFFFFD, 0x3EFFFFFD};
3164 XMGLOBALCONST XMVECTORI32 g_XMSelect1000 = {XM_SELECT_1, XM_SELECT_0, XM_SELECT_0, XM_SELECT_0};
3165 XMGLOBALCONST XMVECTORI32 g_XMSelect1100 = {XM_SELECT_1, XM_SELECT_1, XM_SELECT_0, XM_SELECT_0};
3166 XMGLOBALCONST XMVECTORI32 g_XMSelect1110 = {XM_SELECT_1, XM_SELECT_1, XM_SELECT_1, XM_SELECT_0};
3167 XMGLOBALCONST XMVECTORI32 g_XMSwizzleXYXY = {XM_PERMUTE_0X, XM_PERMUTE_0Y, XM_PERMUTE_0X, XM_PERMUTE_0Y};
3168 XMGLOBALCONST XMVECTORI32 g_XMSwizzleXYZX = {XM_PERMUTE_0X, XM_PERMUTE_0Y, XM_PERMUTE_0Z, XM_PERMUTE_0X};
3169 XMGLOBALCONST XMVECTORI32 g_XMSwizzleYXZW = {XM_PERMUTE_0Y, XM_PERMUTE_0X, XM_PERMUTE_0Z, XM_PERMUTE_0W};
3170 XMGLOBALCONST XMVECTORI32 g_XMSwizzleYZXW = {XM_PERMUTE_0Y, XM_PERMUTE_0Z, XM_PERMUTE_0X, XM_PERMUTE_0W};
3171 XMGLOBALCONST XMVECTORI32 g_XMSwizzleZXYW = {XM_PERMUTE_0Z, XM_PERMUTE_0X, XM_PERMUTE_0Y, XM_PERMUTE_0W};
3172 XMGLOBALCONST XMVECTORI32 g_XMPermute0X0Y1X1Y = {XM_PERMUTE_0X, XM_PERMUTE_0Y, XM_PERMUTE_1X, XM_PERMUTE_1Y};
3173 XMGLOBALCONST XMVECTORI32 g_XMPermute0Z0W1Z1W = {XM_PERMUTE_0Z, XM_PERMUTE_0W, XM_PERMUTE_1Z, XM_PERMUTE_1W};
3174 XMGLOBALCONST XMVECTORF32 g_XMFixupY16 = {1.0f,1.0f/65536.0f,0.0f,0.0f};
3175 XMGLOBALCONST XMVECTORF32 g_XMFixupY16W16 = {1.0f,1.0f,1.0f/65536.0f,1.0f/65536.0f};
3176 XMGLOBALCONST XMVECTORI32 g_XMFlipY = {0,0x80000000,0,0};
3177 XMGLOBALCONST XMVECTORI32 g_XMFlipZ = {0,0,0x80000000,0};
3178 XMGLOBALCONST XMVECTORI32 g_XMFlipW = {0,0,0,0x80000000};
3179 XMGLOBALCONST XMVECTORI32 g_XMFlipYZ = {0,0x80000000,0x80000000,0};
3180 XMGLOBALCONST XMVECTORI32 g_XMFlipZW = {0,0,0x80000000,0x80000000};
3181 XMGLOBALCONST XMVECTORI32 g_XMFlipYW = {0,0x80000000,0,0x80000000};
3182 XMGLOBALCONST XMVECTORI32 g_XMMaskHenD3 = {0x7FF,0x7ff<<11,0x3FF<<22,0};
3183 XMGLOBALCONST XMVECTORI32 g_XMMaskDHen3 = {0x3FF,0x7ff<<10,0x7FF<<21,0};
3184 XMGLOBALCONST XMVECTORF32 g_XMAddUHenD3 = {0,0,32768.0f*65536.0f,0};
3185 XMGLOBALCONST XMVECTORF32 g_XMAddHenD3 = {-1024.0f,-1024.0f*2048.0f,0,0};
3186 XMGLOBALCONST XMVECTORF32 g_XMAddDHen3 = {-512.0f,-1024.0f*1024.0f,0,0};
3187 XMGLOBALCONST XMVECTORF32 g_XMMulHenD3 = {1.0f,1.0f/2048.0f,1.0f/(2048.0f*2048.0f),0};
3188 XMGLOBALCONST XMVECTORF32 g_XMMulDHen3 = {1.0f,1.0f/1024.0f,1.0f/(1024.0f*2048.0f),0};
3189 XMGLOBALCONST XMVECTORI32 g_XMXorHenD3 = {0x400,0x400<<11,0,0};
3190 XMGLOBALCONST XMVECTORI32 g_XMXorDHen3 = {0x200,0x400<<10,0,0};
3191 XMGLOBALCONST XMVECTORI32 g_XMMaskIco4 = {0xFFFFF,0xFFFFF000,0xFFFFF,0xF0000000};
3192 XMGLOBALCONST XMVECTORI32 g_XMXorXIco4 = {0x80000,0,0x80000,0x80000000};
3193 XMGLOBALCONST XMVECTORI32 g_XMXorIco4 = {0x80000,0,0x80000,0};
3194 XMGLOBALCONST XMVECTORF32 g_XMAddXIco4 = {-8.0f*65536.0f,0,-8.0f*65536.0f,32768.0f*65536.0f};
3195 XMGLOBALCONST XMVECTORF32 g_XMAddUIco4 = {0,32768.0f*65536.0f,0,32768.0f*65536.0f};
3196 XMGLOBALCONST XMVECTORF32 g_XMAddIco4 = {-8.0f*65536.0f,0,-8.0f*65536.0f,0};
3197 XMGLOBALCONST XMVECTORF32 g_XMMulIco4 = {1.0f,1.0f/4096.0f,1.0f,1.0f/(4096.0f*65536.0f)};
3198 XMGLOBALCONST XMVECTORI32 g_XMMaskDec4 = {0x3FF,0x3FF<<10,0x3FF<<20,0x3<<30};
3199 XMGLOBALCONST XMVECTORI32 g_XMXorDec4 = {0x200,0x200<<10,0x200<<20,0};
3200 XMGLOBALCONST XMVECTORF32 g_XMAddUDec4 = {0,0,0,32768.0f*65536.0f};
3201 XMGLOBALCONST XMVECTORF32 g_XMAddDec4 = {-512.0f,-512.0f*1024.0f,-512.0f*1024.0f*1024.0f,0};
3202 XMGLOBALCONST XMVECTORF32 g_XMMulDec4 = {1.0f,1.0f/1024.0f,1.0f/(1024.0f*1024.0f),1.0f/(1024.0f*1024.0f*1024.0f)};
3203 XMGLOBALCONST XMVECTORI32 g_XMMaskByte4 = {0xFF,0xFF00,0xFF0000,0xFF000000};
3204 XMGLOBALCONST XMVECTORI32 g_XMXorByte4 = {0x80,0x8000,0x800000,0x00000000};
3205 XMGLOBALCONST XMVECTORF32 g_XMAddByte4 = {-128.0f,-128.0f*256.0f,-128.0f*65536.0f,0};
3206 XMGLOBALCONST XMVECTORF32 g_XMFixUnsigned = {32768.0f*65536.0f,32768.0f*65536.0f,32768.0f*65536.0f,32768.0f*65536.0f};
3207 XMGLOBALCONST XMVECTORF32 g_XMMaxInt = {65536.0f*32768.0f-128.0f,65536.0f*32768.0f-128.0f,65536.0f*32768.0f-128.0f,65536.0f*32768.0f-128.0f};
3208 XMGLOBALCONST XMVECTORF32 g_XMMaxUInt = {65536.0f*65536.0f-256.0f,65536.0f*65536.0f-256.0f,65536.0f*65536.0f-256.0f,65536.0f*65536.0f-256.0f};
3209 XMGLOBALCONST XMVECTORF32 g_XMUnsignedFix = {32768.0f*65536.0f,32768.0f*65536.0f,32768.0f*65536.0f,32768.0f*65536.0f};
3212 /****************************************************************************
3216 ****************************************************************************/
3218 #pragma warning(push)
3219 #pragma warning(disable:4068 4214 4204 4365 4616 6001)
3221 #pragma prefast(push)
3222 #pragma prefast(disable : 25000, "FXMVECTOR is 16 bytes")
3224 #if !defined(__cplusplus) && !defined(_XBOX) && defined(_XM_ISVS2005_)
3226 /* Work around VC 2005 bug where math.h defines logf with a semicolon at the end.
3227 * Note this is fixed as of Visual Studio 2005 Service Pack 1
3231 #define logf(x) ((float)log((double)(x)))
3233 #endif // !defined(__cplusplus) && !defined(_XBOX) && defined(_XM_ISVS2005_)
3236 //------------------------------------------------------------------------------
3238 #if !defined(_XM_NO_INTRINSICS_) && defined(_XM_VMX128_INTRINSICS_)
3241 XMFINLINE XMVECTOR XMVectorSetBinaryConstant(UINT C0, UINT C1, UINT C2, UINT C3)
3243 #if defined(_XM_NO_INTRINSICS_)
3244 XMVECTORU32 vResult;
3245 vResult.u[0] = (0-(C0&1)) & 0x3F800000;
3246 vResult.u[1] = (0-(C1&1)) & 0x3F800000;
3247 vResult.u[2] = (0-(C2&1)) & 0x3F800000;
3248 vResult.u[3] = (0-(C3&1)) & 0x3F800000;
3250 #else // XM_SSE_INTRINSICS_
3251 static const XMVECTORU32 g_vMask1 = {1,1,1,1};
3252 // Move the parms to a vector
3253 __m128i vTemp = _mm_set_epi32(C3,C2,C1,C0);
3254 // Mask off the low bits
3255 vTemp = _mm_and_si128(vTemp,g_vMask1);
3256 // 0xFFFFFFFF on true bits
3257 vTemp = _mm_cmpeq_epi32(vTemp,g_vMask1);
3258 // 0xFFFFFFFF -> 1.0f, 0x00000000 -> 0.0f
3259 vTemp = _mm_and_si128(vTemp,g_XMOne);
3260 return reinterpret_cast<const __m128 *>(&vTemp)[0];
3264 //------------------------------------------------------------------------------
3266 XMFINLINE XMVECTOR XMVectorSplatConstant(INT IntConstant, UINT DivExponent)
3268 #if defined(_XM_NO_INTRINSICS_)
3269 XMASSERT( IntConstant >= -16 && IntConstant <= 15 );
3270 XMASSERT(DivExponent<32);
3272 XMVECTORI32 V = { IntConstant, IntConstant, IntConstant, IntConstant };
3273 return XMConvertVectorIntToFloat( V.v, DivExponent);
3275 #else // XM_SSE_INTRINSICS_
3276 XMASSERT( IntConstant >= -16 && IntConstant <= 15 );
3277 XMASSERT(DivExponent<32);
3279 __m128i vScale = _mm_set1_epi32(IntConstant);
3280 // Convert to a float
3281 XMVECTOR vResult = _mm_cvtepi32_ps(vScale);
3282 // Convert DivExponent into 1.0f/(1<<DivExponent)
3283 UINT uScale = 0x3F800000U - (DivExponent << 23);
3284 // Splat the scalar value (It's really a float)
3285 vScale = _mm_set1_epi32(uScale);
3286 // Multiply by the reciprocal (Perform a right shift by DivExponent)
3287 vResult = _mm_mul_ps(vResult,reinterpret_cast<const __m128 *>(&vScale)[0]);
3292 //------------------------------------------------------------------------------
3294 XMFINLINE XMVECTOR XMVectorSplatConstantInt(INT IntConstant)
3296 #if defined(_XM_NO_INTRINSICS_)
3297 XMASSERT( IntConstant >= -16 && IntConstant <= 15 );
3299 XMVECTORI32 V = { IntConstant, IntConstant, IntConstant, IntConstant };
3302 #else // XM_SSE_INTRINSICS_
3303 XMASSERT( IntConstant >= -16 && IntConstant <= 15 );
3304 __m128i V = _mm_set1_epi32( IntConstant );
3305 return reinterpret_cast<__m128 *>(&V)[0];
3309 //------------------------------------------------------------------------------
3311 XMFINLINE XMVECTOR XMVectorShiftLeft(FXMVECTOR V1, FXMVECTOR V2, UINT Elements)
3313 return XMVectorPermute(V1, V2, XMVectorPermuteControl((Elements), ((Elements) + 1), ((Elements) + 2), ((Elements) + 3)));
3316 //------------------------------------------------------------------------------
3318 XMFINLINE XMVECTOR XMVectorRotateLeft(FXMVECTOR V, UINT Elements)
3320 #if defined(_XM_NO_INTRINSICS_)
3321 XMASSERT( Elements < 4 );
3323 XMVECTORF32 vResult = { V.vector4_f32[Elements & 3], V.vector4_f32[(Elements + 1) & 3],
3324 V.vector4_f32[(Elements + 2) & 3], V.vector4_f32[(Elements + 3) & 3] };
3327 #else // XM_SSE_INTRINSICS_
3328 FLOAT fx = XMVectorGetByIndex(V,(Elements) & 3);
3329 FLOAT fy = XMVectorGetByIndex(V,((Elements) + 1) & 3);
3330 FLOAT fz = XMVectorGetByIndex(V,((Elements) + 2) & 3);
3331 FLOAT fw = XMVectorGetByIndex(V,((Elements) + 3) & 3);
3332 return _mm_set_ps( fw, fz, fy, fx );
3336 //------------------------------------------------------------------------------
3338 XMFINLINE XMVECTOR XMVectorRotateRight(FXMVECTOR V, UINT Elements)
3340 #if defined(_XM_NO_INTRINSICS_)
3341 XMASSERT( Elements < 4 );
3343 XMVECTORF32 vResult = { V.vector4_f32[(4 - (Elements)) & 3], V.vector4_f32[(5 - (Elements)) & 3],
3344 V.vector4_f32[(6 - (Elements)) & 3], V.vector4_f32[(7 - (Elements)) & 3] };
3347 #else // XM_SSE_INTRINSICS_
3348 FLOAT fx = XMVectorGetByIndex(V,(4 - (Elements)) & 3);
3349 FLOAT fy = XMVectorGetByIndex(V,(5 - (Elements)) & 3);
3350 FLOAT fz = XMVectorGetByIndex(V,(6 - (Elements)) & 3);
3351 FLOAT fw = XMVectorGetByIndex(V,(7 - (Elements)) & 3);
3352 return _mm_set_ps( fw, fz, fy, fx );
3356 //------------------------------------------------------------------------------
3358 XMFINLINE XMVECTOR XMVectorSwizzle(FXMVECTOR V, UINT E0, UINT E1, UINT E2, UINT E3)
3360 #if defined(_XM_NO_INTRINSICS_)
3361 XMASSERT( (E0 < 4) && (E1 < 4) && (E2 < 4) && (E3 < 4) );
3363 XMVECTORF32 vResult = { V.vector4_f32[E0], V.vector4_f32[E1], V.vector4_f32[E2], V.vector4_f32[E3] };
3366 #else // XM_SSE_INTRINSICS_
3367 FLOAT fx = XMVectorGetByIndex(V,E0);
3368 FLOAT fy = XMVectorGetByIndex(V,E1);
3369 FLOAT fz = XMVectorGetByIndex(V,E2);
3370 FLOAT fw = XMVectorGetByIndex(V,E3);
3371 return _mm_set_ps( fw, fz, fy, fx );
3375 //------------------------------------------------------------------------------
3377 XMFINLINE XMVECTOR XMVectorInsert(FXMVECTOR VD, FXMVECTOR VS, UINT VSLeftRotateElements,
3378 UINT Select0, UINT Select1, UINT Select2, UINT Select3)
3380 XMVECTOR Control = XMVectorSelectControl(Select0&1, Select1&1, Select2&1, Select3&1);
3381 return XMVectorSelect( VD, XMVectorRotateLeft(VS, VSLeftRotateElements), Control );
3386 //------------------------------------------------------------------------------
3388 #include "xnamathconvert.inl"
3389 #include "xnamathvector.inl"
3390 #include "xnamathmatrix.inl"
3391 #include "xnamathmisc.inl"
3393 #pragma prefast(pop)
3394 #pragma warning(pop)
3396 #endif // __XNAMATH_H__