xnamath.h

Go to the documentation of this file.

/*++

Copyright (c) Microsoft Corporation. All rights reserved.

Module Name:

 xnamath.h

Abstract:

 XNA math library for Windows and Xbox 360
--*/

#if defined(_MSC_VER) && (_MSC_VER > 1000)
#pragma once
#endif

#ifndef __XNAMATH_H__
#define __XNAMATH_H__

#ifdef __XBOXMATH_H__
#error XNAMATH and XBOXMATH are incompatible in the same compilation module. Use one or the other.
#endif

#define XNAMATH_VERSION 203

#if !defined(_XM_X64_) && !defined(_XM_X86_)
#if defined(_M_AMD64) || defined(_AMD64_)
#define _XM_X64_
#elif defined(_M_IX86) || defined(_X86_)
#define _XM_X86_
#endif
#endif

#if !defined(_XM_BIGENDIAN_) && !defined(_XM_LITTLEENDIAN_)
#if defined(_XM_X64_) || defined(_XM_X86_)
#define _XM_LITTLEENDIAN_
#elif defined(_XBOX_VER)
#define _XM_BIGENDIAN_
#else
#error xnamath.h only supports x86, x64, or XBox 360 targets
#endif
#endif

#if defined(_XM_X86_) || defined(_XM_X64_)
#define _XM_SSE_INTRINSICS_
#if !defined(__cplusplus) && !defined(_XM_NO_INTRINSICS_)
#error xnamath.h only supports C compliation for Xbox 360 targets and no intrinsics cases for x86/x64
#endif
#elif defined(_XBOX_VER)
#if !defined(__VMX128_SUPPORTED) && !defined(_XM_NO_INTRINSICS_)
#error xnamath.h requires VMX128 compiler support for XBOX 360
#endif // !__VMX128_SUPPORTED && !_XM_NO_INTRINSICS_
#define _XM_VMX128_INTRINSICS_
#else
#error xnamath.h only supports x86, x64, or XBox 360 targets
#endif


#if defined(_XM_SSE_INTRINSICS_)
#ifndef _XM_NO_INTRINSICS_
#include <xmmintrin.h>
#include <emmintrin.h>
#endif
#elif defined(_XM_VMX128_INTRINSICS_)
#error This version of xnamath.h is for Windows use only
#endif

#if defined(_XM_SSE_INTRINSICS_)
#pragma warning(push)
#pragma warning(disable:4985)
#endif
#include <math.h>
#if defined(_XM_SSE_INTRINSICS_)
#pragma warning(pop)
#endif

#include <sal.h>

#if !defined(XMINLINE)
#if !defined(XM_NO_MISALIGNED_VECTOR_ACCESS)
#define XMINLINE __inline
#else
#define XMINLINE __forceinline
#endif
#endif

#if !defined(XMFINLINE)
#define XMFINLINE __forceinline
#endif

#if !defined(XMDEBUG)
#if defined(_DEBUG)
#define XMDEBUG
#endif
#endif // !XMDEBUG

#if !defined(XMASSERT)
#if defined(_PREFAST_)
#define XMASSERT(Expression) __analysis_assume((Expression))
#elif defined(XMDEBUG) // !_PREFAST_
#define XMASSERT(Expression) ((VOID)((Expression) || (XMAssert(#Expression, __FILE__, __LINE__), 0)))
#else // !XMDEBUG
#define XMASSERT(Expression) ((VOID)0)
#endif // !XMDEBUG
#endif // !XMASSERT

#if !defined(XM_NO_ALIGNMENT)
#define _DECLSPEC_ALIGN_16_ __declspec(align(16))
#else
#define _DECLSPEC_ALIGN_16_
#endif


#if defined(_MSC_VER) && (_MSC_VER<1500) && (_MSC_VER>=1400)
#define _XM_ISVS2005_
#endif

/****************************************************************************
 *
 * Constant definitions
 *
 ****************************************************************************/

#define XM_PI 3.141592654f
#define XM_2PI 6.283185307f
#define XM_1DIVPI 0.318309886f
#define XM_1DIV2PI 0.159154943f
#define XM_PIDIV2 1.570796327f
#define XM_PIDIV4 0.785398163f

#define XM_SELECT_0 0x00000000
#define XM_SELECT_1 0xFFFFFFFF

#define XM_PERMUTE_0X 0x00010203
#define XM_PERMUTE_0Y 0x04050607
#define XM_PERMUTE_0Z 0x08090A0B
#define XM_PERMUTE_0W 0x0C0D0E0F
#define XM_PERMUTE_1X 0x10111213
#define XM_PERMUTE_1Y 0x14151617
#define XM_PERMUTE_1Z 0x18191A1B
#define XM_PERMUTE_1W 0x1C1D1E1F

#define XM_CRMASK_CR6 0x000000F0
#define XM_CRMASK_CR6TRUE 0x00000080
#define XM_CRMASK_CR6FALSE 0x00000020
#define XM_CRMASK_CR6BOUNDS XM_CRMASK_CR6FALSE

#define XM_CACHE_LINE_SIZE 64

/****************************************************************************
 *
 * Macros
 *
 ****************************************************************************/

// Unit conversion

XMFINLINE FLOAT XMConvertToRadians(FLOAT fDegrees) { return fDegrees * (XM_PI / 180.0f); }
XMFINLINE FLOAT XMConvertToDegrees(FLOAT fRadians) { return fRadians * (180.0f / XM_PI); }

// Condition register evaluation proceeding a recording (Rc) comparison

#define XMComparisonAllTrue(CR) (((CR) & XM_CRMASK_CR6TRUE) == XM_CRMASK_CR6TRUE)
#define XMComparisonAnyTrue(CR) (((CR) & XM_CRMASK_CR6FALSE) != XM_CRMASK_CR6FALSE)
#define XMComparisonAllFalse(CR) (((CR) & XM_CRMASK_CR6FALSE) == XM_CRMASK_CR6FALSE)
#define XMComparisonAnyFalse(CR) (((CR) & XM_CRMASK_CR6TRUE) != XM_CRMASK_CR6TRUE)
#define XMComparisonMixed(CR) (((CR) & XM_CRMASK_CR6) == 0)
#define XMComparisonAllInBounds(CR) (((CR) & XM_CRMASK_CR6BOUNDS) == XM_CRMASK_CR6BOUNDS)
#define XMComparisonAnyOutOfBounds(CR) (((CR) & XM_CRMASK_CR6BOUNDS) != XM_CRMASK_CR6BOUNDS)


#define XMMin(a, b) (((a) < (b)) ? (a) : (b))
#define XMMax(a, b) (((a) > (b)) ? (a) : (b))

/****************************************************************************
 *
 * Data types
 *
 ****************************************************************************/

#pragma warning(push)
#pragma warning(disable:4201 4365 4324)

#if !defined (_XM_X86_) && !defined(_XM_X64_)
#pragma bitfield_order(push)
#pragma bitfield_order(lsb_to_msb)
#endif // !_XM_X86_ && !_XM_X64_

#if defined(_XM_NO_INTRINSICS_) && !defined(_XBOX_VER)
// The __vector4 structure is an intrinsic on Xbox but must be separately defined
// for x86/x64
typedef struct __vector4
{
 union
 {
 float vector4_f32[4];
 unsigned int vector4_u32[4];
#ifndef XM_STRICT_VECTOR4
 struct
 {
 FLOAT x;
 FLOAT y;
 FLOAT z;
 FLOAT w;
 };
 FLOAT v[4];
 UINT u[4];
#endif // !XM_STRICT_VECTOR4
 };
} __vector4;
#endif // _XM_NO_INTRINSICS_

#if (defined (_XM_X86_) || defined(_XM_X64_)) && defined(_XM_NO_INTRINSICS_)
typedef UINT __vector4i[4];
#else
typedef __declspec(align(16)) UINT __vector4i[4];
#endif

// Vector intrinsic: Four 32 bit floating point components aligned on a 16 byte 
// boundary and mapped to hardware vector registers
#if defined(_XM_SSE_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
typedef __m128 XMVECTOR;
#else
typedef __vector4 XMVECTOR;
#endif

// Conversion types for constants
typedef _DECLSPEC_ALIGN_16_ struct XMVECTORF32 {
 union {
 float f[4];
 XMVECTOR v;
 };

#if defined(__cplusplus)
 inline operator XMVECTOR() const { return v; }
#if !defined(_XM_NO_INTRINSICS_) && defined(_XM_SSE_INTRINSICS_)
 inline operator __m128i() const { return reinterpret_cast<const __m128i *>(&v)[0]; }
 inline operator __m128d() const { return reinterpret_cast<const __m128d *>(&v)[0]; }
#endif
#endif // __cplusplus
} XMVECTORF32;

typedef _DECLSPEC_ALIGN_16_ struct XMVECTORI32 {
 union {
 INT i[4];
 XMVECTOR v;
 };
#if defined(__cplusplus)
 inline operator XMVECTOR() const { return v; }
#if !defined(_XM_NO_INTRINSICS_) && defined(_XM_SSE_INTRINSICS_)
 inline operator __m128i() const { return reinterpret_cast<const __m128i *>(&v)[0]; }
 inline operator __m128d() const { return reinterpret_cast<const __m128d *>(&v)[0]; }
#endif
#endif // __cplusplus
} XMVECTORI32;

typedef _DECLSPEC_ALIGN_16_ struct XMVECTORU8 {
 union {
 BYTE u[16];
 XMVECTOR v;
 };
#if defined(__cplusplus)
 inline operator XMVECTOR() const { return v; }
#if !defined(_XM_NO_INTRINSICS_) && defined(_XM_SSE_INTRINSICS_)
 inline operator __m128i() const { return reinterpret_cast<const __m128i *>(&v)[0]; }
 inline operator __m128d() const { return reinterpret_cast<const __m128d *>(&v)[0]; }
#endif
#endif // __cplusplus
} XMVECTORU8;

typedef _DECLSPEC_ALIGN_16_ struct XMVECTORU32 {
 union {
 UINT u[4];
 XMVECTOR v;
 };
#if defined(__cplusplus)
 inline operator XMVECTOR() const { return v; }
#if !defined(_XM_NO_INTRINSICS_) && defined(_XM_SSE_INTRINSICS_)
 inline operator __m128i() const { return reinterpret_cast<const __m128i *>(&v)[0]; }
 inline operator __m128d() const { return reinterpret_cast<const __m128d *>(&v)[0]; }
#endif
#endif // __cplusplus
} XMVECTORU32;

// Fix-up for (1st-3rd) XMVECTOR parameters that are pass-in-register for x86 and Xbox 360, but not for other targets
#if defined(_XM_VMX128_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
typedef const XMVECTOR FXMVECTOR;
#elif defined(_XM_X86_) && !defined(_XM_NO_INTRINSICS_)
typedef const XMVECTOR FXMVECTOR;
#elif defined(__cplusplus)
typedef const XMVECTOR& FXMVECTOR;
#else
typedef const XMVECTOR FXMVECTOR;
#endif

// Fix-up for (4th+) XMVECTOR parameters to pass in-register for Xbox 360 and by reference otherwise
#if defined(_XM_VMX128_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
typedef const XMVECTOR CXMVECTOR;
#elif defined(__cplusplus)
typedef const XMVECTOR& CXMVECTOR;
#else
typedef const XMVECTOR CXMVECTOR;
#endif

// Vector operators
#if defined(__cplusplus) && !defined(XM_NO_OPERATOR_OVERLOADS)

XMVECTOR operator+ (FXMVECTOR V);
XMVECTOR operator- (FXMVECTOR V);

XMVECTOR& operator+= (XMVECTOR& V1, FXMVECTOR V2);
XMVECTOR& operator-= (XMVECTOR& V1, FXMVECTOR V2);
XMVECTOR& operator*= (XMVECTOR& V1, FXMVECTOR V2);
XMVECTOR& operator/= (XMVECTOR& V1, FXMVECTOR V2);
XMVECTOR& operator*= (XMVECTOR& V, FLOAT S);
XMVECTOR& operator/= (XMVECTOR& V, FLOAT S);

XMVECTOR operator+ (FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR operator- (FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR operator* (FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR operator/ (FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR operator* (FXMVECTOR V, FLOAT S);
XMVECTOR operator* (FLOAT S, FXMVECTOR V);
XMVECTOR operator/ (FXMVECTOR V, FLOAT S);

#endif // __cplusplus && !XM_NO_OPERATOR_OVERLOADS

// Matrix type: Sixteen 32 bit floating point components aligned on a
// 16 byte boundary and mapped to four hardware vector registers
#if (defined(_XM_X86_) || defined(_XM_X64_)) && defined(_XM_NO_INTRINSICS_)
typedef struct _XMMATRIX
#else
typedef _DECLSPEC_ALIGN_16_ struct _XMMATRIX
#endif
{
 union
 {
 XMVECTOR r[4];
 struct
 {
 FLOAT _11, _12, _13, _14;
 FLOAT _21, _22, _23, _24;
 FLOAT _31, _32, _33, _34;
 FLOAT _41, _42, _43, _44;
 };
 FLOAT m[4][4];
 };

#ifdef __cplusplus

 _XMMATRIX() {};
 _XMMATRIX(FXMVECTOR R0, FXMVECTOR R1, FXMVECTOR R2, CXMVECTOR R3);
 _XMMATRIX(FLOAT m00, FLOAT m01, FLOAT m02, FLOAT m03,
 FLOAT m10, FLOAT m11, FLOAT m12, FLOAT m13,
 FLOAT m20, FLOAT m21, FLOAT m22, FLOAT m23,
 FLOAT m30, FLOAT m31, FLOAT m32, FLOAT m33);
 _XMMATRIX(CONST FLOAT *pArray);

 FLOAT operator() (UINT Row, UINT Column) CONST { return m[Row][Column]; }
 FLOAT& operator() (UINT Row, UINT Column) { return m[Row][Column]; }

 _XMMATRIX& operator= (CONST _XMMATRIX& M);

#ifndef XM_NO_OPERATOR_OVERLOADS
 _XMMATRIX& operator*= (CONST _XMMATRIX& M);
 _XMMATRIX operator* (CONST _XMMATRIX& M) CONST;
#endif // !XM_NO_OPERATOR_OVERLOADS

#endif // __cplusplus

} XMMATRIX;

// Fix-up for XMMATRIX parameters to pass in-register on Xbox 360, by reference otherwise
#if defined(_XM_VMX128_INTRINSICS_)
typedef const XMMATRIX CXMMATRIX;
#elif defined(__cplusplus)
typedef const XMMATRIX& CXMMATRIX;
#else
typedef const XMMATRIX CXMMATRIX;
#endif

// 16 bit floating point number consisting of a sign bit, a 5 bit biased 
// exponent, and a 10 bit mantissa
//typedef WORD HALF;
typedef USHORT HALF;

// 2D Vector; 32 bit floating point components
typedef struct _XMFLOAT2
{
 FLOAT x;
 FLOAT y;

#ifdef __cplusplus

 _XMFLOAT2() {};
 _XMFLOAT2(FLOAT _x, FLOAT _y) : x(_x), y(_y) {};
 _XMFLOAT2(CONST FLOAT *pArray);

 _XMFLOAT2& operator= (CONST _XMFLOAT2& Float2);

#endif // __cplusplus

} XMFLOAT2;

// 2D Vector; 32 bit floating point components aligned on a 16 byte boundary
#ifdef __cplusplus
__declspec(align(16)) struct XMFLOAT2A : public XMFLOAT2
{
 XMFLOAT2A() : XMFLOAT2() {};
 XMFLOAT2A(FLOAT _x, FLOAT _y) : XMFLOAT2(_x, _y) {};
 XMFLOAT2A(CONST FLOAT *pArray) : XMFLOAT2(pArray) {};

 XMFLOAT2A& operator= (CONST XMFLOAT2A& Float2);
};
#else
typedef __declspec(align(16)) XMFLOAT2 XMFLOAT2A;
#endif // __cplusplus

// 2D Vector; 16 bit floating point components
typedef struct _XMHALF2
{
 HALF x;
 HALF y;

#ifdef __cplusplus

 _XMHALF2() {};
 _XMHALF2(HALF _x, HALF _y) : x(_x), y(_y) {};
 _XMHALF2(CONST HALF *pArray);
 _XMHALF2(FLOAT _x, FLOAT _y);
 _XMHALF2(CONST FLOAT *pArray);

 _XMHALF2& operator= (CONST _XMHALF2& Half2);

#endif // __cplusplus

} XMHALF2;

// 2D Vector; 16 bit signed normalized integer components
typedef struct _XMSHORTN2
{
 SHORT x;
 SHORT y;

#ifdef __cplusplus

 _XMSHORTN2() {};
 _XMSHORTN2(SHORT _x, SHORT _y) : x(_x), y(_y) {};
 _XMSHORTN2(CONST SHORT *pArray);
 _XMSHORTN2(FLOAT _x, FLOAT _y);
 _XMSHORTN2(CONST FLOAT *pArray);

 _XMSHORTN2& operator= (CONST _XMSHORTN2& ShortN2);

#endif // __cplusplus

} XMSHORTN2;

// 2D Vector; 16 bit signed integer components
typedef struct _XMSHORT2
{
 SHORT x;
 SHORT y;

#ifdef __cplusplus

 _XMSHORT2() {};
 _XMSHORT2(SHORT _x, SHORT _y) : x(_x), y(_y) {};
 _XMSHORT2(CONST SHORT *pArray);
 _XMSHORT2(FLOAT _x, FLOAT _y);
 _XMSHORT2(CONST FLOAT *pArray);

 _XMSHORT2& operator= (CONST _XMSHORT2& Short2);

#endif // __cplusplus

} XMSHORT2;

// 2D Vector; 16 bit unsigned normalized integer components
typedef struct _XMUSHORTN2
{
 USHORT x;
 USHORT y;

#ifdef __cplusplus

 _XMUSHORTN2() {};
 _XMUSHORTN2(USHORT _x, USHORT _y) : x(_x), y(_y) {};
 _XMUSHORTN2(CONST USHORT *pArray);
 _XMUSHORTN2(FLOAT _x, FLOAT _y);
 _XMUSHORTN2(CONST FLOAT *pArray);

 _XMUSHORTN2& operator= (CONST _XMUSHORTN2& UShortN2);

#endif // __cplusplus

} XMUSHORTN2;

// 2D Vector; 16 bit unsigned integer components
typedef struct _XMUSHORT2
{
 USHORT x;
 USHORT y;

#ifdef __cplusplus

 _XMUSHORT2() {};
 _XMUSHORT2(USHORT _x, USHORT _y) : x(_x), y(_y) {};
 _XMUSHORT2(CONST USHORT *pArray);
 _XMUSHORT2(FLOAT _x, FLOAT _y);
 _XMUSHORT2(CONST FLOAT *pArray);

 _XMUSHORT2& operator= (CONST _XMUSHORT2& UShort2);

#endif // __cplusplus

} XMUSHORT2;

// 3D Vector; 32 bit floating point components
typedef struct _XMFLOAT3
{
 FLOAT x;
 FLOAT y;
 FLOAT z;

#ifdef __cplusplus

 _XMFLOAT3() {};
 _XMFLOAT3(FLOAT _x, FLOAT _y, FLOAT _z) : x(_x), y(_y), z(_z) {};
 _XMFLOAT3(CONST FLOAT *pArray);

 _XMFLOAT3& operator= (CONST _XMFLOAT3& Float3);

#endif // __cplusplus

} XMFLOAT3;

// 3D Vector; 32 bit floating point components aligned on a 16 byte boundary
#ifdef __cplusplus
__declspec(align(16)) struct XMFLOAT3A : public XMFLOAT3
{
 XMFLOAT3A() : XMFLOAT3() {};
 XMFLOAT3A(FLOAT _x, FLOAT _y, FLOAT _z) : XMFLOAT3(_x, _y, _z) {};
 XMFLOAT3A(CONST FLOAT *pArray) : XMFLOAT3(pArray) {};

 XMFLOAT3A& operator= (CONST XMFLOAT3A& Float3);
};
#else
typedef __declspec(align(16)) XMFLOAT3 XMFLOAT3A; 
#endif // __cplusplus

// 3D Vector; 11-11-10 bit normalized components packed into a 32 bit integer
// The normalized 3D Vector is packed into 32 bits as follows: a 10 bit signed, 
// normalized integer for the z component and 11 bit signed, normalized 
// integers for the x and y components. The z component is stored in the 
// most significant bits and the x component in the least significant bits
// (Z10Y11X11): [32] zzzzzzzz zzyyyyyy yyyyyxxx xxxxxxxx [0]
typedef struct _XMHENDN3
{
 union
 {
 struct
 {
 INT x : 11; // -1023/1023 to 1023/1023
 INT y : 11; // -1023/1023 to 1023/1023
 INT z : 10; // -511/511 to 511/511
 };
 UINT v;
 };

#ifdef __cplusplus

 _XMHENDN3() {};
 _XMHENDN3(UINT Packed) : v(Packed) {};
 _XMHENDN3(FLOAT _x, FLOAT _y, FLOAT _z);
 _XMHENDN3(CONST FLOAT *pArray);

 operator UINT () { return v; }

 _XMHENDN3& operator= (CONST _XMHENDN3& HenDN3);
 _XMHENDN3& operator= (CONST UINT Packed);

#endif // __cplusplus

} XMHENDN3;

// 3D Vector; 11-11-10 bit components packed into a 32 bit integer
// The 3D Vector is packed into 32 bits as follows: a 10 bit signed, 
// integer for the z component and 11 bit signed integers for the 
// x and y components. The z component is stored in the 
// most significant bits and the x component in the least significant bits
// (Z10Y11X11): [32] zzzzzzzz zzyyyyyy yyyyyxxx xxxxxxxx [0]
typedef struct _XMHEND3
{
 union
 {
 struct
 {
 INT x : 11; // -1023 to 1023
 INT y : 11; // -1023 to 1023
 INT z : 10; // -511 to 511
 };
 UINT v;
 };

#ifdef __cplusplus

 _XMHEND3() {};
 _XMHEND3(UINT Packed) : v(Packed) {};
 _XMHEND3(FLOAT _x, FLOAT _y, FLOAT _z);
 _XMHEND3(CONST FLOAT *pArray);

 operator UINT () { return v; }

 _XMHEND3& operator= (CONST _XMHEND3& HenD3);
 _XMHEND3& operator= (CONST UINT Packed);

#endif // __cplusplus

} XMHEND3;

// 3D Vector; 11-11-10 bit normalized components packed into a 32 bit integer
// The normalized 3D Vector is packed into 32 bits as follows: a 10 bit unsigned, 
// normalized integer for the z component and 11 bit unsigned, normalized 
// integers for the x and y components. The z component is stored in the 
// most significant bits and the x component in the least significant bits
// (Z10Y11X11): [32] zzzzzzzz zzyyyyyy yyyyyxxx xxxxxxxx [0]
typedef struct _XMUHENDN3
{
 union
 {
 struct
 {
 UINT x : 11; // 0/2047 to 2047/2047
 UINT y : 11; // 0/2047 to 2047/2047
 UINT z : 10; // 0/1023 to 1023/1023
 };
 UINT v;
 };

#ifdef __cplusplus

 _XMUHENDN3() {};
 _XMUHENDN3(UINT Packed) : v(Packed) {};
 _XMUHENDN3(FLOAT _x, FLOAT _y, FLOAT _z);
 _XMUHENDN3(CONST FLOAT *pArray);

 operator UINT () { return v; }

 _XMUHENDN3& operator= (CONST _XMUHENDN3& UHenDN3);
 _XMUHENDN3& operator= (CONST UINT Packed);

#endif // __cplusplus

} XMUHENDN3;

// 3D Vector; 11-11-10 bit components packed into a 32 bit integer
// The 3D Vector is packed into 32 bits as follows: a 10 bit unsigned
// integer for the z component and 11 bit unsigned integers 
// for the x and y components. The z component is stored in the 
// most significant bits and the x component in the least significant bits
// (Z10Y11X11): [32] zzzzzzzz zzyyyyyy yyyyyxxx xxxxxxxx [0]
typedef struct _XMUHEND3
{
 union
 {
 struct
 {
 UINT x : 11; // 0 to 2047
 UINT y : 11; // 0 to 2047
 UINT z : 10; // 0 to 1023
 };
 UINT v;
 };

#ifdef __cplusplus

 _XMUHEND3() {};
 _XMUHEND3(UINT Packed) : v(Packed) {};
 _XMUHEND3(FLOAT _x, FLOAT _y, FLOAT _z);
 _XMUHEND3(CONST FLOAT *pArray);

 operator UINT () { return v; }

 _XMUHEND3& operator= (CONST _XMUHEND3& UHenD3);
 _XMUHEND3& operator= (CONST UINT Packed);

#endif // __cplusplus

} XMUHEND3;

// 3D Vector; 10-11-11 bit normalized components packed into a 32 bit integer
// The normalized 3D Vector is packed into 32 bits as follows: a 10 bit signed, 
// normalized integer for the x component and 11 bit signed, normalized 
// integers for the y and z components. The z component is stored in the 
// most significant bits and the x component in the least significant bits
// (Z11Y11X10): [32] zzzzzzzz zzzyyyyy yyyyyyxx xxxxxxxx [0]
typedef struct _XMDHENN3
{
 union
 {
 struct
 {
 INT x : 10; // -511/511 to 511/511
 INT y : 11; // -1023/1023 to 1023/1023
 INT z : 11; // -1023/1023 to 1023/1023
 };
 UINT v;
 };

#ifdef __cplusplus

 _XMDHENN3() {};
 _XMDHENN3(UINT Packed) : v(Packed) {};
 _XMDHENN3(FLOAT _x, FLOAT _y, FLOAT _z);
 _XMDHENN3(CONST FLOAT *pArray);

 operator UINT () { return v; }

 _XMDHENN3& operator= (CONST _XMDHENN3& DHenN3);
 _XMDHENN3& operator= (CONST UINT Packed);

#endif // __cplusplus

} XMDHENN3;

// 3D Vector; 10-11-11 bit components packed into a 32 bit integer
// The 3D Vector is packed into 32 bits as follows: a 10 bit signed, 
// integer for the x component and 11 bit signed integers for the 
// y and z components. The w component is stored in the 
// most significant bits and the x component in the least significant bits
// (Z11Y11X10): [32] zzzzzzzz zzzyyyyy yyyyyyxx xxxxxxxx [0]
typedef struct _XMDHEN3
{
 union
 {
 struct
 {
 INT x : 10; // -511 to 511
 INT y : 11; // -1023 to 1023
 INT z : 11; // -1023 to 1023
 };
 UINT v;
 };

#ifdef __cplusplus

 _XMDHEN3() {};
 _XMDHEN3(UINT Packed) : v(Packed) {};
 _XMDHEN3(FLOAT _x, FLOAT _y, FLOAT _z);
 _XMDHEN3(CONST FLOAT *pArray);

 operator UINT () { return v; }

 _XMDHEN3& operator= (CONST _XMDHEN3& DHen3);
 _XMDHEN3& operator= (CONST UINT Packed);

#endif // __cplusplus

} XMDHEN3;

// 3D Vector; 10-11-11 bit normalized components packed into a 32 bit integer
// The normalized 3D Vector is packed into 32 bits as follows: a 10 bit unsigned, 
// normalized integer for the x component and 11 bit unsigned, normalized 
// integers for the y and z components. The w component is stored in the 
// most significant bits and the x component in the least significant bits
// (Z11Y11X10): [32] zzzzzzzz zzzyyyyy yyyyyyxx xxxxxxxx [0]
typedef struct _XMUDHENN3
{
 union
 {
 struct
 {
 UINT x : 10; // 0/1023 to 1023/1023
 UINT y : 11; // 0/2047 to 2047/2047
 UINT z : 11; // 0/2047 to 2047/2047
 };
 UINT v;
 };

#ifdef __cplusplus

 _XMUDHENN3() {};
 _XMUDHENN3(UINT Packed) : v(Packed) {};
 _XMUDHENN3(FLOAT _x, FLOAT _y, FLOAT _z);
 _XMUDHENN3(CONST FLOAT *pArray);

 operator UINT () { return v; }

 _XMUDHENN3& operator= (CONST _XMUDHENN3& UDHenN3);
 _XMUDHENN3& operator= (CONST UINT Packed);

#endif // __cplusplus

} XMUDHENN3;

// 3D Vector; 10-11-11 bit components packed into a 32 bit integer
// The 3D Vector is packed into 32 bits as follows: a 10 bit unsigned, 
// integer for the x component and 11 bit unsigned integers 
// for the y and z components. The w component is stored in the 
// most significant bits and the x component in the least significant bits
// (Z11Y11X10): [32] zzzzzzzz zzzyyyyy yyyyyyxx xxxxxxxx [0]
typedef struct _XMUDHEN3
{
 union
 {
 struct
 {
 UINT x : 10; // 0 to 1023
 UINT y : 11; // 0 to 2047
 UINT z : 11; // 0 to 2047
 };
 UINT v;
 };

#ifdef __cplusplus

 _XMUDHEN3() {};
 _XMUDHEN3(UINT Packed) : v(Packed) {};
 _XMUDHEN3(FLOAT _x, FLOAT _y, FLOAT _z);
 _XMUDHEN3(CONST FLOAT *pArray);

 operator UINT () { return v; }

 _XMUDHEN3& operator= (CONST _XMUDHEN3& UDHen3);
 _XMUDHEN3& operator= (CONST UINT Packed);

#endif // __cplusplus

} XMUDHEN3;

// 3D vector: 5/6/5 unsigned integer components
typedef struct _XMU565
{
 union
 {
 struct
 {
 USHORT x : 5;
 USHORT y : 6;
 USHORT z : 5;
 };
 USHORT v;
 };

#ifdef __cplusplus

 _XMU565() {};
 _XMU565(USHORT Packed) : v(Packed) {};
 _XMU565(CHAR _x, CHAR _y, CHAR _z) : x(_x), y(_y), z(_z) {};
 _XMU565(CONST CHAR *pArray);
 _XMU565(FLOAT _x, FLOAT _y, FLOAT _z);
 _XMU565(CONST FLOAT *pArray);

 operator USHORT () { return v; }

 _XMU565& operator= (CONST _XMU565& U565);
 _XMU565& operator= (CONST USHORT Packed);

#endif // __cplusplus

} XMU565;

// 3D vector: 11/11/10 floating-point components
// The 3D vector is packed into 32 bits as follows: a 5-bit biased exponent
// and 6-bit mantissa for x component, a 5-bit biased exponent and
// 6-bit mantissa for y component, a 5-bit biased exponent and a 5-bit
// mantissa for z. The z component is stored in the most significant bits
// and the x component in the least significant bits. No sign bits so
// all partial-precision numbers are positive.
// (Z10Y11X11): [32] ZZZZZzzz zzzYYYYY yyyyyyXX XXXxxxxx [0]
typedef struct _XMFLOAT3PK
{
 union
 {
 struct
 {
 UINT xm : 6;
 UINT xe : 5;
 UINT ym : 6;
 UINT ye : 5;
 UINT zm : 5;
 UINT ze : 5;
 };
 UINT v;
 };

#ifdef __cplusplus

 _XMFLOAT3PK() {};
 _XMFLOAT3PK(UINT Packed) : v(Packed) {};
 _XMFLOAT3PK(FLOAT _x, FLOAT _y, FLOAT _z);
 _XMFLOAT3PK(CONST FLOAT *pArray);

 operator UINT () { return v; }

 _XMFLOAT3PK& operator= (CONST _XMFLOAT3PK& float3pk);
 _XMFLOAT3PK& operator= (CONST UINT Packed);

#endif // __cplusplus

} XMFLOAT3PK;

// 3D vector: 9/9/9 floating-point components with shared 5-bit exponent
// The 3D vector is packed into 32 bits as follows: a 5-bit biased exponent
// with 9-bit mantissa for the x, y, and z component. The shared exponent
// is stored in the most significant bits and the x component mantissa is in
// the least significant bits. No sign bits so all partial-precision numbers
// are positive.
// (E5Z9Y9X9): [32] EEEEEzzz zzzzzzyy yyyyyyyx xxxxxxxx [0]
typedef struct _XMFLOAT3SE
{
 union
 {
 struct
 {
 UINT xm : 9;
 UINT ym : 9;
 UINT zm : 9;
 UINT e : 5;
 };
 UINT v;
 };

#ifdef __cplusplus

 _XMFLOAT3SE() {};
 _XMFLOAT3SE(UINT Packed) : v(Packed) {};
 _XMFLOAT3SE(FLOAT _x, FLOAT _y, FLOAT _z);
 _XMFLOAT3SE(CONST FLOAT *pArray);

 operator UINT () { return v; }

 _XMFLOAT3SE& operator= (CONST _XMFLOAT3SE& float3se);
 _XMFLOAT3SE& operator= (CONST UINT Packed);

#endif // __cplusplus

} XMFLOAT3SE;

// 4D Vector; 32 bit floating point components
typedef struct _XMFLOAT4
{
 FLOAT x;
 FLOAT y;
 FLOAT z;
 FLOAT w;

#ifdef __cplusplus

 _XMFLOAT4() {};
 _XMFLOAT4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w) : x(_x), y(_y), z(_z), w(_w) {};
 _XMFLOAT4(CONST FLOAT *pArray);

 _XMFLOAT4& operator= (CONST _XMFLOAT4& Float4);

#endif // __cplusplus

} XMFLOAT4;

// 4D Vector; 32 bit floating point components aligned on a 16 byte boundary
#ifdef __cplusplus
__declspec(align(16)) struct XMFLOAT4A : public XMFLOAT4
{
 XMFLOAT4A() : XMFLOAT4() {};
 XMFLOAT4A(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w) : XMFLOAT4(_x, _y, _z, _w) {};
 XMFLOAT4A(CONST FLOAT *pArray) : XMFLOAT4(pArray) {};

 XMFLOAT4A& operator= (CONST XMFLOAT4A& Float4); 
};
#else
typedef __declspec(align(16)) XMFLOAT4 XMFLOAT4A;
#endif // __cplusplus

// 4D Vector; 16 bit floating point components
typedef struct _XMHALF4
{
 HALF x;
 HALF y;
 HALF z;
 HALF w;

#ifdef __cplusplus

 _XMHALF4() {};
 _XMHALF4(HALF _x, HALF _y, HALF _z, HALF _w) : x(_x), y(_y), z(_z), w(_w) {};
 _XMHALF4(CONST HALF *pArray);
 _XMHALF4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
 _XMHALF4(CONST FLOAT *pArray);

 _XMHALF4& operator= (CONST _XMHALF4& Half4);

#endif // __cplusplus

} XMHALF4;

// 4D Vector; 16 bit signed normalized integer components
typedef struct _XMSHORTN4
{
 SHORT x;
 SHORT y;
 SHORT z;
 SHORT w;

#ifdef __cplusplus

 _XMSHORTN4() {};
 _XMSHORTN4(SHORT _x, SHORT _y, SHORT _z, SHORT _w) : x(_x), y(_y), z(_z), w(_w) {};
 _XMSHORTN4(CONST SHORT *pArray);
 _XMSHORTN4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
 _XMSHORTN4(CONST FLOAT *pArray);

 _XMSHORTN4& operator= (CONST _XMSHORTN4& ShortN4);

#endif // __cplusplus

} XMSHORTN4;

// 4D Vector; 16 bit signed integer components
typedef struct _XMSHORT4
{
 SHORT x;
 SHORT y;
 SHORT z;
 SHORT w;

#ifdef __cplusplus

 _XMSHORT4() {};
 _XMSHORT4(SHORT _x, SHORT _y, SHORT _z, SHORT _w) : x(_x), y(_y), z(_z), w(_w) {};
 _XMSHORT4(CONST SHORT *pArray);
 _XMSHORT4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
 _XMSHORT4(CONST FLOAT *pArray);

 _XMSHORT4& operator= (CONST _XMSHORT4& Short4);

#endif // __cplusplus

} XMSHORT4;

// 4D Vector; 16 bit unsigned normalized integer components
typedef struct _XMUSHORTN4
{
 USHORT x;
 USHORT y;
 USHORT z;
 USHORT w;

#ifdef __cplusplus

 _XMUSHORTN4() {};
 _XMUSHORTN4(USHORT _x, USHORT _y, USHORT _z, USHORT _w) : x(_x), y(_y), z(_z), w(_w) {};
 _XMUSHORTN4(CONST USHORT *pArray);
 _XMUSHORTN4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
 _XMUSHORTN4(CONST FLOAT *pArray);

 _XMUSHORTN4& operator= (CONST _XMUSHORTN4& UShortN4);

#endif // __cplusplus

} XMUSHORTN4;

// 4D Vector; 16 bit unsigned integer components
typedef struct _XMUSHORT4
{
 USHORT x;
 USHORT y;
 USHORT z;
 USHORT w;

#ifdef __cplusplus

 _XMUSHORT4() {};
 _XMUSHORT4(USHORT _x, USHORT _y, USHORT _z, USHORT _w) : x(_x), y(_y), z(_z), w(_w) {};
 _XMUSHORT4(CONST USHORT *pArray);
 _XMUSHORT4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
 _XMUSHORT4(CONST FLOAT *pArray);

 _XMUSHORT4& operator= (CONST _XMUSHORT4& UShort4);

#endif // __cplusplus

} XMUSHORT4;

// 4D Vector; 10-10-10-2 bit normalized components packed into a 32 bit integer
// The normalized 4D Vector is packed into 32 bits as follows: a 2 bit unsigned, 
// normalized integer for the w component and 10 bit signed, normalized 
// integers for the z, y, and x components. The w component is stored in the 
// most significant bits and the x component in the least significant bits
// (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
typedef struct _XMXDECN4
{
 union
 {
 struct
 {
 INT x : 10; // -511/511 to 511/511
 INT y : 10; // -511/511 to 511/511
 INT z : 10; // -511/511 to 511/511
 UINT w : 2; // 0/3 to 3/3
 };
 UINT v;
 };

#ifdef __cplusplus

 _XMXDECN4() {};
 _XMXDECN4(UINT Packed) : v(Packed) {};
 _XMXDECN4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
 _XMXDECN4(CONST FLOAT *pArray);

 operator UINT () { return v; }

 _XMXDECN4& operator= (CONST _XMXDECN4& XDecN4);
 _XMXDECN4& operator= (CONST UINT Packed);

#endif // __cplusplus

} XMXDECN4;

// 4D Vector; 10-10-10-2 bit components packed into a 32 bit integer
// The normalized 4D Vector is packed into 32 bits as follows: a 2 bit unsigned
// integer for the w component and 10 bit signed integers for the 
// z, y, and x components. The w component is stored in the 
// most significant bits and the x component in the least significant bits
// (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
typedef struct _XMXDEC4
{
 union
 {
 struct
 {
 INT x : 10; // -511 to 511
 INT y : 10; // -511 to 511
 INT z : 10; // -511 to 511
 UINT w : 2; // 0 to 3
 };
 UINT v;
 };

#ifdef __cplusplus

 _XMXDEC4() {};
 _XMXDEC4(UINT Packed) : v(Packed) {};
 _XMXDEC4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
 _XMXDEC4(CONST FLOAT *pArray);

 operator UINT () { return v; }

 _XMXDEC4& operator= (CONST _XMXDEC4& XDec4);
 _XMXDEC4& operator= (CONST UINT Packed);

#endif // __cplusplus

} XMXDEC4;

// 4D Vector; 10-10-10-2 bit normalized components packed into a 32 bit integer
// The normalized 4D Vector is packed into 32 bits as follows: a 2 bit signed, 
// normalized integer for the w component and 10 bit signed, normalized 
// integers for the z, y, and x components. The w component is stored in the 
// most significant bits and the x component in the least significant bits
// (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
typedef struct _XMDECN4
{
 union
 {
 struct
 {
 INT x : 10; // -511/511 to 511/511
 INT y : 10; // -511/511 to 511/511
 INT z : 10; // -511/511 to 511/511
 INT w : 2; // -1/1 to 1/1
 };
 UINT v;
 };

#ifdef __cplusplus

 _XMDECN4() {};
 _XMDECN4(UINT Packed) : v(Packed) {};
 _XMDECN4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
 _XMDECN4(CONST FLOAT *pArray);

 operator UINT () { return v; }

 _XMDECN4& operator= (CONST _XMDECN4& DecN4);
 _XMDECN4& operator= (CONST UINT Packed);

#endif // __cplusplus

} XMDECN4;

// 4D Vector; 10-10-10-2 bit components packed into a 32 bit integer
// The 4D Vector is packed into 32 bits as follows: a 2 bit signed, 
// integer for the w component and 10 bit signed integers for the 
// z, y, and x components. The w component is stored in the 
// most significant bits and the x component in the least significant bits
// (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
typedef struct _XMDEC4
{
 union
 {
 struct
 {
 INT x : 10; // -511 to 511
 INT y : 10; // -511 to 511
 INT z : 10; // -511 to 511
 INT w : 2; // -1 to 1
 };
 UINT v;
 };

#ifdef __cplusplus

 _XMDEC4() {};
 _XMDEC4(UINT Packed) : v(Packed) {};
 _XMDEC4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
 _XMDEC4(CONST FLOAT *pArray);

 operator UINT () { return v; }

 _XMDEC4& operator= (CONST _XMDEC4& Dec4);
 _XMDEC4& operator= (CONST UINT Packed);

#endif // __cplusplus

} XMDEC4;

// 4D Vector; 10-10-10-2 bit normalized components packed into a 32 bit integer
// The normalized 4D Vector is packed into 32 bits as follows: a 2 bit unsigned, 
// normalized integer for the w component and 10 bit unsigned, normalized 
// integers for the z, y, and x components. The w component is stored in the 
// most significant bits and the x component in the least significant bits
// (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
typedef struct _XMUDECN4
{
 union
 {
 struct
 {
 UINT x : 10; // 0/1023 to 1023/1023
 UINT y : 10; // 0/1023 to 1023/1023
 UINT z : 10; // 0/1023 to 1023/1023
 UINT w : 2; // 0/3 to 3/3
 };
 UINT v;
 };

#ifdef __cplusplus

 _XMUDECN4() {};
 _XMUDECN4(UINT Packed) : v(Packed) {};
 _XMUDECN4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
 _XMUDECN4(CONST FLOAT *pArray);

 operator UINT () { return v; }

 _XMUDECN4& operator= (CONST _XMUDECN4& UDecN4);
 _XMUDECN4& operator= (CONST UINT Packed);

#endif // __cplusplus

} XMUDECN4;

// 4D Vector; 10-10-10-2 bit components packed into a 32 bit integer
// The 4D Vector is packed into 32 bits as follows: a 2 bit unsigned, 
// integer for the w component and 10 bit unsigned integers 
// for the z, y, and x components. The w component is stored in the 
// most significant bits and the x component in the least significant bits
// (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
typedef struct _XMUDEC4
{
 union
 {
 struct
 {
 UINT x : 10; // 0 to 1023
 UINT y : 10; // 0 to 1023
 UINT z : 10; // 0 to 1023
 UINT w : 2; // 0 to 3
 };
 UINT v;
 };

#ifdef __cplusplus

 _XMUDEC4() {};
 _XMUDEC4(UINT Packed) : v(Packed) {};
 _XMUDEC4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
 _XMUDEC4(CONST FLOAT *pArray);

 operator UINT () { return v; }

 _XMUDEC4& operator= (CONST _XMUDEC4& UDec4);
 _XMUDEC4& operator= (CONST UINT Packed);

#endif // __cplusplus

} XMUDEC4;

// 4D Vector; 20-20-20-4 bit normalized components packed into a 64 bit integer
// The normalized 4D Vector is packed into 64 bits as follows: a 4 bit unsigned, 
// normalized integer for the w component and 20 bit signed, normalized 
// integers for the z, y, and x components. The w component is stored in the 
// most significant bits and the x component in the least significant bits
// (W4Z20Y20X20): [64] wwwwzzzz zzzzzzzz zzzzzzzz yyyyyyyy yyyyyyyy yyyyxxxx xxxxxxxx xxxxxxxx [0]
typedef struct _XMXICON4
{
 union
 {
 struct
 {
 INT64 x : 20; // -524287/524287 to 524287/524287
 INT64 y : 20; // -524287/524287 to 524287/524287
 INT64 z : 20; // -524287/524287 to 524287/524287
 UINT64 w : 4; // 0/15 to 15/15
 };
 UINT64 v;
 };

#ifdef __cplusplus

 _XMXICON4() {};
 _XMXICON4(UINT64 Packed) : v(Packed) {};
 _XMXICON4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
 _XMXICON4(CONST FLOAT *pArray);

 operator UINT64 () { return v; }

 _XMXICON4& operator= (CONST _XMXICON4& XIcoN4);
 _XMXICON4& operator= (CONST UINT64 Packed);

#endif // __cplusplus

} XMXICON4;

// 4D Vector; 20-20-20-4 bit components packed into a 64 bit integer
// The 4D Vector is packed into 64 bits as follows: a 4 bit unsigned
// integer for the w component and 20 bit signed integers for the 
// z, y, and x components. The w component is stored in the 
// most significant bits and the x component in the least significant bits
// (W4Z20Y20X20): [64] wwwwzzzz zzzzzzzz zzzzzzzz yyyyyyyy yyyyyyyy yyyyxxxx xxxxxxxx xxxxxxxx [0]
typedef struct _XMXICO4
{
 union
 {
 struct
 {
 INT64 x : 20; // -524287 to 524287
 INT64 y : 20; // -524287 to 524287
 INT64 z : 20; // -524287 to 524287
 UINT64 w : 4; // 0 to 15
 };
 UINT64 v;
 };

#ifdef __cplusplus

 _XMXICO4() {};
 _XMXICO4(UINT64 Packed) : v(Packed) {};
 _XMXICO4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
 _XMXICO4(CONST FLOAT *pArray);

 operator UINT64 () { return v; }

 _XMXICO4& operator= (CONST _XMXICO4& XIco4);
 _XMXICO4& operator= (CONST UINT64 Packed);

#endif // __cplusplus

} XMXICO4;

// 4D Vector; 20-20-20-4 bit normalized components packed into a 64 bit integer
// The normalized 4D Vector is packed into 64 bits as follows: a 4 bit signed, 
// normalized integer for the w component and 20 bit signed, normalized 
// integers for the z, y, and x components. The w component is stored in the 
// most significant bits and the x component in the least significant bits
// (W4Z20Y20X20): [64] wwwwzzzz zzzzzzzz zzzzzzzz yyyyyyyy yyyyyyyy yyyyxxxx xxxxxxxx xxxxxxxx [0]
typedef struct _XMICON4
{
 union
 {
 struct
 {
 INT64 x : 20; // -524287/524287 to 524287/524287
 INT64 y : 20; // -524287/524287 to 524287/524287
 INT64 z : 20; // -524287/524287 to 524287/524287
 INT64 w : 4; // -7/7 to 7/7
 };
 UINT64 v;
 };

#ifdef __cplusplus

 _XMICON4() {};
 _XMICON4(UINT64 Packed) : v(Packed) {};
 _XMICON4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
 _XMICON4(CONST FLOAT *pArray);

 operator UINT64 () { return v; }

 _XMICON4& operator= (CONST _XMICON4& IcoN4);
 _XMICON4& operator= (CONST UINT64 Packed);

#endif // __cplusplus

} XMICON4;

// 4D Vector; 20-20-20-4 bit components packed into a 64 bit integer
// The 4D Vector is packed into 64 bits as follows: a 4 bit signed, 
// integer for the w component and 20 bit signed integers for the 
// z, y, and x components. The w component is stored in the 
// most significant bits and the x component in the least significant bits
// (W4Z20Y20X20): [64] wwwwzzzz zzzzzzzz zzzzzzzz yyyyyyyy yyyyyyyy yyyyxxxx xxxxxxxx xxxxxxxx [0]
typedef struct _XMICO4
{
 union
 {
 struct
 {
 INT64 x : 20; // -524287 to 524287
 INT64 y : 20; // -524287 to 524287
 INT64 z : 20; // -524287 to 524287
 INT64 w : 4; // -7 to 7
 };
 UINT64 v;
 };

#ifdef __cplusplus

 _XMICO4() {};
 _XMICO4(UINT64 Packed) : v(Packed) {};
 _XMICO4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
 _XMICO4(CONST FLOAT *pArray);

 operator UINT64 () { return v; }

 _XMICO4& operator= (CONST _XMICO4& Ico4);
 _XMICO4& operator= (CONST UINT64 Packed);

#endif // __cplusplus

} XMICO4;

// 4D Vector; 20-20-20-4 bit normalized components packed into a 64 bit integer
// The normalized 4D Vector is packed into 64 bits as follows: a 4 bit unsigned, 
// normalized integer for the w component and 20 bit unsigned, normalized 
// integers for the z, y, and x components. The w component is stored in the 
// most significant bits and the x component in the least significant bits
// (W4Z20Y20X20): [64] wwwwzzzz zzzzzzzz zzzzzzzz yyyyyyyy yyyyyyyy yyyyxxxx xxxxxxxx xxxxxxxx [0]
typedef struct _XMUICON4
{
 union
 {
 struct
 {
 UINT64 x : 20; // 0/1048575 to 1048575/1048575
 UINT64 y : 20; // 0/1048575 to 1048575/1048575
 UINT64 z : 20; // 0/1048575 to 1048575/1048575
 UINT64 w : 4; // 0/15 to 15/15
 };
 UINT64 v;
 };

#ifdef __cplusplus

 _XMUICON4() {};
 _XMUICON4(UINT64 Packed) : v(Packed) {};
 _XMUICON4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
 _XMUICON4(CONST FLOAT *pArray);

 operator UINT64 () { return v; }

 _XMUICON4& operator= (CONST _XMUICON4& UIcoN4);
 _XMUICON4& operator= (CONST UINT64 Packed);

#endif // __cplusplus

} XMUICON4;

// 4D Vector; 20-20-20-4 bit components packed into a 64 bit integer
// The 4D Vector is packed into 64 bits as follows: a 4 bit unsigned 
// integer for the w component and 20 bit unsigned integers for the 
// z, y, and x components. The w component is stored in the 
// most significant bits and the x component in the least significant bits
// (W4Z20Y20X20): [64] wwwwzzzz zzzzzzzz zzzzzzzz yyyyyyyy yyyyyyyy yyyyxxxx xxxxxxxx xxxxxxxx [0]
typedef struct _XMUICO4
{
 union
 {
 struct
 {
 UINT64 x : 20; // 0 to 1048575
 UINT64 y : 20; // 0 to 1048575
 UINT64 z : 20; // 0 to 1048575
 UINT64 w : 4; // 0 to 15
 };
 UINT64 v;
 };

#ifdef __cplusplus

 _XMUICO4() {};
 _XMUICO4(UINT64 Packed) : v(Packed) {};
 _XMUICO4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
 _XMUICO4(CONST FLOAT *pArray);

 operator UINT64 () { return v; }

 _XMUICO4& operator= (CONST _XMUICO4& UIco4);
 _XMUICO4& operator= (CONST UINT64 Packed);

#endif // __cplusplus

} XMUICO4;

// ARGB Color; 8-8-8-8 bit unsigned normalized integer components packed into
// a 32 bit integer. The normalized color is packed into 32 bits using 8 bit
// unsigned, normalized integers for the alpha, red, green, and blue components.
// The alpha component is stored in the most significant bits and the blue
// component in the least significant bits (A8R8G8B8):
// [32] aaaaaaaa rrrrrrrr gggggggg bbbbbbbb [0]
typedef struct _XMCOLOR
{
 union
 {
 struct
 {
 UINT b : 8; // Blue: 0/255 to 255/255
 UINT g : 8; // Green: 0/255 to 255/255
 UINT r : 8; // Red: 0/255 to 255/255
 UINT a : 8; // Alpha: 0/255 to 255/255
 };
 UINT c;
 };

#ifdef __cplusplus

 _XMCOLOR() {};
 _XMCOLOR(UINT Color) : c(Color) {};
 _XMCOLOR(FLOAT _r, FLOAT _g, FLOAT _b, FLOAT _a);
 _XMCOLOR(CONST FLOAT *pArray);

 operator UINT () { return c; }

 _XMCOLOR& operator= (CONST _XMCOLOR& Color);
 _XMCOLOR& operator= (CONST UINT Color);

#endif // __cplusplus

} XMCOLOR;

// 4D Vector; 8 bit signed normalized integer components
typedef struct _XMBYTEN4
{
 union
 {
 struct
 {
 CHAR x;
 CHAR y;
 CHAR z;
 CHAR w;
 };
 UINT v;
 };

#ifdef __cplusplus

 _XMBYTEN4() {};
 _XMBYTEN4(CHAR _x, CHAR _y, CHAR _z, CHAR _w) : x(_x), y(_y), z(_z), w(_w) {};
 _XMBYTEN4(UINT Packed) : v(Packed) {};
 _XMBYTEN4(CONST CHAR *pArray);
 _XMBYTEN4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
 _XMBYTEN4(CONST FLOAT *pArray);

 _XMBYTEN4& operator= (CONST _XMBYTEN4& ByteN4);

#endif // __cplusplus

} XMBYTEN4;

// 4D Vector; 8 bit signed integer components
typedef struct _XMBYTE4
{
 union
 {
 struct
 {
 CHAR x;
 CHAR y;
 CHAR z;
 CHAR w;
 };
 UINT v;
 };

#ifdef __cplusplus

 _XMBYTE4() {};
 _XMBYTE4(CHAR _x, CHAR _y, CHAR _z, CHAR _w) : x(_x), y(_y), z(_z), w(_w) {};
 _XMBYTE4(UINT Packed) : v(Packed) {};
 _XMBYTE4(CONST CHAR *pArray);
 _XMBYTE4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
 _XMBYTE4(CONST FLOAT *pArray);

 _XMBYTE4& operator= (CONST _XMBYTE4& Byte4);

#endif // __cplusplus

} XMBYTE4;

// 4D Vector; 8 bit unsigned normalized integer components
typedef struct _XMUBYTEN4
{
 union
 {
 struct
 {
 BYTE x;
 BYTE y;
 BYTE z;
 BYTE w;
 };
 UINT v;
 };

#ifdef __cplusplus

 _XMUBYTEN4() {};
 _XMUBYTEN4(BYTE _x, BYTE _y, BYTE _z, BYTE _w) : x(_x), y(_y), z(_z), w(_w) {};
 _XMUBYTEN4(UINT Packed) : v(Packed) {};
 _XMUBYTEN4(CONST BYTE *pArray);
 _XMUBYTEN4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
 _XMUBYTEN4(CONST FLOAT *pArray);

 _XMUBYTEN4& operator= (CONST _XMUBYTEN4& UByteN4);

#endif // __cplusplus

} XMUBYTEN4;

// 4D Vector; 8 bit unsigned integer components
typedef struct _XMUBYTE4
{
 union
 {
 struct
 {
 BYTE x;
 BYTE y;
 BYTE z;
 BYTE w;
 };
 UINT v;
 };

#ifdef __cplusplus

 _XMUBYTE4() {};
 _XMUBYTE4(BYTE _x, BYTE _y, BYTE _z, BYTE _w) : x(_x), y(_y), z(_z), w(_w) {};
 _XMUBYTE4(UINT Packed) : v(Packed) {};
 _XMUBYTE4(CONST BYTE *pArray);
 _XMUBYTE4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
 _XMUBYTE4(CONST FLOAT *pArray);

 _XMUBYTE4& operator= (CONST _XMUBYTE4& UByte4);

#endif // __cplusplus

} XMUBYTE4;

// 4D vector; 4 bit unsigned integer components
typedef struct _XMUNIBBLE4
{
 union
 {
 struct
 {
 USHORT x : 4;
 USHORT y : 4;
 USHORT z : 4;
 USHORT w : 4;
 };
 USHORT v;
 };

#ifdef __cplusplus

 _XMUNIBBLE4() {};
 _XMUNIBBLE4(USHORT Packed) : v(Packed) {};
 _XMUNIBBLE4(CHAR _x, CHAR _y, CHAR _z, CHAR _w) : x(_x), y(_y), z(_z), w(_w) {};
 _XMUNIBBLE4(CONST CHAR *pArray);
 _XMUNIBBLE4(FLOAT _x, FLOAT _y, FLOAT _z, FLOAT _w);
 _XMUNIBBLE4(CONST FLOAT *pArray);

 operator USHORT () { return v; }

 _XMUNIBBLE4& operator= (CONST _XMUNIBBLE4& UNibble4);
 _XMUNIBBLE4& operator= (CONST USHORT Packed);

#endif // __cplusplus

} XMUNIBBLE4;

// 4D vector: 5/5/5/1 unsigned integer components
typedef struct _XMU555
{
 union
 {
 struct
 {
 USHORT x : 5;
 USHORT y : 5;
 USHORT z : 5;
 USHORT w : 1;
 };
 USHORT v;
 };

#ifdef __cplusplus

 _XMU555() {};
 _XMU555(USHORT Packed) : v(Packed) {};
 _XMU555(CHAR _x, CHAR _y, CHAR _z, BOOL _w) : x(_x), y(_y), z(_z), w(_w ? 0x1 : 0) {};
 _XMU555(CONST CHAR *pArray, BOOL _w);
 _XMU555(FLOAT _x, FLOAT _y, FLOAT _z, BOOL _w);
 _XMU555(CONST FLOAT *pArray, BOOL _w);

 operator USHORT () { return v; }

 _XMU555& operator= (CONST _XMU555& U555);
 _XMU555& operator= (CONST USHORT Packed);

#endif // __cplusplus

} XMU555;

// 3x3 Matrix: 32 bit floating point components
typedef struct _XMFLOAT3X3
{
 union
 {
 struct
 {
 FLOAT _11, _12, _13;
 FLOAT _21, _22, _23;
 FLOAT _31, _32, _33;
 };
 FLOAT m[3][3];
 };

#ifdef __cplusplus

 _XMFLOAT3X3() {};
 _XMFLOAT3X3(FLOAT m00, FLOAT m01, FLOAT m02,
 FLOAT m10, FLOAT m11, FLOAT m12,
 FLOAT m20, FLOAT m21, FLOAT m22);
 _XMFLOAT3X3(CONST FLOAT *pArray);

 FLOAT operator() (UINT Row, UINT Column) CONST { return m[Row][Column]; }
 FLOAT& operator() (UINT Row, UINT Column) { return m[Row][Column]; }

 _XMFLOAT3X3& operator= (CONST _XMFLOAT3X3& Float3x3);

#endif // __cplusplus

} XMFLOAT3X3;

// 4x3 Matrix: 32 bit floating point components
typedef struct _XMFLOAT4X3
{
 union
 {
 struct
 {
 FLOAT _11, _12, _13;
 FLOAT _21, _22, _23;
 FLOAT _31, _32, _33;
 FLOAT _41, _42, _43;
 };
 FLOAT m[4][3];
 };

#ifdef __cplusplus

 _XMFLOAT4X3() {};
 _XMFLOAT4X3(FLOAT m00, FLOAT m01, FLOAT m02,
 FLOAT m10, FLOAT m11, FLOAT m12,
 FLOAT m20, FLOAT m21, FLOAT m22,
 FLOAT m30, FLOAT m31, FLOAT m32);
 _XMFLOAT4X3(CONST FLOAT *pArray);

 FLOAT operator() (UINT Row, UINT Column) CONST { return m[Row][Column]; }
 FLOAT& operator() (UINT Row, UINT Column) { return m[Row][Column]; }

 _XMFLOAT4X3& operator= (CONST _XMFLOAT4X3& Float4x3);

#endif // __cplusplus

} XMFLOAT4X3;

// 4x3 Matrix: 32 bit floating point components aligned on a 16 byte boundary
#ifdef __cplusplus
__declspec(align(16)) struct XMFLOAT4X3A : public XMFLOAT4X3
{
 XMFLOAT4X3A() : XMFLOAT4X3() {};
 XMFLOAT4X3A(FLOAT m00, FLOAT m01, FLOAT m02,
 FLOAT m10, FLOAT m11, FLOAT m12,
 FLOAT m20, FLOAT m21, FLOAT m22,
 FLOAT m30, FLOAT m31, FLOAT m32) :
 XMFLOAT4X3(m00,m01,m02,m10,m11,m12,m20,m21,m22,m30,m31,m32) {};
 XMFLOAT4X3A(CONST FLOAT *pArray) : XMFLOAT4X3(pArray) {}

 FLOAT operator() (UINT Row, UINT Column) CONST { return m[Row][Column]; }
 FLOAT& operator() (UINT Row, UINT Column) { return m[Row][Column]; }

 XMFLOAT4X3A& operator= (CONST XMFLOAT4X3A& Float4x3);
};
#else
typedef __declspec(align(16)) XMFLOAT4X3 XMFLOAT4X3A;
#endif // __cplusplus

// 4x4 Matrix: 32 bit floating point components
typedef struct _XMFLOAT4X4
{
 union
 {
 struct
 {
 FLOAT _11, _12, _13, _14;
 FLOAT _21, _22, _23, _24;
 FLOAT _31, _32, _33, _34;
 FLOAT _41, _42, _43, _44;
 };
 FLOAT m[4][4];
 };

#ifdef __cplusplus

 _XMFLOAT4X4() {};
 _XMFLOAT4X4(FLOAT m00, FLOAT m01, FLOAT m02, FLOAT m03,
 FLOAT m10, FLOAT m11, FLOAT m12, FLOAT m13,
 FLOAT m20, FLOAT m21, FLOAT m22, FLOAT m23,
 FLOAT m30, FLOAT m31, FLOAT m32, FLOAT m33);
 _XMFLOAT4X4(CONST FLOAT *pArray);

 FLOAT operator() (UINT Row, UINT Column) CONST { return m[Row][Column]; }
 FLOAT& operator() (UINT Row, UINT Column) { return m[Row][Column]; }

 _XMFLOAT4X4& operator= (CONST _XMFLOAT4X4& Float4x4);

#endif // __cplusplus

} XMFLOAT4X4;

// 4x4 Matrix: 32 bit floating point components aligned on a 16 byte boundary
#ifdef __cplusplus
__declspec(align(16)) struct XMFLOAT4X4A : public XMFLOAT4X4
{
 XMFLOAT4X4A() : XMFLOAT4X4() {};
 XMFLOAT4X4A(FLOAT m00, FLOAT m01, FLOAT m02, FLOAT m03,
 FLOAT m10, FLOAT m11, FLOAT m12, FLOAT m13,
 FLOAT m20, FLOAT m21, FLOAT m22, FLOAT m23,
 FLOAT m30, FLOAT m31, FLOAT m32, FLOAT m33)
 : XMFLOAT4X4(m00,m01,m02,m03,m10,m11,m12,m13,m20,m21,m22,m23,m30,m31,m32,m33) {};
 XMFLOAT4X4A(CONST FLOAT *pArray) : XMFLOAT4X4(pArray) {}

 FLOAT operator() (UINT Row, UINT Column) CONST { return m[Row][Column]; }
 FLOAT& operator() (UINT Row, UINT Column) { return m[Row][Column]; }

 XMFLOAT4X4A& operator= (CONST XMFLOAT4X4A& Float4x4);
};
#else
typedef __declspec(align(16)) XMFLOAT4X4 XMFLOAT4X4A;
#endif // __cplusplus

#if !defined(_XM_X86_) && !defined(_XM_X64_)
#pragma bitfield_order(pop)
#endif // !_XM_X86_ && !_XM_X64_

#pragma warning(pop)


/****************************************************************************
 *
 * Data conversion operations
 *
 ****************************************************************************/

#if !defined(_XM_NO_INTRINSICS_) && defined(_XM_VMX128_INTRINSICS_)
#else
XMVECTOR XMConvertVectorIntToFloat(FXMVECTOR VInt, UINT DivExponent);
XMVECTOR XMConvertVectorFloatToInt(FXMVECTOR VFloat, UINT MulExponent);
XMVECTOR XMConvertVectorUIntToFloat(FXMVECTOR VUInt, UINT DivExponent);
XMVECTOR XMConvertVectorFloatToUInt(FXMVECTOR VFloat, UINT MulExponent);
#endif

FLOAT XMConvertHalfToFloat(HALF Value);
FLOAT* XMConvertHalfToFloatStream(_Out_bytecap_x_(sizeof(FLOAT)+OutputStride*(HalfCount-1)) FLOAT* pOutputStream,
 _In_ UINT OutputStride,
 _In_bytecount_x_(sizeof(HALF)+InputStride*(HalfCount-1)) CONST HALF* pInputStream,
 _In_ UINT InputStride, _In_ UINT HalfCount);
HALF XMConvertFloatToHalf(FLOAT Value);
HALF* XMConvertFloatToHalfStream(_Out_bytecap_x_(sizeof(HALF)+OutputStride*(FloatCount-1)) HALF* pOutputStream,
 _In_ UINT OutputStride,
 _In_bytecount_x_(sizeof(FLOAT)+InputStride*(FloatCount-1)) CONST FLOAT* pInputStream,
 _In_ UINT InputStride, _In_ UINT FloatCount);

#if !defined(_XM_NO_INTRINSICS_) && defined(_XM_VMX128_INTRINSICS_)
#else
XMVECTOR XMVectorSetBinaryConstant(UINT C0, UINT C1, UINT C2, UINT C3);
XMVECTOR XMVectorSplatConstant(INT IntConstant, UINT DivExponent);
XMVECTOR XMVectorSplatConstantInt(INT IntConstant);
#endif

/****************************************************************************
 *
 * Load operations
 *
 ****************************************************************************/

XMVECTOR XMLoadInt(_In_ CONST UINT* pSource);
XMVECTOR XMLoadFloat(_In_ CONST FLOAT* pSource);

XMVECTOR XMLoadInt2(_In_count_c_(2) CONST UINT* pSource);
XMVECTOR XMLoadInt2A(_In_count_c_(2) CONST UINT* PSource);
XMVECTOR XMLoadFloat2(_In_ CONST XMFLOAT2* pSource);
XMVECTOR XMLoadFloat2A(_In_ CONST XMFLOAT2A* pSource);
XMVECTOR XMLoadHalf2(_In_ CONST XMHALF2* pSource);
XMVECTOR XMLoadShortN2(_In_ CONST XMSHORTN2* pSource);
XMVECTOR XMLoadShort2(_In_ CONST XMSHORT2* pSource);
XMVECTOR XMLoadUShortN2(_In_ CONST XMUSHORTN2* pSource);
XMVECTOR XMLoadUShort2(_In_ CONST XMUSHORT2* pSource);

XMVECTOR XMLoadInt3(_In_count_c_(3) CONST UINT* pSource);
XMVECTOR XMLoadInt3A(_In_count_c_(3) CONST UINT* pSource);
XMVECTOR XMLoadFloat3(_In_ CONST XMFLOAT3* pSource);
XMVECTOR XMLoadFloat3A(_In_ CONST XMFLOAT3A* pSource);
XMVECTOR XMLoadHenDN3(_In_ CONST XMHENDN3* pSource);
XMVECTOR XMLoadHenD3(_In_ CONST XMHEND3* pSource);
XMVECTOR XMLoadUHenDN3(_In_ CONST XMUHENDN3* pSource);
XMVECTOR XMLoadUHenD3(_In_ CONST XMUHEND3* pSource);
XMVECTOR XMLoadDHenN3(_In_ CONST XMDHENN3* pSource);
XMVECTOR XMLoadDHen3(_In_ CONST XMDHEN3* pSource);
XMVECTOR XMLoadUDHenN3(_In_ CONST XMUDHENN3* pSource);
XMVECTOR XMLoadUDHen3(_In_ CONST XMUDHEN3* pSource);
XMVECTOR XMLoadU565(_In_ CONST XMU565* pSource);
XMVECTOR XMLoadFloat3PK(_In_ CONST XMFLOAT3PK* pSource);
XMVECTOR XMLoadFloat3SE(_In_ CONST XMFLOAT3SE* pSource);

XMVECTOR XMLoadInt4(_In_count_c_(4) CONST UINT* pSource);
XMVECTOR XMLoadInt4A(_In_count_c_(4) CONST UINT* pSource);
XMVECTOR XMLoadFloat4(_In_ CONST XMFLOAT4* pSource);
XMVECTOR XMLoadFloat4A(_In_ CONST XMFLOAT4A* pSource);
XMVECTOR XMLoadHalf4(_In_ CONST XMHALF4* pSource);
XMVECTOR XMLoadShortN4(_In_ CONST XMSHORTN4* pSource);
XMVECTOR XMLoadShort4(_In_ CONST XMSHORT4* pSource);
XMVECTOR XMLoadUShortN4(_In_ CONST XMUSHORTN4* pSource);
XMVECTOR XMLoadUShort4(_In_ CONST XMUSHORT4* pSource);
XMVECTOR XMLoadXIcoN4(_In_ CONST XMXICON4* pSource);
XMVECTOR XMLoadXIco4(_In_ CONST XMXICO4* pSource);
XMVECTOR XMLoadIcoN4(_In_ CONST XMICON4* pSource);
XMVECTOR XMLoadIco4(_In_ CONST XMICO4* pSource);
XMVECTOR XMLoadUIcoN4(_In_ CONST XMUICON4* pSource);
XMVECTOR XMLoadUIco4(_In_ CONST XMUICO4* pSource);
XMVECTOR XMLoadXDecN4(_In_ CONST XMXDECN4* pSource);
XMVECTOR XMLoadXDec4(_In_ CONST XMXDEC4* pSource);
XMVECTOR XMLoadDecN4(_In_ CONST XMDECN4* pSource);
XMVECTOR XMLoadDec4(_In_ CONST XMDEC4* pSource);
XMVECTOR XMLoadUDecN4(_In_ CONST XMUDECN4* pSource);
XMVECTOR XMLoadUDec4(_In_ CONST XMUDEC4* pSource);
XMVECTOR XMLoadByteN4(_In_ CONST XMBYTEN4* pSource);
XMVECTOR XMLoadByte4(_In_ CONST XMBYTE4* pSource);
XMVECTOR XMLoadUByteN4(_In_ CONST XMUBYTEN4* pSource);
XMVECTOR XMLoadUByte4(_In_ CONST XMUBYTE4* pSource);
XMVECTOR XMLoadUNibble4(_In_ CONST XMUNIBBLE4* pSource);
XMVECTOR XMLoadU555(_In_ CONST XMU555* pSource);
XMVECTOR XMLoadColor(_In_ CONST XMCOLOR* pSource);

XMMATRIX XMLoadFloat3x3(_In_ CONST XMFLOAT3X3* pSource);
XMMATRIX XMLoadFloat4x3(_In_ CONST XMFLOAT4X3* pSource);
XMMATRIX XMLoadFloat4x3A(_In_ CONST XMFLOAT4X3A* pSource);
XMMATRIX XMLoadFloat4x4(_In_ CONST XMFLOAT4X4* pSource);
XMMATRIX XMLoadFloat4x4A(_In_ CONST XMFLOAT4X4A* pSource);

/****************************************************************************
 *
 * Store operations
 *
 ****************************************************************************/

VOID XMStoreInt(_Out_ UINT* pDestination, FXMVECTOR V);
VOID XMStoreFloat(_Out_ FLOAT* pDestination, FXMVECTOR V);

VOID XMStoreInt2(_Out_cap_c_(2) UINT* pDestination, FXMVECTOR V);
VOID XMStoreInt2A(_Out_cap_c_(2) UINT* pDestination, FXMVECTOR V);
VOID XMStoreFloat2(_Out_ XMFLOAT2* pDestination, FXMVECTOR V);
VOID XMStoreFloat2A(_Out_ XMFLOAT2A* pDestination, FXMVECTOR V);
VOID XMStoreHalf2(_Out_ XMHALF2* pDestination, FXMVECTOR V);
VOID XMStoreShortN2(_Out_ XMSHORTN2* pDestination, FXMVECTOR V);
VOID XMStoreShort2(_Out_ XMSHORT2* pDestination, FXMVECTOR V);
VOID XMStoreUShortN2(_Out_ XMUSHORTN2* pDestination, FXMVECTOR V);
VOID XMStoreUShort2(_Out_ XMUSHORT2* pDestination, FXMVECTOR V);

VOID XMStoreInt3(_Out_cap_c_(3) UINT* pDestination, FXMVECTOR V);
VOID XMStoreInt3A(_Out_cap_c_(3) UINT* pDestination, FXMVECTOR V);
VOID XMStoreFloat3(_Out_ XMFLOAT3* pDestination, FXMVECTOR V);
VOID XMStoreFloat3A(_Out_ XMFLOAT3A* pDestination, FXMVECTOR V);
VOID XMStoreHenDN3(_Out_ XMHENDN3* pDestination, FXMVECTOR V);
VOID XMStoreHenD3(_Out_ XMHEND3* pDestination, FXMVECTOR V);
VOID XMStoreUHenDN3(_Out_ XMUHENDN3* pDestination, FXMVECTOR V);
VOID XMStoreUHenD3(_Out_ XMUHEND3* pDestination, FXMVECTOR V);
VOID XMStoreDHenN3(_Out_ XMDHENN3* pDestination, FXMVECTOR V);
VOID XMStoreDHen3(_Out_ XMDHEN3* pDestination, FXMVECTOR V);
VOID XMStoreUDHenN3(_Out_ XMUDHENN3* pDestination, FXMVECTOR V);
VOID XMStoreUDHen3(_Out_ XMUDHEN3* pDestination, FXMVECTOR V);
VOID XMStoreU565(_Out_ XMU565* pDestination, FXMVECTOR V);
VOID XMStoreFloat3PK(_Out_ XMFLOAT3PK* pDestination, FXMVECTOR V);
VOID XMStoreFloat3SE(_Out_ XMFLOAT3SE* pDestination, FXMVECTOR V);

VOID XMStoreInt4(_Out_cap_c_(4) UINT* pDestination, FXMVECTOR V);
VOID XMStoreInt4A(_Out_cap_c_(4) UINT* pDestination, FXMVECTOR V);
VOID XMStoreInt4NC(_Out_ UINT* pDestination, FXMVECTOR V);
VOID XMStoreFloat4(_Out_ XMFLOAT4* pDestination, FXMVECTOR V);
VOID XMStoreFloat4A(_Out_ XMFLOAT4A* pDestination, FXMVECTOR V);
VOID XMStoreFloat4NC(_Out_ XMFLOAT4* pDestination, FXMVECTOR V);
VOID XMStoreHalf4(_Out_ XMHALF4* pDestination, FXMVECTOR V);
VOID XMStoreShortN4(_Out_ XMSHORTN4* pDestination, FXMVECTOR V);
VOID XMStoreShort4(_Out_ XMSHORT4* pDestination, FXMVECTOR V);
VOID XMStoreUShortN4(_Out_ XMUSHORTN4* pDestination, FXMVECTOR V);
VOID XMStoreUShort4(_Out_ XMUSHORT4* pDestination, FXMVECTOR V);
VOID XMStoreXIcoN4(_Out_ XMXICON4* pDestination, FXMVECTOR V);
VOID XMStoreXIco4(_Out_ XMXICO4* pDestination, FXMVECTOR V);
VOID XMStoreIcoN4(_Out_ XMICON4* pDestination, FXMVECTOR V);
VOID XMStoreIco4(_Out_ XMICO4* pDestination, FXMVECTOR V);
VOID XMStoreUIcoN4(_Out_ XMUICON4* pDestination, FXMVECTOR V);
VOID XMStoreUIco4(_Out_ XMUICO4* pDestination, FXMVECTOR V);
VOID XMStoreXDecN4(_Out_ XMXDECN4* pDestination, FXMVECTOR V);
VOID XMStoreXDec4(_Out_ XMXDEC4* pDestination, FXMVECTOR V);
VOID XMStoreDecN4(_Out_ XMDECN4* pDestination, FXMVECTOR V);
VOID XMStoreDec4(_Out_ XMDEC4* pDestination, FXMVECTOR V);
VOID XMStoreUDecN4(_Out_ XMUDECN4* pDestination, FXMVECTOR V);
VOID XMStoreUDec4(_Out_ XMUDEC4* pDestination, FXMVECTOR V);
VOID XMStoreByteN4(_Out_ XMBYTEN4* pDestination, FXMVECTOR V);
VOID XMStoreByte4(_Out_ XMBYTE4* pDestination, FXMVECTOR V);
VOID XMStoreUByteN4(_Out_ XMUBYTEN4* pDestination, FXMVECTOR V);
VOID XMStoreUByte4(_Out_ XMUBYTE4* pDestination, FXMVECTOR V);
VOID XMStoreUNibble4(_Out_ XMUNIBBLE4* pDestination, FXMVECTOR V);
VOID XMStoreU555(_Out_ XMU555* pDestination, FXMVECTOR V);
VOID XMStoreColor(_Out_ XMCOLOR* pDestination, FXMVECTOR V);

VOID XMStoreFloat3x3(_Out_ XMFLOAT3X3* pDestination, CXMMATRIX M);
VOID XMStoreFloat3x3NC(_Out_ XMFLOAT3X3* pDestination, CXMMATRIX M);
VOID XMStoreFloat4x3(_Out_ XMFLOAT4X3* pDestination, CXMMATRIX M);
VOID XMStoreFloat4x3A(_Out_ XMFLOAT4X3A* pDestination, CXMMATRIX M);
VOID XMStoreFloat4x3NC(_Out_ XMFLOAT4X3* pDestination, CXMMATRIX M);
VOID XMStoreFloat4x4(_Out_ XMFLOAT4X4* pDestination, CXMMATRIX M);
VOID XMStoreFloat4x4A(_Out_ XMFLOAT4X4A* pDestination, CXMMATRIX M);
VOID XMStoreFloat4x4NC(_Out_ XMFLOAT4X4* pDestination, CXMMATRIX M);

/****************************************************************************
 *
 * General vector operations
 *
 ****************************************************************************/

XMVECTOR XMVectorZero();
XMVECTOR XMVectorSet(FLOAT x, FLOAT y, FLOAT z, FLOAT w);
XMVECTOR XMVectorSetInt(UINT x, UINT y, UINT z, UINT w);
XMVECTOR XMVectorReplicate(FLOAT Value);
XMVECTOR XMVectorReplicatePtr(_In_ CONST FLOAT *pValue);
XMVECTOR XMVectorReplicateInt(UINT Value);
XMVECTOR XMVectorReplicateIntPtr(_In_ CONST UINT *pValue);
XMVECTOR XMVectorTrueInt();
XMVECTOR XMVectorFalseInt();
XMVECTOR XMVectorSplatX(FXMVECTOR V);
XMVECTOR XMVectorSplatY(FXMVECTOR V);
XMVECTOR XMVectorSplatZ(FXMVECTOR V);
XMVECTOR XMVectorSplatW(FXMVECTOR V);
XMVECTOR XMVectorSplatOne();
XMVECTOR XMVectorSplatInfinity();
XMVECTOR XMVectorSplatQNaN();
XMVECTOR XMVectorSplatEpsilon();
XMVECTOR XMVectorSplatSignMask();

FLOAT XMVectorGetByIndex(FXMVECTOR V,UINT i);
FLOAT XMVectorGetX(FXMVECTOR V);
FLOAT XMVectorGetY(FXMVECTOR V);
FLOAT XMVectorGetZ(FXMVECTOR V);
FLOAT XMVectorGetW(FXMVECTOR V);

VOID XMVectorGetByIndexPtr(_Out_ FLOAT *f, FXMVECTOR V, UINT i);
VOID XMVectorGetXPtr(_Out_ FLOAT *x, FXMVECTOR V);
VOID XMVectorGetYPtr(_Out_ FLOAT *y, FXMVECTOR V);
VOID XMVectorGetZPtr(_Out_ FLOAT *z, FXMVECTOR V);
VOID XMVectorGetWPtr(_Out_ FLOAT *w, FXMVECTOR V);

UINT XMVectorGetIntByIndex(FXMVECTOR V,UINT i);
UINT XMVectorGetIntX(FXMVECTOR V);
UINT XMVectorGetIntY(FXMVECTOR V);
UINT XMVectorGetIntZ(FXMVECTOR V);
UINT XMVectorGetIntW(FXMVECTOR V);

VOID XMVectorGetIntByIndexPtr(_Out_ UINT *x,FXMVECTOR V, UINT i);
VOID XMVectorGetIntXPtr(_Out_ UINT *x, FXMVECTOR V);
VOID XMVectorGetIntYPtr(_Out_ UINT *y, FXMVECTOR V);
VOID XMVectorGetIntZPtr(_Out_ UINT *z, FXMVECTOR V);
VOID XMVectorGetIntWPtr(_Out_ UINT *w, FXMVECTOR V);

XMVECTOR XMVectorSetByIndex(FXMVECTOR V,FLOAT f,UINT i);
XMVECTOR XMVectorSetX(FXMVECTOR V, FLOAT x);
XMVECTOR XMVectorSetY(FXMVECTOR V, FLOAT y);
XMVECTOR XMVectorSetZ(FXMVECTOR V, FLOAT z);
XMVECTOR XMVectorSetW(FXMVECTOR V, FLOAT w);

XMVECTOR XMVectorSetByIndexPtr(FXMVECTOR V, _In_ CONST FLOAT *f, UINT i);
XMVECTOR XMVectorSetXPtr(FXMVECTOR V, _In_ CONST FLOAT *x);
XMVECTOR XMVectorSetYPtr(FXMVECTOR V, _In_ CONST FLOAT *y);
XMVECTOR XMVectorSetZPtr(FXMVECTOR V, _In_ CONST FLOAT *z);
XMVECTOR XMVectorSetWPtr(FXMVECTOR V, _In_ CONST FLOAT *w);

XMVECTOR XMVectorSetIntByIndex(FXMVECTOR V, UINT x,UINT i);
XMVECTOR XMVectorSetIntX(FXMVECTOR V, UINT x);
XMVECTOR XMVectorSetIntY(FXMVECTOR V, UINT y);
XMVECTOR XMVectorSetIntZ(FXMVECTOR V, UINT z);
XMVECTOR XMVectorSetIntW(FXMVECTOR V, UINT w);

XMVECTOR XMVectorSetIntByIndexPtr(FXMVECTOR V, _In_ CONST UINT *x, UINT i);
XMVECTOR XMVectorSetIntXPtr(FXMVECTOR V, _In_ CONST UINT *x);
XMVECTOR XMVectorSetIntYPtr(FXMVECTOR V, _In_ CONST UINT *y);
XMVECTOR XMVectorSetIntZPtr(FXMVECTOR V, _In_ CONST UINT *z);
XMVECTOR XMVectorSetIntWPtr(FXMVECTOR V, _In_ CONST UINT *w);

XMVECTOR XMVectorPermuteControl(UINT ElementIndex0, UINT ElementIndex1, UINT ElementIndex2, UINT ElementIndex3);
XMVECTOR XMVectorPermute(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR Control);
XMVECTOR XMVectorSelectControl(UINT VectorIndex0, UINT VectorIndex1, UINT VectorIndex2, UINT VectorIndex3);
XMVECTOR XMVectorSelect(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR Control);
XMVECTOR XMVectorMergeXY(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorMergeZW(FXMVECTOR V1, FXMVECTOR V2);

#if !defined(_XM_NO_INTRINSICS_) && defined(_XM_VMX128_INTRINSICS_)
#else
XMVECTOR XMVectorShiftLeft(FXMVECTOR V1, FXMVECTOR V2, UINT Elements);
XMVECTOR XMVectorRotateLeft(FXMVECTOR V, UINT Elements);
XMVECTOR XMVectorRotateRight(FXMVECTOR V, UINT Elements);
XMVECTOR XMVectorSwizzle(FXMVECTOR V, UINT E0, UINT E1, UINT E2, UINT E3);
XMVECTOR XMVectorInsert(FXMVECTOR VD, FXMVECTOR VS, UINT VSLeftRotateElements,
 UINT Select0, UINT Select1, UINT Select2, UINT Select3);
#endif

XMVECTOR XMVectorEqual(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorEqualR(_Out_ UINT* pCR, FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorEqualInt(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorEqualIntR(_Out_ UINT* pCR, FXMVECTOR V, FXMVECTOR V2);
XMVECTOR XMVectorNearEqual(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR Epsilon);
XMVECTOR XMVectorNotEqual(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorNotEqualInt(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorGreater(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorGreaterR(_Out_ UINT* pCR, FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorGreaterOrEqual(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorGreaterOrEqualR(_Out_ UINT* pCR, FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorLess(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorLessOrEqual(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorInBounds(FXMVECTOR V, FXMVECTOR Bounds);
XMVECTOR XMVectorInBoundsR(_Out_ UINT* pCR, FXMVECTOR V, FXMVECTOR Bounds);

XMVECTOR XMVectorIsNaN(FXMVECTOR V);
XMVECTOR XMVectorIsInfinite(FXMVECTOR V);

XMVECTOR XMVectorMin(FXMVECTOR V1,FXMVECTOR V2);
XMVECTOR XMVectorMax(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorRound(FXMVECTOR V);
XMVECTOR XMVectorTruncate(FXMVECTOR V);
XMVECTOR XMVectorFloor(FXMVECTOR V);
XMVECTOR XMVectorCeiling(FXMVECTOR V);
XMVECTOR XMVectorClamp(FXMVECTOR V, FXMVECTOR Min, FXMVECTOR Max);
XMVECTOR XMVectorSaturate(FXMVECTOR V);

XMVECTOR XMVectorAndInt(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorAndCInt(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorOrInt(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorNorInt(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorXorInt(FXMVECTOR V1, FXMVECTOR V2);

XMVECTOR XMVectorNegate(FXMVECTOR V);
XMVECTOR XMVectorAdd(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorAddAngles(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorSubtract(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorSubtractAngles(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorMultiply(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorMultiplyAdd(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR V3);
XMVECTOR XMVectorDivide(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorNegativeMultiplySubtract(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR V3);
XMVECTOR XMVectorScale(FXMVECTOR V, FLOAT ScaleFactor);
XMVECTOR XMVectorReciprocalEst(FXMVECTOR V);
XMVECTOR XMVectorReciprocal(FXMVECTOR V);
XMVECTOR XMVectorSqrtEst(FXMVECTOR V);
XMVECTOR XMVectorSqrt(FXMVECTOR V);
XMVECTOR XMVectorReciprocalSqrtEst(FXMVECTOR V);
XMVECTOR XMVectorReciprocalSqrt(FXMVECTOR V);
XMVECTOR XMVectorExpEst(FXMVECTOR V);
XMVECTOR XMVectorExp(FXMVECTOR V);
XMVECTOR XMVectorLogEst(FXMVECTOR V);
XMVECTOR XMVectorLog(FXMVECTOR V);
XMVECTOR XMVectorPowEst(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorPow(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorAbs(FXMVECTOR V);
XMVECTOR XMVectorMod(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVectorModAngles(FXMVECTOR Angles);
XMVECTOR XMVectorSin(FXMVECTOR V);
XMVECTOR XMVectorSinEst(FXMVECTOR V);
XMVECTOR XMVectorCos(FXMVECTOR V);
XMVECTOR XMVectorCosEst(FXMVECTOR V);
VOID XMVectorSinCos(_Out_ XMVECTOR* pSin, _Out_ XMVECTOR* pCos, FXMVECTOR V);
VOID XMVectorSinCosEst(_Out_ XMVECTOR* pSin, _Out_ XMVECTOR* pCos, FXMVECTOR V);
XMVECTOR XMVectorTan(FXMVECTOR V);
XMVECTOR XMVectorTanEst(FXMVECTOR V);
XMVECTOR XMVectorSinH(FXMVECTOR V);
XMVECTOR XMVectorSinHEst(FXMVECTOR V);
XMVECTOR XMVectorCosH(FXMVECTOR V);
XMVECTOR XMVectorCosHEst(FXMVECTOR V);
XMVECTOR XMVectorTanH(FXMVECTOR V);
XMVECTOR XMVectorTanHEst(FXMVECTOR V);
XMVECTOR XMVectorASin(FXMVECTOR V);
XMVECTOR XMVectorASinEst(FXMVECTOR V);
XMVECTOR XMVectorACos(FXMVECTOR V);
XMVECTOR XMVectorACosEst(FXMVECTOR V);
XMVECTOR XMVectorATan(FXMVECTOR V);
XMVECTOR XMVectorATanEst(FXMVECTOR V);
XMVECTOR XMVectorATan2(FXMVECTOR Y, FXMVECTOR X);
XMVECTOR XMVectorATan2Est(FXMVECTOR Y, FXMVECTOR X);
XMVECTOR XMVectorLerp(FXMVECTOR V0, FXMVECTOR V1, FLOAT t);
XMVECTOR XMVectorLerpV(FXMVECTOR V0, FXMVECTOR V1, FXMVECTOR T);
XMVECTOR XMVectorHermite(FXMVECTOR Position0, FXMVECTOR Tangent0, FXMVECTOR Position1, CXMVECTOR Tangent1, FLOAT t);
XMVECTOR XMVectorHermiteV(FXMVECTOR Position0, FXMVECTOR Tangent0, FXMVECTOR Position1, CXMVECTOR Tangent1, CXMVECTOR T);
XMVECTOR XMVectorCatmullRom(FXMVECTOR Position0, FXMVECTOR Position1, FXMVECTOR Position2, CXMVECTOR Position3, FLOAT t);
XMVECTOR XMVectorCatmullRomV(FXMVECTOR Position0, FXMVECTOR Position1, FXMVECTOR Position2, CXMVECTOR Position3, CXMVECTOR T);
XMVECTOR XMVectorBaryCentric(FXMVECTOR Position0, FXMVECTOR Position1, FXMVECTOR Position2, FLOAT f, FLOAT g);
XMVECTOR XMVectorBaryCentricV(FXMVECTOR Position0, FXMVECTOR Position1, FXMVECTOR Position2, CXMVECTOR F, CXMVECTOR G);

/****************************************************************************
 *
 * 2D vector operations
 *
 ****************************************************************************/


BOOL XMVector2Equal(FXMVECTOR V1, FXMVECTOR V2);
UINT XMVector2EqualR(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector2EqualInt(FXMVECTOR V1, FXMVECTOR V2);
UINT XMVector2EqualIntR(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector2NearEqual(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR Epsilon);
BOOL XMVector2NotEqual(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector2NotEqualInt(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector2Greater(FXMVECTOR V1, FXMVECTOR V2);
UINT XMVector2GreaterR(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector2GreaterOrEqual(FXMVECTOR V1, FXMVECTOR V2);
UINT XMVector2GreaterOrEqualR(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector2Less(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector2LessOrEqual(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector2InBounds(FXMVECTOR V, FXMVECTOR Bounds);
UINT XMVector2InBoundsR(FXMVECTOR V, FXMVECTOR Bounds);

BOOL XMVector2IsNaN(FXMVECTOR V);
BOOL XMVector2IsInfinite(FXMVECTOR V);

XMVECTOR XMVector2Dot(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVector2Cross(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVector2LengthSq(FXMVECTOR V);
XMVECTOR XMVector2ReciprocalLengthEst(FXMVECTOR V);
XMVECTOR XMVector2ReciprocalLength(FXMVECTOR V);
XMVECTOR XMVector2LengthEst(FXMVECTOR V);
XMVECTOR XMVector2Length(FXMVECTOR V);
XMVECTOR XMVector2NormalizeEst(FXMVECTOR V);
XMVECTOR XMVector2Normalize(FXMVECTOR V);
XMVECTOR XMVector2ClampLength(FXMVECTOR V, FLOAT LengthMin, FLOAT LengthMax);
XMVECTOR XMVector2ClampLengthV(FXMVECTOR V, FXMVECTOR LengthMin, FXMVECTOR LengthMax);
XMVECTOR XMVector2Reflect(FXMVECTOR Incident, FXMVECTOR Normal);
XMVECTOR XMVector2Refract(FXMVECTOR Incident, FXMVECTOR Normal, FLOAT RefractionIndex);
XMVECTOR XMVector2RefractV(FXMVECTOR Incident, FXMVECTOR Normal, FXMVECTOR RefractionIndex);
XMVECTOR XMVector2Orthogonal(FXMVECTOR V);
XMVECTOR XMVector2AngleBetweenNormalsEst(FXMVECTOR N1, FXMVECTOR N2);
XMVECTOR XMVector2AngleBetweenNormals(FXMVECTOR N1, FXMVECTOR N2);
XMVECTOR XMVector2AngleBetweenVectors(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVector2LinePointDistance(FXMVECTOR LinePoint1, FXMVECTOR LinePoint2, FXMVECTOR Point);
XMVECTOR XMVector2IntersectLine(FXMVECTOR Line1Point1, FXMVECTOR Line1Point2, FXMVECTOR Line2Point1, CXMVECTOR Line2Point2);
XMVECTOR XMVector2Transform(FXMVECTOR V, CXMMATRIX M);
XMFLOAT4* XMVector2TransformStream(_Out_bytecap_x_(sizeof(XMFLOAT4)+OutputStride*(VectorCount-1)) XMFLOAT4* pOutputStream,
 _In_ UINT OutputStride,
 _In_bytecount_x_(sizeof(XMFLOAT2)+InputStride*(VectorCount-1)) CONST XMFLOAT2* pInputStream,
 _In_ UINT InputStride, _In_ UINT VectorCount, CXMMATRIX M);
XMFLOAT4* XMVector2TransformStreamNC(_Out_bytecap_x_(sizeof(XMFLOAT4)+OutputStride*(VectorCount-1)) XMFLOAT4* pOutputStream,
 _In_ UINT OutputStride,
 _In_bytecount_x_(sizeof(XMFLOAT2)+InputStride*(VectorCount-1)) CONST XMFLOAT2* pInputStream,
 _In_ UINT InputStride, _In_ UINT VectorCount, CXMMATRIX M);
XMVECTOR XMVector2TransformCoord(FXMVECTOR V, CXMMATRIX M);
XMFLOAT2* XMVector2TransformCoordStream(_Out_bytecap_x_(sizeof(XMFLOAT2)+OutputStride*(VectorCount-1)) XMFLOAT2* pOutputStream,
 _In_ UINT OutputStride,
 _In_bytecount_x_(sizeof(XMFLOAT2)+InputStride*(VectorCount-1)) CONST XMFLOAT2* pInputStream,
 _In_ UINT InputStride, _In_ UINT VectorCount, CXMMATRIX M);
XMVECTOR XMVector2TransformNormal(FXMVECTOR V, CXMMATRIX M);
XMFLOAT2* XMVector2TransformNormalStream(_Out_bytecap_x_(sizeof(XMFLOAT2)+OutputStride*(VectorCount-1)) XMFLOAT2* pOutputStream,
 _In_ UINT OutputStride,
 _In_bytecount_x_(sizeof(XMFLOAT2)+InputStride*(VectorCount-1)) CONST XMFLOAT2* pInputStream,
 _In_ UINT InputStride, _In_ UINT VectorCount, CXMMATRIX M);

/****************************************************************************
 *
 * 3D vector operations
 *
 ****************************************************************************/


BOOL XMVector3Equal(FXMVECTOR V1, FXMVECTOR V2);
UINT XMVector3EqualR(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector3EqualInt(FXMVECTOR V1, FXMVECTOR V2);
UINT XMVector3EqualIntR(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector3NearEqual(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR Epsilon);
BOOL XMVector3NotEqual(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector3NotEqualInt(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector3Greater(FXMVECTOR V1, FXMVECTOR V2);
UINT XMVector3GreaterR(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector3GreaterOrEqual(FXMVECTOR V1, FXMVECTOR V2);
UINT XMVector3GreaterOrEqualR(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector3Less(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector3LessOrEqual(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector3InBounds(FXMVECTOR V, FXMVECTOR Bounds);
UINT XMVector3InBoundsR(FXMVECTOR V, FXMVECTOR Bounds);

BOOL XMVector3IsNaN(FXMVECTOR V);
BOOL XMVector3IsInfinite(FXMVECTOR V);

XMVECTOR XMVector3Dot(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVector3Cross(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVector3LengthSq(FXMVECTOR V);
XMVECTOR XMVector3ReciprocalLengthEst(FXMVECTOR V);
XMVECTOR XMVector3ReciprocalLength(FXMVECTOR V);
XMVECTOR XMVector3LengthEst(FXMVECTOR V);
XMVECTOR XMVector3Length(FXMVECTOR V);
XMVECTOR XMVector3NormalizeEst(FXMVECTOR V);
XMVECTOR XMVector3Normalize(FXMVECTOR V);
XMVECTOR XMVector3ClampLength(FXMVECTOR V, FLOAT LengthMin, FLOAT LengthMax);
XMVECTOR XMVector3ClampLengthV(FXMVECTOR V, FXMVECTOR LengthMin, FXMVECTOR LengthMax);
XMVECTOR XMVector3Reflect(FXMVECTOR Incident, FXMVECTOR Normal);
XMVECTOR XMVector3Refract(FXMVECTOR Incident, FXMVECTOR Normal, FLOAT RefractionIndex);
XMVECTOR XMVector3RefractV(FXMVECTOR Incident, FXMVECTOR Normal, FXMVECTOR RefractionIndex);
XMVECTOR XMVector3Orthogonal(FXMVECTOR V);
XMVECTOR XMVector3AngleBetweenNormalsEst(FXMVECTOR N1, FXMVECTOR N2);
XMVECTOR XMVector3AngleBetweenNormals(FXMVECTOR N1, FXMVECTOR N2);
XMVECTOR XMVector3AngleBetweenVectors(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVector3LinePointDistance(FXMVECTOR LinePoint1, FXMVECTOR LinePoint2, FXMVECTOR Point);
VOID XMVector3ComponentsFromNormal(_Out_ XMVECTOR* pParallel, _Out_ XMVECTOR* pPerpendicular, FXMVECTOR V, FXMVECTOR Normal);
XMVECTOR XMVector3Rotate(FXMVECTOR V, FXMVECTOR RotationQuaternion);
XMVECTOR XMVector3InverseRotate(FXMVECTOR V, FXMVECTOR RotationQuaternion);
XMVECTOR XMVector3Transform(FXMVECTOR V, CXMMATRIX M);
XMFLOAT4* XMVector3TransformStream(_Out_bytecap_x_(sizeof(XMFLOAT4)+OutputStride*(VectorCount-1)) XMFLOAT4* pOutputStream,
 _In_ UINT OutputStride,
 _In_bytecount_x_(sizeof(XMFLOAT3)+InputStride*(VectorCount-1)) CONST XMFLOAT3* pInputStream,
 _In_ UINT InputStride, _In_ UINT VectorCount, CXMMATRIX M);
XMFLOAT4* XMVector3TransformStreamNC(_Out_bytecap_x_(sizeof(XMFLOAT4)+OutputStride*(VectorCount-1)) XMFLOAT4* pOutputStream,
 _In_ UINT OutputStride,
 _In_bytecount_x_(sizeof(XMFLOAT3)+InputStride*(VectorCount-1)) CONST XMFLOAT3* pInputStream,
 _In_ UINT InputStride, _In_ UINT VectorCount, CXMMATRIX M);
XMVECTOR XMVector3TransformCoord(FXMVECTOR V, CXMMATRIX M);
XMFLOAT3* XMVector3TransformCoordStream(_Out_bytecap_x_(sizeof(XMFLOAT3)+OutputStride*(VectorCount-1)) XMFLOAT3* pOutputStream,
 _In_ UINT OutputStride,
 _In_bytecount_x_(sizeof(XMFLOAT3)+InputStride*(VectorCount-1)) CONST XMFLOAT3* pInputStream,
 _In_ UINT InputStride, _In_ UINT VectorCount, CXMMATRIX M);
XMVECTOR XMVector3TransformNormal(FXMVECTOR V, CXMMATRIX M);
XMFLOAT3* XMVector3TransformNormalStream(_Out_bytecap_x_(sizeof(XMFLOAT3)+OutputStride*(VectorCount-1)) XMFLOAT3* pOutputStream,
 _In_ UINT OutputStride,
 _In_bytecount_x_(sizeof(XMFLOAT3)+InputStride*(VectorCount-1)) CONST XMFLOAT3* pInputStream,
 _In_ UINT InputStride, _In_ UINT VectorCount, CXMMATRIX M);
XMVECTOR XMVector3Project(FXMVECTOR V, FLOAT ViewportX, FLOAT ViewportY, FLOAT ViewportWidth, FLOAT ViewportHeight, FLOAT ViewportMinZ, FLOAT ViewportMaxZ, 
 CXMMATRIX Projection, CXMMATRIX View, CXMMATRIX World);
XMFLOAT3* XMVector3ProjectStream(_Out_bytecap_x_(sizeof(XMFLOAT3)+OutputStride*(VectorCount-1)) XMFLOAT3* pOutputStream,
 _In_ UINT OutputStride,
 _In_bytecount_x_(sizeof(XMFLOAT3)+InputStride*(VectorCount-1)) CONST XMFLOAT3* pInputStream,
 _In_ UINT InputStride, _In_ UINT VectorCount, 
 FLOAT ViewportX, FLOAT ViewportY, FLOAT ViewportWidth, FLOAT ViewportHeight, FLOAT ViewportMinZ, FLOAT ViewportMaxZ, 
 CXMMATRIX Projection, CXMMATRIX View, CXMMATRIX World);
XMVECTOR XMVector3Unproject(FXMVECTOR V, FLOAT ViewportX, FLOAT ViewportY, FLOAT ViewportWidth, FLOAT ViewportHeight, FLOAT ViewportMinZ, FLOAT ViewportMaxZ, 
 CXMMATRIX Projection, CXMMATRIX View, CXMMATRIX World);
XMFLOAT3* XMVector3UnprojectStream(_Out_bytecap_x_(sizeof(XMFLOAT3)+OutputStride*(VectorCount-1)) XMFLOAT3* pOutputStream,
 _In_ UINT OutputStride,
 _In_bytecount_x_(sizeof(XMFLOAT3)+InputStride*(VectorCount-1)) CONST XMFLOAT3* pInputStream,
 _In_ UINT InputStride, _In_ UINT VectorCount, 
 FLOAT ViewportX, FLOAT ViewportY, FLOAT ViewportWidth, FLOAT ViewportHeight, FLOAT ViewportMinZ, FLOAT ViewportMaxZ, 
 CXMMATRIX Projection, CXMMATRIX View, CXMMATRIX World);

/****************************************************************************
 *
 * 4D vector operations
 *
 ****************************************************************************/

BOOL XMVector4Equal(FXMVECTOR V1, FXMVECTOR V2);
UINT XMVector4EqualR(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector4EqualInt(FXMVECTOR V1, FXMVECTOR V2);
UINT XMVector4EqualIntR(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector4NearEqual(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR Epsilon);
BOOL XMVector4NotEqual(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector4NotEqualInt(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector4Greater(FXMVECTOR V1, FXMVECTOR V2);
UINT XMVector4GreaterR(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector4GreaterOrEqual(FXMVECTOR V1, FXMVECTOR V2);
UINT XMVector4GreaterOrEqualR(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector4Less(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector4LessOrEqual(FXMVECTOR V1, FXMVECTOR V2);
BOOL XMVector4InBounds(FXMVECTOR V, FXMVECTOR Bounds);
UINT XMVector4InBoundsR(FXMVECTOR V, FXMVECTOR Bounds);

BOOL XMVector4IsNaN(FXMVECTOR V);
BOOL XMVector4IsInfinite(FXMVECTOR V);

XMVECTOR XMVector4Dot(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVector4Cross(FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR V3);
XMVECTOR XMVector4LengthSq(FXMVECTOR V);
XMVECTOR XMVector4ReciprocalLengthEst(FXMVECTOR V);
XMVECTOR XMVector4ReciprocalLength(FXMVECTOR V);
XMVECTOR XMVector4LengthEst(FXMVECTOR V);
XMVECTOR XMVector4Length(FXMVECTOR V);
XMVECTOR XMVector4NormalizeEst(FXMVECTOR V);
XMVECTOR XMVector4Normalize(FXMVECTOR V);
XMVECTOR XMVector4ClampLength(FXMVECTOR V, FLOAT LengthMin, FLOAT LengthMax);
XMVECTOR XMVector4ClampLengthV(FXMVECTOR V, FXMVECTOR LengthMin, FXMVECTOR LengthMax);
XMVECTOR XMVector4Reflect(FXMVECTOR Incident, FXMVECTOR Normal);
XMVECTOR XMVector4Refract(FXMVECTOR Incident, FXMVECTOR Normal, FLOAT RefractionIndex);
XMVECTOR XMVector4RefractV(FXMVECTOR Incident, FXMVECTOR Normal, FXMVECTOR RefractionIndex);
XMVECTOR XMVector4Orthogonal(FXMVECTOR V);
XMVECTOR XMVector4AngleBetweenNormalsEst(FXMVECTOR N1, FXMVECTOR N2);
XMVECTOR XMVector4AngleBetweenNormals(FXMVECTOR N1, FXMVECTOR N2);
XMVECTOR XMVector4AngleBetweenVectors(FXMVECTOR V1, FXMVECTOR V2);
XMVECTOR XMVector4Transform(FXMVECTOR V, CXMMATRIX M);
XMFLOAT4* XMVector4TransformStream(_Out_bytecap_x_(sizeof(XMFLOAT4)+OutputStride*(VectorCount-1)) XMFLOAT4* pOutputStream,
 _In_ UINT OutputStride,
 _In_bytecount_x_(sizeof(XMFLOAT4)+InputStride*(VectorCount-1)) CONST XMFLOAT4* pInputStream,
 _In_ UINT InputStride, _In_ UINT VectorCount, CXMMATRIX M);

/****************************************************************************
 *
 * Matrix operations
 *
 ****************************************************************************/

BOOL XMMatrixIsNaN(CXMMATRIX M);
BOOL XMMatrixIsInfinite(CXMMATRIX M);
BOOL XMMatrixIsIdentity(CXMMATRIX M);

XMMATRIX XMMatrixMultiply(CXMMATRIX M1, CXMMATRIX M2);
XMMATRIX XMMatrixMultiplyTranspose(CXMMATRIX M1, CXMMATRIX M2);
XMMATRIX XMMatrixTranspose(CXMMATRIX M);
XMMATRIX XMMatrixInverse(_Out_ XMVECTOR* pDeterminant, CXMMATRIX M);
XMVECTOR XMMatrixDeterminant(CXMMATRIX M);
BOOL XMMatrixDecompose(_Out_ XMVECTOR *outScale, _Out_ XMVECTOR *outRotQuat, _Out_ XMVECTOR *outTrans, CXMMATRIX M);

XMMATRIX XMMatrixIdentity();
XMMATRIX XMMatrixSet(FLOAT m00, FLOAT m01, FLOAT m02, FLOAT m03,
 FLOAT m10, FLOAT m11, FLOAT m12, FLOAT m13,
 FLOAT m20, FLOAT m21, FLOAT m22, FLOAT m23,
 FLOAT m30, FLOAT m31, FLOAT m32, FLOAT m33);
XMMATRIX XMMatrixTranslation(FLOAT OffsetX, FLOAT OffsetY, FLOAT OffsetZ);
XMMATRIX XMMatrixTranslationFromVector(FXMVECTOR Offset);
XMMATRIX XMMatrixScaling(FLOAT ScaleX, FLOAT ScaleY, FLOAT ScaleZ);
XMMATRIX XMMatrixScalingFromVector(FXMVECTOR Scale);
XMMATRIX XMMatrixRotationX(FLOAT Angle);
XMMATRIX XMMatrixRotationY(FLOAT Angle);
XMMATRIX XMMatrixRotationZ(FLOAT Angle);
XMMATRIX XMMatrixRotationRollPitchYaw(FLOAT Pitch, FLOAT Yaw, FLOAT Roll);
XMMATRIX XMMatrixRotationRollPitchYawFromVector(FXMVECTOR Angles);
XMMATRIX XMMatrixRotationNormal(FXMVECTOR NormalAxis, FLOAT Angle);
XMMATRIX XMMatrixRotationAxis(FXMVECTOR Axis, FLOAT Angle);
XMMATRIX XMMatrixRotationQuaternion(FXMVECTOR Quaternion);
XMMATRIX XMMatrixTransformation2D(FXMVECTOR ScalingOrigin, FLOAT ScalingOrientation, FXMVECTOR Scaling, 
 FXMVECTOR RotationOrigin, FLOAT Rotation, CXMVECTOR Translation);
XMMATRIX XMMatrixTransformation(FXMVECTOR ScalingOrigin, FXMVECTOR ScalingOrientationQuaternion, FXMVECTOR Scaling, 
 CXMVECTOR RotationOrigin, CXMVECTOR RotationQuaternion, CXMVECTOR Translation);
XMMATRIX XMMatrixAffineTransformation2D(FXMVECTOR Scaling, FXMVECTOR RotationOrigin, FLOAT Rotation, FXMVECTOR Translation);
XMMATRIX XMMatrixAffineTransformation(FXMVECTOR Scaling, FXMVECTOR RotationOrigin, FXMVECTOR RotationQuaternion, CXMVECTOR Translation);
XMMATRIX XMMatrixReflect(FXMVECTOR ReflectionPlane);
XMMATRIX XMMatrixShadow(FXMVECTOR ShadowPlane, FXMVECTOR LightPosition);

XMMATRIX XMMatrixLookAtLH(FXMVECTOR EyePosition, FXMVECTOR FocusPosition, FXMVECTOR UpDirection);
XMMATRIX XMMatrixLookAtRH(FXMVECTOR EyePosition, FXMVECTOR FocusPosition, FXMVECTOR UpDirection);
XMMATRIX XMMatrixLookToLH(FXMVECTOR EyePosition, FXMVECTOR EyeDirection, FXMVECTOR UpDirection);
XMMATRIX XMMatrixLookToRH(FXMVECTOR EyePosition, FXMVECTOR EyeDirection, FXMVECTOR UpDirection);
XMMATRIX XMMatrixPerspectiveLH(FLOAT ViewWidth, FLOAT ViewHeight, FLOAT NearZ, FLOAT FarZ);
XMMATRIX XMMatrixPerspectiveRH(FLOAT ViewWidth, FLOAT ViewHeight, FLOAT NearZ, FLOAT FarZ);
XMMATRIX XMMatrixPerspectiveFovLH(FLOAT FovAngleY, FLOAT AspectHByW, FLOAT NearZ, FLOAT FarZ);
XMMATRIX XMMatrixPerspectiveFovRH(FLOAT FovAngleY, FLOAT AspectHByW, FLOAT NearZ, FLOAT FarZ);
XMMATRIX XMMatrixPerspectiveOffCenterLH(FLOAT ViewLeft, FLOAT ViewRight, FLOAT ViewBottom, FLOAT ViewTop, FLOAT NearZ, FLOAT FarZ);
XMMATRIX XMMatrixPerspectiveOffCenterRH(FLOAT ViewLeft, FLOAT ViewRight, FLOAT ViewBottom, FLOAT ViewTop, FLOAT NearZ, FLOAT FarZ);
XMMATRIX XMMatrixOrthographicLH(FLOAT ViewWidth, FLOAT ViewHeight, FLOAT NearZ, FLOAT FarZ);
XMMATRIX XMMatrixOrthographicRH(FLOAT ViewWidth, FLOAT ViewHeight, FLOAT NearZ, FLOAT FarZ);
XMMATRIX XMMatrixOrthographicOffCenterLH(FLOAT ViewLeft, FLOAT ViewRight, FLOAT ViewBottom, FLOAT ViewTop, FLOAT NearZ, FLOAT FarZ);
XMMATRIX XMMatrixOrthographicOffCenterRH(FLOAT ViewLeft, FLOAT ViewRight, FLOAT ViewBottom, FLOAT ViewTop, FLOAT NearZ, FLOAT FarZ);

/****************************************************************************
 *
 * Quaternion operations
 *
 ****************************************************************************/

BOOL XMQuaternionEqual(FXMVECTOR Q1, FXMVECTOR Q2);
BOOL XMQuaternionNotEqual(FXMVECTOR Q1, FXMVECTOR Q2);

BOOL XMQuaternionIsNaN(FXMVECTOR Q);
BOOL XMQuaternionIsInfinite(FXMVECTOR Q);
BOOL XMQuaternionIsIdentity(FXMVECTOR Q);

XMVECTOR XMQuaternionDot(FXMVECTOR Q1, FXMVECTOR Q2);
XMVECTOR XMQuaternionMultiply(FXMVECTOR Q1, FXMVECTOR Q2);
XMVECTOR XMQuaternionLengthSq(FXMVECTOR Q);
XMVECTOR XMQuaternionReciprocalLength(FXMVECTOR Q);
XMVECTOR XMQuaternionLength(FXMVECTOR Q);
XMVECTOR XMQuaternionNormalizeEst(FXMVECTOR Q);
XMVECTOR XMQuaternionNormalize(FXMVECTOR Q);
XMVECTOR XMQuaternionConjugate(FXMVECTOR Q);
XMVECTOR XMQuaternionInverse(FXMVECTOR Q);
XMVECTOR XMQuaternionLn(FXMVECTOR Q);
XMVECTOR XMQuaternionExp(FXMVECTOR Q);
XMVECTOR XMQuaternionSlerp(FXMVECTOR Q0, FXMVECTOR Q1, FLOAT t);
XMVECTOR XMQuaternionSlerpV(FXMVECTOR Q0, FXMVECTOR Q1, FXMVECTOR T);
XMVECTOR XMQuaternionSquad(FXMVECTOR Q0, FXMVECTOR Q1, FXMVECTOR Q2, CXMVECTOR Q3, FLOAT t);
XMVECTOR XMQuaternionSquadV(FXMVECTOR Q0, FXMVECTOR Q1, FXMVECTOR Q2, CXMVECTOR Q3, CXMVECTOR T);
VOID XMQuaternionSquadSetup(_Out_ XMVECTOR* pA, _Out_ XMVECTOR* pB, _Out_ XMVECTOR* pC, FXMVECTOR Q0, FXMVECTOR Q1, FXMVECTOR Q2, CXMVECTOR Q3);
XMVECTOR XMQuaternionBaryCentric(FXMVECTOR Q0, FXMVECTOR Q1, FXMVECTOR Q2, FLOAT f, FLOAT g);
XMVECTOR XMQuaternionBaryCentricV(FXMVECTOR Q0, FXMVECTOR Q1, FXMVECTOR Q2, CXMVECTOR F, CXMVECTOR G);

XMVECTOR XMQuaternionIdentity();
XMVECTOR XMQuaternionRotationRollPitchYaw(FLOAT Pitch, FLOAT Yaw, FLOAT Roll);
XMVECTOR XMQuaternionRotationRollPitchYawFromVector(FXMVECTOR Angles);
XMVECTOR XMQuaternionRotationNormal(FXMVECTOR NormalAxis, FLOAT Angle);
XMVECTOR XMQuaternionRotationAxis(FXMVECTOR Axis, FLOAT Angle);
XMVECTOR XMQuaternionRotationMatrix(CXMMATRIX M);

VOID XMQuaternionToAxisAngle(_Out_ XMVECTOR* pAxis, _Out_ FLOAT* pAngle, FXMVECTOR Q);

/****************************************************************************
 *
 * Plane operations
 *
 ****************************************************************************/

BOOL XMPlaneEqual(FXMVECTOR P1, FXMVECTOR P2);
BOOL XMPlaneNearEqual(FXMVECTOR P1, FXMVECTOR P2, FXMVECTOR Epsilon);
BOOL XMPlaneNotEqual(FXMVECTOR P1, FXMVECTOR P2);

BOOL XMPlaneIsNaN(FXMVECTOR P);
BOOL XMPlaneIsInfinite(FXMVECTOR P);

XMVECTOR XMPlaneDot(FXMVECTOR P, FXMVECTOR V);
XMVECTOR XMPlaneDotCoord(FXMVECTOR P, FXMVECTOR V);
XMVECTOR XMPlaneDotNormal(FXMVECTOR P, FXMVECTOR V);
XMVECTOR XMPlaneNormalizeEst(FXMVECTOR P);
XMVECTOR XMPlaneNormalize(FXMVECTOR P);
XMVECTOR XMPlaneIntersectLine(FXMVECTOR P, FXMVECTOR LinePoint1, FXMVECTOR LinePoint2);
VOID XMPlaneIntersectPlane(_Out_ XMVECTOR* pLinePoint1, _Out_ XMVECTOR* pLinePoint2, FXMVECTOR P1, FXMVECTOR P2);
XMVECTOR XMPlaneTransform(FXMVECTOR P, CXMMATRIX M);
XMFLOAT4* XMPlaneTransformStream(_Out_bytecap_x_(sizeof(XMFLOAT4)+OutputStride*(PlaneCount-1)) XMFLOAT4* pOutputStream,
 _In_ UINT OutputStride,
 _In_bytecount_x_(sizeof(XMFLOAT4)+InputStride*(PlaneCount-1)) CONST XMFLOAT4* pInputStream,
 _In_ UINT InputStride, _In_ UINT PlaneCount, CXMMATRIX M);

XMVECTOR XMPlaneFromPointNormal(FXMVECTOR Point, FXMVECTOR Normal);
XMVECTOR XMPlaneFromPoints(FXMVECTOR Point1, FXMVECTOR Point2, FXMVECTOR Point3);

/****************************************************************************
 *
 * Color operations
 *
 ****************************************************************************/

BOOL XMColorEqual(FXMVECTOR C1, FXMVECTOR C2);
BOOL XMColorNotEqual(FXMVECTOR C1, FXMVECTOR C2);
BOOL XMColorGreater(FXMVECTOR C1, FXMVECTOR C2);
BOOL XMColorGreaterOrEqual(FXMVECTOR C1, FXMVECTOR C2);
BOOL XMColorLess(FXMVECTOR C1, FXMVECTOR C2);
BOOL XMColorLessOrEqual(FXMVECTOR C1, FXMVECTOR C2);

BOOL XMColorIsNaN(FXMVECTOR C);
BOOL XMColorIsInfinite(FXMVECTOR C);

XMVECTOR XMColorNegative(FXMVECTOR C);
XMVECTOR XMColorModulate(FXMVECTOR C1, FXMVECTOR C2);
XMVECTOR XMColorAdjustSaturation(FXMVECTOR C, FLOAT Saturation);
XMVECTOR XMColorAdjustContrast(FXMVECTOR C, FLOAT Contrast);

/****************************************************************************
 *
 * Miscellaneous operations
 *
 ****************************************************************************/

BOOL XMVerifyCPUSupport();

VOID XMAssert(_In_z_ CONST CHAR* pExpression, _In_z_ CONST CHAR* pFileName, UINT LineNumber);

XMVECTOR XMFresnelTerm(FXMVECTOR CosIncidentAngle, FXMVECTOR RefractionIndex);

BOOL XMScalarNearEqual(FLOAT S1, FLOAT S2, FLOAT Epsilon);
FLOAT XMScalarModAngle(FLOAT Value);
FLOAT XMScalarSin(FLOAT Value);
FLOAT XMScalarCos(FLOAT Value);
VOID XMScalarSinCos(_Out_ FLOAT* pSin, _Out_ FLOAT* pCos, FLOAT Value);
FLOAT XMScalarASin(FLOAT Value);
FLOAT XMScalarACos(FLOAT Value);
FLOAT XMScalarSinEst(FLOAT Value);
FLOAT XMScalarCosEst(FLOAT Value);
VOID XMScalarSinCosEst(_Out_ FLOAT* pSin, _Out_ FLOAT* pCos, FLOAT Value);
FLOAT XMScalarASinEst(FLOAT Value);
FLOAT XMScalarACosEst(FLOAT Value);

/****************************************************************************
 *
 * Globals
 *
 ****************************************************************************/

// The purpose of the following global constants is to prevent redundant 
// reloading of the constants when they are referenced by more than one
// separate inline math routine called within the same function. Declaring
// a constant locally within a routine is sufficient to prevent redundant
// reloads of that constant when that single routine is called multiple
// times in a function, but if the constant is used (and declared) in a 
// separate math routine it would be reloaded.

#define XMGLOBALCONST extern CONST __declspec(selectany)

XMGLOBALCONST XMVECTORF32 g_XMSinCoefficients0 = {1.0f, -0.166666667f, 8.333333333e-3f, -1.984126984e-4f};
XMGLOBALCONST XMVECTORF32 g_XMSinCoefficients1 = {2.755731922e-6f, -2.505210839e-8f, 1.605904384e-10f, -7.647163732e-13f};
XMGLOBALCONST XMVECTORF32 g_XMSinCoefficients2 = {2.811457254e-15f, -8.220635247e-18f, 1.957294106e-20f, -3.868170171e-23f};
XMGLOBALCONST XMVECTORF32 g_XMCosCoefficients0 = {1.0f, -0.5f, 4.166666667e-2f, -1.388888889e-3f};
XMGLOBALCONST XMVECTORF32 g_XMCosCoefficients1 = {2.480158730e-5f, -2.755731922e-7f, 2.087675699e-9f, -1.147074560e-11f};
XMGLOBALCONST XMVECTORF32 g_XMCosCoefficients2 = {4.779477332e-14f, -1.561920697e-16f, 4.110317623e-19f, -8.896791392e-22f};
XMGLOBALCONST XMVECTORF32 g_XMTanCoefficients0 = {1.0f, 0.333333333f, 0.133333333f, 5.396825397e-2f};
XMGLOBALCONST XMVECTORF32 g_XMTanCoefficients1 = {2.186948854e-2f, 8.863235530e-3f, 3.592128167e-3f, 1.455834485e-3f};
XMGLOBALCONST XMVECTORF32 g_XMTanCoefficients2 = {5.900274264e-4f, 2.391290764e-4f, 9.691537707e-5f, 3.927832950e-5f};
XMGLOBALCONST XMVECTORF32 g_XMASinCoefficients0 = {-0.05806367563904f, -0.41861972469416f, 0.22480114791621f, 2.17337241360606f};
XMGLOBALCONST XMVECTORF32 g_XMASinCoefficients1 = {0.61657275907170f, 4.29696498283455f, -1.18942822255452f, -6.53784832094831f};
XMGLOBALCONST XMVECTORF32 g_XMASinCoefficients2 = {-1.36926553863413f, -4.48179294237210f, 1.41810672941833f, 5.48179257935713f};
XMGLOBALCONST XMVECTORF32 g_XMATanCoefficients0 = {1.0f, 0.333333334f, 0.2f, 0.142857143f};
XMGLOBALCONST XMVECTORF32 g_XMATanCoefficients1 = {1.111111111e-1f, 9.090909091e-2f, 7.692307692e-2f, 6.666666667e-2f};
XMGLOBALCONST XMVECTORF32 g_XMATanCoefficients2 = {5.882352941e-2f, 5.263157895e-2f, 4.761904762e-2f, 4.347826087e-2f};
XMGLOBALCONST XMVECTORF32 g_XMSinEstCoefficients = {1.0f, -1.66521856991541e-1f, 8.199913018755e-3f, -1.61475937228e-4f};
XMGLOBALCONST XMVECTORF32 g_XMCosEstCoefficients = {1.0f, -4.95348008918096e-1f, 3.878259962881e-2f, -9.24587976263e-4f};
XMGLOBALCONST XMVECTORF32 g_XMTanEstCoefficients = {2.484f, -1.954923183e-1f, 2.467401101f, XM_1DIVPI};
XMGLOBALCONST XMVECTORF32 g_XMATanEstCoefficients = {7.689891418951e-1f, 1.104742493348f, 8.661844266006e-1f, XM_PIDIV2};
XMGLOBALCONST XMVECTORF32 g_XMASinEstCoefficients = {-1.36178272886711f, 2.37949493464538f, -8.08228565650486e-1f, 2.78440142746736e-1f};
XMGLOBALCONST XMVECTORF32 g_XMASinEstConstants = {1.00000011921f, XM_PIDIV2, 0.0f, 0.0f};
XMGLOBALCONST XMVECTORF32 g_XMPiConstants0 = {XM_PI, XM_2PI, XM_1DIVPI, XM_1DIV2PI};
XMGLOBALCONST XMVECTORF32 g_XMIdentityR0 = {1.0f, 0.0f, 0.0f, 0.0f};
XMGLOBALCONST XMVECTORF32 g_XMIdentityR1 = {0.0f, 1.0f, 0.0f, 0.0f};
XMGLOBALCONST XMVECTORF32 g_XMIdentityR2 = {0.0f, 0.0f, 1.0f, 0.0f};
XMGLOBALCONST XMVECTORF32 g_XMIdentityR3 = {0.0f, 0.0f, 0.0f, 1.0f};
XMGLOBALCONST XMVECTORF32 g_XMNegIdentityR0 = {-1.0f,0.0f, 0.0f, 0.0f};
XMGLOBALCONST XMVECTORF32 g_XMNegIdentityR1 = {0.0f,-1.0f, 0.0f, 0.0f};
XMGLOBALCONST XMVECTORF32 g_XMNegIdentityR2 = {0.0f, 0.0f,-1.0f, 0.0f};
XMGLOBALCONST XMVECTORF32 g_XMNegIdentityR3 = {0.0f, 0.0f, 0.0f,-1.0f};
XMGLOBALCONST XMVECTORI32 g_XMNegativeZero = {0x80000000, 0x80000000, 0x80000000, 0x80000000};
XMGLOBALCONST XMVECTORI32 g_XMNegate3 = {0x80000000, 0x80000000, 0x80000000, 0x00000000};
XMGLOBALCONST XMVECTORI32 g_XMMask3 = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000};
XMGLOBALCONST XMVECTORI32 g_XMMaskX = {0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000};
XMGLOBALCONST XMVECTORI32 g_XMMaskY = {0x00000000, 0xFFFFFFFF, 0x00000000, 0x00000000};
XMGLOBALCONST XMVECTORI32 g_XMMaskZ = {0x00000000, 0x00000000, 0xFFFFFFFF, 0x00000000};
XMGLOBALCONST XMVECTORI32 g_XMMaskW = {0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF};
XMGLOBALCONST XMVECTORF32 g_XMOne = { 1.0f, 1.0f, 1.0f, 1.0f};
XMGLOBALCONST XMVECTORF32 g_XMOne3 = { 1.0f, 1.0f, 1.0f, 0.0f};
XMGLOBALCONST XMVECTORF32 g_XMZero = { 0.0f, 0.0f, 0.0f, 0.0f};
XMGLOBALCONST XMVECTORF32 g_XMNegativeOne = {-1.0f,-1.0f,-1.0f,-1.0f};
XMGLOBALCONST XMVECTORF32 g_XMOneHalf = { 0.5f, 0.5f, 0.5f, 0.5f};
XMGLOBALCONST XMVECTORF32 g_XMNegativeOneHalf = {-0.5f,-0.5f,-0.5f,-0.5f};
XMGLOBALCONST XMVECTORF32 g_XMNegativeTwoPi = {-XM_2PI, -XM_2PI, -XM_2PI, -XM_2PI};
XMGLOBALCONST XMVECTORF32 g_XMNegativePi = {-XM_PI, -XM_PI, -XM_PI, -XM_PI};
XMGLOBALCONST XMVECTORF32 g_XMHalfPi = {XM_PIDIV2, XM_PIDIV2, XM_PIDIV2, XM_PIDIV2};
XMGLOBALCONST XMVECTORF32 g_XMPi = {XM_PI, XM_PI, XM_PI, XM_PI};
XMGLOBALCONST XMVECTORF32 g_XMReciprocalPi = {XM_1DIVPI, XM_1DIVPI, XM_1DIVPI, XM_1DIVPI};
XMGLOBALCONST XMVECTORF32 g_XMTwoPi = {XM_2PI, XM_2PI, XM_2PI, XM_2PI};
XMGLOBALCONST XMVECTORF32 g_XMReciprocalTwoPi = {XM_1DIV2PI, XM_1DIV2PI, XM_1DIV2PI, XM_1DIV2PI};
XMGLOBALCONST XMVECTORF32 g_XMEpsilon = {1.192092896e-7f, 1.192092896e-7f, 1.192092896e-7f, 1.192092896e-7f};
XMGLOBALCONST XMVECTORI32 g_XMInfinity = {0x7F800000, 0x7F800000, 0x7F800000, 0x7F800000};
XMGLOBALCONST XMVECTORI32 g_XMQNaN = {0x7FC00000, 0x7FC00000, 0x7FC00000, 0x7FC00000};
XMGLOBALCONST XMVECTORI32 g_XMQNaNTest = {0x007FFFFF, 0x007FFFFF, 0x007FFFFF, 0x007FFFFF};
XMGLOBALCONST XMVECTORI32 g_XMAbsMask = {0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF};
XMGLOBALCONST XMVECTORI32 g_XMFltMin = {0x00800000, 0x00800000, 0x00800000, 0x00800000};
XMGLOBALCONST XMVECTORI32 g_XMFltMax = {0x7F7FFFFF, 0x7F7FFFFF, 0x7F7FFFFF, 0x7F7FFFFF};
XMGLOBALCONST XMVECTORI32 g_XMNegOneMask = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
XMGLOBALCONST XMVECTORI32 g_XMMaskA8R8G8B8 = {0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000};
XMGLOBALCONST XMVECTORI32 g_XMFlipA8R8G8B8 = {0x00000000, 0x00000000, 0x00000000, 0x80000000};
XMGLOBALCONST XMVECTORF32 g_XMFixAA8R8G8B8 = {0.0f,0.0f,0.0f,(float)(0x80000000U)};
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))};
XMGLOBALCONST XMVECTORI32 g_XMMaskA2B10G10R10 = {0x000003FF, 0x000FFC00, 0x3FF00000, 0xC0000000};
XMGLOBALCONST XMVECTORI32 g_XMFlipA2B10G10R10 = {0x00000200, 0x00080000, 0x20000000, 0x80000000};
XMGLOBALCONST XMVECTORF32 g_XMFixAA2B10G10R10 = {-512.0f,-512.0f*(float)(0x400),-512.0f*(float)(0x100000),(float)(0x80000000U)};
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))};
XMGLOBALCONST XMVECTORI32 g_XMMaskX16Y16 = {0x0000FFFF, 0xFFFF0000, 0x00000000, 0x00000000};
XMGLOBALCONST XMVECTORI32 g_XMFlipX16Y16 = {0x00008000, 0x00000000, 0x00000000, 0x00000000};
XMGLOBALCONST XMVECTORF32 g_XMFixX16Y16 = {-32768.0f,0.0f,0.0f,0.0f};
XMGLOBALCONST XMVECTORF32 g_XMNormalizeX16Y16 = {1.0f/32767.0f,1.0f/(32767.0f*65536.0f),0.0f,0.0f};
XMGLOBALCONST XMVECTORI32 g_XMMaskX16Y16Z16W16 = {0x0000FFFF, 0x0000FFFF, 0xFFFF0000, 0xFFFF0000};
XMGLOBALCONST XMVECTORI32 g_XMFlipX16Y16Z16W16 = {0x00008000, 0x00008000, 0x00000000, 0x00000000};
XMGLOBALCONST XMVECTORF32 g_XMFixX16Y16Z16W16 = {-32768.0f,-32768.0f,0.0f,0.0f};
XMGLOBALCONST XMVECTORF32 g_XMNormalizeX16Y16Z16W16 = {1.0f/32767.0f,1.0f/32767.0f,1.0f/(32767.0f*65536.0f),1.0f/(32767.0f*65536.0f)};
XMGLOBALCONST XMVECTORF32 g_XMNoFraction = {8388608.0f,8388608.0f,8388608.0f,8388608.0f};
XMGLOBALCONST XMVECTORI32 g_XMMaskByte = {0x000000FF, 0x000000FF, 0x000000FF, 0x000000FF};
XMGLOBALCONST XMVECTORF32 g_XMNegateX = {-1.0f, 1.0f, 1.0f, 1.0f};
XMGLOBALCONST XMVECTORF32 g_XMNegateY = { 1.0f,-1.0f, 1.0f, 1.0f};
XMGLOBALCONST XMVECTORF32 g_XMNegateZ = { 1.0f, 1.0f,-1.0f, 1.0f};
XMGLOBALCONST XMVECTORF32 g_XMNegateW = { 1.0f, 1.0f, 1.0f,-1.0f};
XMGLOBALCONST XMVECTORI32 g_XMSelect0101 = {XM_SELECT_0, XM_SELECT_1, XM_SELECT_0, XM_SELECT_1};
XMGLOBALCONST XMVECTORI32 g_XMSelect1010 = {XM_SELECT_1, XM_SELECT_0, XM_SELECT_1, XM_SELECT_0};
XMGLOBALCONST XMVECTORI32 g_XMOneHalfMinusEpsilon = { 0x3EFFFFFD, 0x3EFFFFFD, 0x3EFFFFFD, 0x3EFFFFFD};
XMGLOBALCONST XMVECTORI32 g_XMSelect1000 = {XM_SELECT_1, XM_SELECT_0, XM_SELECT_0, XM_SELECT_0};
XMGLOBALCONST XMVECTORI32 g_XMSelect1100 = {XM_SELECT_1, XM_SELECT_1, XM_SELECT_0, XM_SELECT_0};
XMGLOBALCONST XMVECTORI32 g_XMSelect1110 = {XM_SELECT_1, XM_SELECT_1, XM_SELECT_1, XM_SELECT_0};
XMGLOBALCONST XMVECTORI32 g_XMSwizzleXYXY = {XM_PERMUTE_0X, XM_PERMUTE_0Y, XM_PERMUTE_0X, XM_PERMUTE_0Y};
XMGLOBALCONST XMVECTORI32 g_XMSwizzleXYZX = {XM_PERMUTE_0X, XM_PERMUTE_0Y, XM_PERMUTE_0Z, XM_PERMUTE_0X};
XMGLOBALCONST XMVECTORI32 g_XMSwizzleYXZW = {XM_PERMUTE_0Y, XM_PERMUTE_0X, XM_PERMUTE_0Z, XM_PERMUTE_0W};
XMGLOBALCONST XMVECTORI32 g_XMSwizzleYZXW = {XM_PERMUTE_0Y, XM_PERMUTE_0Z, XM_PERMUTE_0X, XM_PERMUTE_0W};
XMGLOBALCONST XMVECTORI32 g_XMSwizzleZXYW = {XM_PERMUTE_0Z, XM_PERMUTE_0X, XM_PERMUTE_0Y, XM_PERMUTE_0W};
XMGLOBALCONST XMVECTORI32 g_XMPermute0X0Y1X1Y = {XM_PERMUTE_0X, XM_PERMUTE_0Y, XM_PERMUTE_1X, XM_PERMUTE_1Y};
XMGLOBALCONST XMVECTORI32 g_XMPermute0Z0W1Z1W = {XM_PERMUTE_0Z, XM_PERMUTE_0W, XM_PERMUTE_1Z, XM_PERMUTE_1W};
XMGLOBALCONST XMVECTORF32 g_XMFixupY16 = {1.0f,1.0f/65536.0f,0.0f,0.0f};
XMGLOBALCONST XMVECTORF32 g_XMFixupY16W16 = {1.0f,1.0f,1.0f/65536.0f,1.0f/65536.0f};
XMGLOBALCONST XMVECTORI32 g_XMFlipY = {0,0x80000000,0,0};
XMGLOBALCONST XMVECTORI32 g_XMFlipZ = {0,0,0x80000000,0};
XMGLOBALCONST XMVECTORI32 g_XMFlipW = {0,0,0,0x80000000};
XMGLOBALCONST XMVECTORI32 g_XMFlipYZ = {0,0x80000000,0x80000000,0};
XMGLOBALCONST XMVECTORI32 g_XMFlipZW = {0,0,0x80000000,0x80000000};
XMGLOBALCONST XMVECTORI32 g_XMFlipYW = {0,0x80000000,0,0x80000000};
XMGLOBALCONST XMVECTORI32 g_XMMaskHenD3 = {0x7FF,0x7ff<<11,0x3FF<<22,0};
XMGLOBALCONST XMVECTORI32 g_XMMaskDHen3 = {0x3FF,0x7ff<<10,0x7FF<<21,0};
XMGLOBALCONST XMVECTORF32 g_XMAddUHenD3 = {0,0,32768.0f*65536.0f,0};
XMGLOBALCONST XMVECTORF32 g_XMAddHenD3 = {-1024.0f,-1024.0f*2048.0f,0,0};
XMGLOBALCONST XMVECTORF32 g_XMAddDHen3 = {-512.0f,-1024.0f*1024.0f,0,0};
XMGLOBALCONST XMVECTORF32 g_XMMulHenD3 = {1.0f,1.0f/2048.0f,1.0f/(2048.0f*2048.0f),0};
XMGLOBALCONST XMVECTORF32 g_XMMulDHen3 = {1.0f,1.0f/1024.0f,1.0f/(1024.0f*2048.0f),0};
XMGLOBALCONST XMVECTORI32 g_XMXorHenD3 = {0x400,0x400<<11,0,0};
XMGLOBALCONST XMVECTORI32 g_XMXorDHen3 = {0x200,0x400<<10,0,0};
XMGLOBALCONST XMVECTORI32 g_XMMaskIco4 = {0xFFFFF,0xFFFFF000,0xFFFFF,0xF0000000};
XMGLOBALCONST XMVECTORI32 g_XMXorXIco4 = {0x80000,0,0x80000,0x80000000};
XMGLOBALCONST XMVECTORI32 g_XMXorIco4 = {0x80000,0,0x80000,0};
XMGLOBALCONST XMVECTORF32 g_XMAddXIco4 = {-8.0f*65536.0f,0,-8.0f*65536.0f,32768.0f*65536.0f};
XMGLOBALCONST XMVECTORF32 g_XMAddUIco4 = {0,32768.0f*65536.0f,0,32768.0f*65536.0f};
XMGLOBALCONST XMVECTORF32 g_XMAddIco4 = {-8.0f*65536.0f,0,-8.0f*65536.0f,0};
XMGLOBALCONST XMVECTORF32 g_XMMulIco4 = {1.0f,1.0f/4096.0f,1.0f,1.0f/(4096.0f*65536.0f)};
XMGLOBALCONST XMVECTORI32 g_XMMaskDec4 = {0x3FF,0x3FF<<10,0x3FF<<20,0x3<<30};
XMGLOBALCONST XMVECTORI32 g_XMXorDec4 = {0x200,0x200<<10,0x200<<20,0};
XMGLOBALCONST XMVECTORF32 g_XMAddUDec4 = {0,0,0,32768.0f*65536.0f};
XMGLOBALCONST XMVECTORF32 g_XMAddDec4 = {-512.0f,-512.0f*1024.0f,-512.0f*1024.0f*1024.0f,0};
XMGLOBALCONST XMVECTORF32 g_XMMulDec4 = {1.0f,1.0f/1024.0f,1.0f/(1024.0f*1024.0f),1.0f/(1024.0f*1024.0f*1024.0f)};
XMGLOBALCONST XMVECTORI32 g_XMMaskByte4 = {0xFF,0xFF00,0xFF0000,0xFF000000};
XMGLOBALCONST XMVECTORI32 g_XMXorByte4 = {0x80,0x8000,0x800000,0x00000000};
XMGLOBALCONST XMVECTORF32 g_XMAddByte4 = {-128.0f,-128.0f*256.0f,-128.0f*65536.0f,0};

/****************************************************************************
 *
 * Implementation
 *
 ****************************************************************************/

#pragma warning(push)
#pragma warning(disable:4214 4204 4365 4616 6001)

#if !defined(__cplusplus) && !defined(_XBOX) && defined(_XM_ISVS2005_)

/* Work around VC 2005 bug where math.h defines logf with a semicolon at the end.
 * Note this is fixed as of Visual Studio 2005 Service Pack 1
 */

#undef logf
#define logf(x) ((float)log((double)(x)))

#endif // !defined(__cplusplus) && !defined(_XBOX) && defined(_XM_ISVS2005_)

//------------------------------------------------------------------------------

#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_)

XMFINLINE XMVECTOR XMVectorSetBinaryConstant(UINT C0, UINT C1, UINT C2, UINT C3)
{
#if defined(_XM_NO_INTRINSICS_)
 XMVECTORU32 vResult;
 vResult.u[0] = (0-(C0&1)) & 0x3F800000;
 vResult.u[1] = (0-(C1&1)) & 0x3F800000;
 vResult.u[2] = (0-(C2&1)) & 0x3F800000;
 vResult.u[3] = (0-(C3&1)) & 0x3F800000;
 return vResult.v;
#else // XM_SSE_INTRINSICS_
 static const XMVECTORU32 g_vMask1 = {1,1,1,1};
 // Move the parms to a vector
 __m128i vTemp = _mm_set_epi32(C3,C2,C1,C0);
 // Mask off the low bits
 vTemp = _mm_and_si128(vTemp,g_vMask1);
 // 0xFFFFFFFF on true bits
 vTemp = _mm_cmpeq_epi32(vTemp,g_vMask1);
 // 0xFFFFFFFF -> 1.0f, 0x00000000 -> 0.0f
 vTemp = _mm_and_si128(vTemp,g_XMOne);
 return reinterpret_cast<const __m128 *>(&vTemp)[0];
#endif
}

//------------------------------------------------------------------------------

XMFINLINE XMVECTOR XMVectorSplatConstant(INT IntConstant, UINT DivExponent)
{
#if defined(_XM_NO_INTRINSICS_)
 XMASSERT( IntConstant >= -16 && IntConstant <= 15 );
 XMASSERT(DivExponent<32);
 {
 XMVECTORI32 V = { IntConstant, IntConstant, IntConstant, IntConstant };
 return XMConvertVectorIntToFloat( V.v, DivExponent);
 }
#else // XM_SSE_INTRINSICS_
 XMASSERT( IntConstant >= -16 && IntConstant <= 15 );
 XMASSERT(DivExponent<32);
 // Splat the int
 __m128i vScale = _mm_set1_epi32(IntConstant);
 // Convert to a float
 XMVECTOR vResult = _mm_cvtepi32_ps(vScale);
 // Convert DivExponent into 1.0f/(1<<DivExponent)
 UINT uScale = 0x3F800000U - (DivExponent << 23);
 // Splat the scalar value (It's really a float)
 vScale = _mm_set1_epi32(uScale);
 // Multiply by the reciprocal (Perform a right shift by DivExponent)
 vResult = _mm_mul_ps(vResult,reinterpret_cast<const __m128 *>(&vScale)[0]);
 return vResult;
#endif
}

//------------------------------------------------------------------------------

XMFINLINE XMVECTOR XMVectorSplatConstantInt(INT IntConstant)
{
#if defined(_XM_NO_INTRINSICS_)
 XMASSERT( IntConstant >= -16 && IntConstant <= 15 );
 {
 XMVECTORI32 V = { IntConstant, IntConstant, IntConstant, IntConstant };
 return V.v;
 }
#else // XM_SSE_INTRINSICS_
 XMASSERT( IntConstant >= -16 && IntConstant <= 15 );
 __m128i V = _mm_set1_epi32( IntConstant );
 return reinterpret_cast<__m128 *>(&V)[0];
#endif
}

//------------------------------------------------------------------------------

XMFINLINE XMVECTOR XMVectorShiftLeft(FXMVECTOR V1, FXMVECTOR V2, UINT Elements)
{
 return XMVectorPermute(V1, V2, XMVectorPermuteControl((Elements), ((Elements) + 1), ((Elements) + 2), ((Elements) + 3)));
}

//------------------------------------------------------------------------------

XMFINLINE XMVECTOR XMVectorRotateLeft(FXMVECTOR V, UINT Elements)
{
#if defined(_XM_NO_INTRINSICS_)
 XMASSERT( Elements < 4 );
 {
 XMVECTORF32 vResult = { V.vector4_f32[Elements & 3], V.vector4_f32[(Elements + 1) & 3],
 V.vector4_f32[(Elements + 2) & 3], V.vector4_f32[(Elements + 3) & 3] };
 return vResult.v;
 }
#else // XM_SSE_INTRINSICS_
 FLOAT fx = XMVectorGetByIndex(V,(Elements) & 3);
 FLOAT fy = XMVectorGetByIndex(V,((Elements) + 1) & 3);
 FLOAT fz = XMVectorGetByIndex(V,((Elements) + 2) & 3);
 FLOAT fw = XMVectorGetByIndex(V,((Elements) + 3) & 3);
 return _mm_set_ps( fw, fz, fy, fx );
#endif
}

//------------------------------------------------------------------------------

XMFINLINE XMVECTOR XMVectorRotateRight(FXMVECTOR V, UINT Elements)
{
#if defined(_XM_NO_INTRINSICS_)
 XMASSERT( Elements < 4 );
 {
 XMVECTORF32 vResult = { V.vector4_f32[(4 - (Elements)) & 3], V.vector4_f32[(5 - (Elements)) & 3],
 V.vector4_f32[(6 - (Elements)) & 3], V.vector4_f32[(7 - (Elements)) & 3] };
 return vResult.v;
 }
#else // XM_SSE_INTRINSICS_
 FLOAT fx = XMVectorGetByIndex(V,(4 - (Elements)) & 3);
 FLOAT fy = XMVectorGetByIndex(V,(5 - (Elements)) & 3);
 FLOAT fz = XMVectorGetByIndex(V,(6 - (Elements)) & 3);
 FLOAT fw = XMVectorGetByIndex(V,(7 - (Elements)) & 3);
 return _mm_set_ps( fw, fz, fy, fx );
#endif
}

//------------------------------------------------------------------------------

XMFINLINE XMVECTOR XMVectorSwizzle(FXMVECTOR V, UINT E0, UINT E1, UINT E2, UINT E3)
{
#if defined(_XM_NO_INTRINSICS_)
 XMASSERT( (E0 < 4) && (E1 < 4) && (E2 < 4) && (E3 < 4) );
 {
 XMVECTORF32 vResult = { V.vector4_f32[E0], V.vector4_f32[E1], V.vector4_f32[E2], V.vector4_f32[E3] };
 return vResult.v;
 }
#else // XM_SSE_INTRINSICS_
 FLOAT fx = XMVectorGetByIndex(V,E0);
 FLOAT fy = XMVectorGetByIndex(V,E1);
 FLOAT fz = XMVectorGetByIndex(V,E2);
 FLOAT fw = XMVectorGetByIndex(V,E3);
 return _mm_set_ps( fw, fz, fy, fx );
#endif
}

//------------------------------------------------------------------------------

XMFINLINE XMVECTOR XMVectorInsert(FXMVECTOR VD, FXMVECTOR VS, UINT VSLeftRotateElements,
 UINT Select0, UINT Select1, UINT Select2, UINT Select3)
{
 XMVECTOR Control = XMVectorSelectControl(Select0&1, Select1&1, Select2&1, Select3&1);
 return XMVectorSelect( VD, XMVectorRotateLeft(VS, VSLeftRotateElements), Control );
}

// Implemented for VMX128 intrinsics as #defines aboves
#endif _XM_NO_INTRINSICS_ || _XM_SSE_INTRINSICS_

//------------------------------------------------------------------------------

#include "xnamathconvert.inl"
#include "xnamathvector.inl"
#include "xnamathmatrix.inl"
#include "xnamathmisc.inl"

#pragma warning(pop)

#endif // __XNAMATH_H__