Vector in DirectXMath

In order to take advantage of the performance gains that SIMD brings, there are some compile, operating system, and hardware related issues to be aware of when using the DirectXMath library.

In DirectXMath, the core vector type is XMVECTOR, which corresponds to a SIMD register. It is a 128-bit type and can handle four 32-bit float data at the same time. It is defined as follows:

typedef __m128 XMVECTOR
Copy the code

__m128 is a SIMD type, and we must use this type for vector calculation to take advantage of SIMD.

Note that XMVECTOR types require 16-byte alignment in memory (Google it if you’re not sure what memory alignment is and why). For global and local variables, the compiler automatically implements memory alignment, but for the class’s data members, using XMFLOAT2, XMFLOAT3, or XMFLOAT4 can cause problems with memory alignment. The XMFLOAT3 type is defined as follows (XMFLOAT2 and XMFLOAT4 are similar, except that the class has a different number of floating-point members) :

struct XMFLOAT3 { float x; float y; float z; XMFLOAT3() {} XMFLOAT3(float _x, float _y, float _z) : x(_x), y(_y), z(_z) {} explicit XMFLOAT3(_In_reads_(3) const float *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]) {} XMFLOAT3& operator= (const XMFLOAT3& Float3) { x = Float3.x; y = Float3.y; z = Float3.z; return *this; }};Copy the code

However, using THE XMFLOATn type directly cannot take advantage of SIMD, so we need to convert it to XMVECTOR and perform the operation, and then revert the result back to XMFLOATn. DirectXMath provides Loading and Storage methods for these conversions:

// Loading methods: load data from XMFLOATn into XMVECTOR
XMVECTOR XM_CALLCONV XMLoadFloat2(const XMFLOAT2 *pSource);
XMVECTOR XM_CALLCONV XMLoadFloat3(const XMFLOAT3 *pSource);
XMVECTOR XM_CALLCONV XMLoadFloat4(const XMFLOAT4 *pSource);

// Stroing methods: store XMVECTOR into XMFLOATn
void XM_CALLCONV XMStoreFloat2(XMFLOAT2 *pDestination, FXMVECTOR V);
void XM_CALLCONV XMStoreFloat3(XMFLOAT3 *pDestination, FXMVECTOR V);
void XM_CALLCONV XMStoreFloat4(XMFLOAT4 *pDestination, FXMVECTOR V);
Copy the code

Sometimes we want to manipulate only one component of an XMVECTOR, and we can use the following getter and setter functions:

// Getter functions
float XM_CALLCONV XMVectorGetX(FXMVECTOR V);
float XM_CALLCONV XMVectorGetY(FXMVECTOR V);
float XM_CALLCONV XMVectorGetZ(FXMVECTOR V);
float XM_CALLCONV XMVectorGetW(FXMVECTOR V);

// Setter functions
XMVECTOR XM_CALLCONV XMVectorSetX(FXMVECTOR V, float x);
XMVECTOR XM_CALLCONV XMVectorSetY(FXMVECTOR V, float y);
XMVECTOR XM_CALLCONV XMVectorSetZ(FXMVECTOR V, float z);
XMVECTOR XM_CALLCONV XMVectorSetW(FXMVECTOR V, float w);
Copy the code

In order to improve efficiency, when the XMVECTOR value is passed to the function as a parameter in the function call, it can be passed directly to the SSE/SSE2 register, rather than stored in the stack memory (if the knowledge of register, stack memory, function call compilation is not clear). The classic Computer Systems: A Programmer’s Perspective (3rd Edition) is recommended for understanding Computer Systems.

However, the number of SSE/SSE2 registers, and the maximum number of parameters that can be passed directly into these registers in a function call, are platform – and compiler-dependent and have different values for different platforms and compilers. To improve portability, we can use the type alias provided by DirectXMath. The XMVECTOR argument is passed as follows:

1. The first threeXMVECTORParameters usingFXMVECTORType;
2. The fourthXMVECTORParameters usingGXMVECTORType;
3. Fifth and sixthXMVECTORParameters usingHXMVECTORType;
4. The rest extraXMVECTORParameters usingCXMVECTORType.

Note that the above count is for input parameters of type XMVECTOR. Output parameters of type XMVECTOR (references, Pointers) and other parameters are not included in the count and can be ignored from the prototype. Here is an example of a function prototype:

inline XMMATRIX XM_CALLCONV XMMatrixTransformation2D(
    FXMVECTOR ScalingOrigin,
    float ScalingOrientation,
    FXMVECTOR Scaling,
    FXMVECTOR RotationOrigin,
    float Rotation,
    GXMVECTOR Translation
);
Copy the code

For constant instances of XMVECTOR, we should use the XMVECTORF32 type. In fact, we should all use the XMVECTORF32 type when we want to use C++ initialization syntax. Here are some examples:

Static const XMVECTORF32 g_vHalfVector = {0.5f, 0.5f, 0.5f, 0.5f}; XMVECTORF32 vRightTop = {vViewFrust.RightSlope, vViewFrust.TopSlope, 1.0f, 1.0f};Copy the code

XMVECOTRF32 is also a 16-byte aligned structure that can also be converted to XMVECTOR as follows:

__declspec(align(16)) struct XMVECTORF32 { union { float f[4]; XMVECTOR v; }; inline operator XMVECTOR() const { return v; } inline operator const float*() const { return f; } #if ! defined(_XM_NO_INTRINSICS_) && defined(_XM_SSE_INTRINSICS_) inline operator __m128i() const { return _mm_castps_si128(v); } inline operator __m128d() const { return _mm_castps_pd(v); } #endif };Copy the code

DirectXMath defines some common constants and inline functions.

Some π” role=”presentation” style=”position: relative;” >Relevant constants:

Const float XM_PI = 3.141592654f; Const float XM_2PI = 6.283185307f; Const float XM_1DIVPI = 0.318309886f; Const float XM_1DIV2PI = 0.159154943f; Const float XM_PIDIV2 = 1.570796327f; Const float XM_PIDIV4 = 0.785398163f;Copy the code

The inline function of radian/Angle conversion, taking the maximum/minimum value:

Inline Float XMConvertToRadians(float fDegrees) {return fDegrees * (XM_PI / 180.0f); } Inline float XMConvertToDegrees(float fRadians) {return fRadians * (180.0f/XM_PI); } template<class T> inline T XMMin(T a, T b) { return (a < b) ? a : b; } template<class T> inline T XMMax(T a, T b) { return (a > b) ? a : b; }Copy the code

The following functions can be used to set the contents of an XMVECTOR value:

// Returns the zero vector 0
XMVECTOR XM_CALLCONV XMVectorZero();
// Returns the vector (1, 1, 1, 1)
XMVECTOR XM_CALLCONV XMVectorSplatOne();
// Returns the vector (x, y, z, w)
XMVECTOR XM_CALLCONV XMVectorSet(float x, float y, float z, float w);
// Returns the vector (s, s, s, s)
XMVECTOR XM_CALLCONV XMVectorReplicate(float Value);
// Returns the vector (vx, vx, vx, vx)
XMVECTOR XM_CALLCONV XMVectorSplatX(FXMVECTOR V);
// Returns the vector (vy, vy, vy, vy)
XMVECTOR XM_CALLCONV XMVectorSplatY(FXMVECTOR V);
// Returns the vector (vz, vz, vz, vz)
XMVECTOR XM_CALLCONV XMVectorSplatZ(FXMVECTOR V);
Copy the code

At the beginning of this paper, SIMD and SSE2 are briefly introduced. I then cover some topics related to typing and compiler optimization in DirectXMath, This includes the configuration of the Visual Studio compiler, the core vector type XMVECTOR and its memory alignment issues (introducing XMFLOAT2, XMFLOAT3, XMFLOAT4 types and related Loading and Store Method), function argument passing and calling conventions (XM_CALLCONV modifier and type aliases such as FXMVECTOR), and vector constants (type XMVECTORF32); Finally, it introduces some common overloaded operators, constant values, inline functions, Setter functions, and vector functions in DirectXMath.