/*++
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 201
#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_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
#if defined(_MSC_VER) && (_MSC_VER<1600) && (_MSC_VER>=1500)
#define _XM_ISVS2008_
#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)
#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_INTRINISCS_)
typedef const XMVECTOR FXMVECTOR;
#elif defined(_XM_X86_) && !defined(_XM_NO_INTRINISCS_)
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_INTRINISCS_)
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&);
#ifndef XM_NO_OPERATOR_OVERLOADS
_XMMATRIX& operator*= (CONST _XMMATRIX&);
_XMMATRIX operator* (CONST _XMMATRIX&) 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
typedef __declspec(align(16)) XMFLOAT2 XMFLOAT2A;
// 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
typedef __declspec(align(16)) XMFLOAT3 XMFLOAT3A;
// 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
typedef __declspec(align(16)) XMFLOAT4 XMFLOAT4A;
// 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 _x, FLOAT _y, FLOAT _z, FLOAT _w);
_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
typedef __declspec(align(16)) XMFLOAT4X3 XMFLOAT4X3A;
// 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
typedef __declspec(align(16)) XMFLOAT4X4 XMFLOAT4X4A;
#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_bcount(sizeof(FLOAT)+OutputStride*(HalfCount-1)) FLOAT* pOutputStream,
__in UINT OutputStride,
__in_bcount(sizeof(HALF)+InputStride*(HalfCount-1)) CONST HALF* pInputStream,
__in UINT InputStride, __in UINT HalfCount);
HALF XMConvertFloatToHalf(FLOAT Value);
HALF* XMConvertFloatToHalfStream(__out_bcount(sizeof(HALF)+OutputStride*(FloatCount-1)) HALF* pOutputStream,
__in UINT OutputStride,
__in_bcount(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_ecount(2) CONST UINT* pSource);
XMVECTOR XMLoadInt2A(__in_ecount(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_ecount(3) CONST UINT* pSource);
XMVECTOR XMLoadInt3A(__in_ecount(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_ecount(4) CONST UINT* pSource);
XMVECTOR XMLoadInt4A(__in_ecount(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_ecount(2) UINT* pDestination, FXMVECTOR V);
VOID XMStoreInt2A(__out_ecount(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_ecount(3) UINT* pDestination, FXMVECTOR V);
VOID XMStoreInt3A(__out_ecount(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_ecount(4) UINT* pDestination, FXMVECTOR V);
VOID XMStoreInt4A(__out_ecount(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 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_bcount(sizeof(XMFLOAT4)+OutputStride*(VectorCount-1)) XMFLOAT4* pOutputStream,
__in UINT OutputStride,
__in_bcount(sizeof(XMFLOAT2)+InputStride*(VectorCount-1)) CONST XMFLOAT2* pInputStream,
__in UINT InputStride, __in UINT VectorCount, CXMMATRIX M);
XMFLOAT4* XMVector2TransformStreamNC(__out_bcount(sizeof(XMFLOAT4)+OutputStride*(VectorCount-1)) XMFLOAT4* pOutputStream,
__in UINT OutputStride,
__in_bcount(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_bcount(sizeof(XMFLOAT2)+OutputStride*(VectorCount-1)) XMFLOAT2* pOutputStream,
__in UINT OutputStride,
__in_bcount(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_bcount(sizeof(XMFLOAT2)+OutputStride*(VectorCount-1)) XMFLOAT2* pOutputStream,
__in UINT OutputStride,
__in_bcount(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_bcount(sizeof(XMFLOAT4)+OutputStride*(VectorCount-1)) XMFLOAT4* pOutputStream,
__in UINT OutputStride,
__in_bcount(sizeof(XMFLOAT3)+InputStride*(VectorCount-1)) CONST XMFLOAT3* pInputStream,
__in UINT InputStride, __in UINT VectorCount, CXMMATRIX M);
XMFLOAT4* XMVector3TransformStreamNC(__out_bcount(sizeof(XMFLOAT4)+OutputStride*(VectorCount-1)) XMFLOAT4* pOutputStream,
__in UINT OutputStride,
__in_bcount(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_bcount(sizeof(XMFLOAT3)+OutputStride*(VectorCount-1)) XMFLOAT3* pOutputStream,
__in UINT OutputStride,
__in_bcount(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_bcount(sizeof(XMFLOAT3)+OutputStride*(VectorCount-1)) XMFLOAT3* pOutputStream,
__in UINT OutputStride,
__in_bcount(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_bcount(sizeof(XMFLOAT3)+OutputStride*(VectorCount-1)) XMFLOAT3* pOutputStream,
__in UINT OutputStride,
__in_bcount(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_bcount(sizeof(XMFLOAT3)+OutputStride*(VectorCount-1)) XMFLOAT3* pOutputStream,
__in UINT OutputStride,
__in_bcount(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_bcount(sizeof(XMFLOAT4)+OutputStride*(VectorCount-1)) XMFLOAT4* pOutputStream,
__in UINT OutputStride,
__in_bcount(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_bcount(sizeof(XMFLOAT4)+OutputStride*(PlaneCount-1)) XMFLOAT4* pOutputStream,
__in UINT OutputStride,
__in_bcount(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};
#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_)
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};
#ifdef _XM_NO_INTRINSICS_
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};
#endif // !_XM_NO_INTRINSICS_
#ifdef _XM_SSE_INTRINSICS_
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};
#endif
#endif // _XM_NO_INTRINSICS_
/****************************************************************************
*
* Implementation
*
****************************************************************************/
#pragma warning(push)
#pragma warning(disable:4214 4204 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__