diff --git a/Inc/DirectXMath.h b/Inc/DirectXMath.h
index aa1d584..f629828 100644
--- a/Inc/DirectXMath.h
+++ b/Inc/DirectXMath.h
@@ -20,14 +20,12 @@
 #define DIRECTX_MATH_VERSION 311
 
 #if defined(_MSC_VER) && (_MSC_VER < 1800)
-#error DirectX Math Visual C++ 2013 or later.
+#error DirectX Math requires Visual C++ 2013 or later.
 #endif
 
 #if defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64) && !defined(_M_HYBRID_X86_ARM64) && (!_MANAGED) && (!_M_CEE) && (!defined(_M_IX86_FP) || (_M_IX86_FP > 1)) && !defined(_XM_NO_INTRINSICS_) && !defined(_XM_VECTORCALL_)
-#if ((_MSC_FULL_VER >= 170065501) && (_MSC_VER < 1800)) || (_MSC_FULL_VER >= 180020418)
 #define _XM_VECTORCALL_ 1
 #endif
-#endif
 
 #if _XM_VECTORCALL_
 #define XM_CALLCONV __vectorcall
@@ -35,12 +33,6 @@
 #define XM_CALLCONV __fastcall
 #endif
 
-#if defined(_MSC_VER) && (_MSC_VER < 1800)
-#define XM_CTOR_DEFAULT {}
-#else
-#define XM_CTOR_DEFAULT =default;
-#endif
-
 #if defined(_MSC_VER) && (_MSC_FULL_VER < 190023506)
 #define XM_CONST const
 #define XM_CONSTEXPR
@@ -464,7 +456,7 @@ __declspec(align(16)) struct XMMATRIX
     XMVECTOR r[4];
 #endif
 
-    XMMATRIX() XM_CTOR_DEFAULT
+    XMMATRIX() =default;
 #if defined(_MSC_VER) && _MSC_VER >= 1900
     constexpr XMMATRIX(FXMVECTOR R0, FXMVECTOR R1, FXMVECTOR R2, CXMVECTOR R3) : r{ R0,R1,R2,R3 } {}
 #else
@@ -508,7 +500,7 @@ struct XMFLOAT2
     float x;
     float y;
 
-    XMFLOAT2() XM_CTOR_DEFAULT
+    XMFLOAT2() =default;
     XM_CONSTEXPR XMFLOAT2(float _x, float _y) : x(_x), y(_y) {}
     explicit XMFLOAT2(_In_reads_(2) const float *pArray) : x(pArray[0]), y(pArray[1]) {}
 
@@ -518,7 +510,7 @@ struct XMFLOAT2
 // 2D Vector; 32 bit floating point components aligned on a 16 byte boundary
 __declspec(align(16)) struct XMFLOAT2A : public XMFLOAT2
 {
-    XMFLOAT2A() XM_CTOR_DEFAULT
+    XMFLOAT2A() =default;
     XM_CONSTEXPR XMFLOAT2A(float _x, float _y) : XMFLOAT2(_x, _y) {}
     explicit XMFLOAT2A(_In_reads_(2) const float *pArray) : XMFLOAT2(pArray) {}
 
@@ -532,7 +524,7 @@ struct XMINT2
     int32_t x;
     int32_t y;
 
-    XMINT2() XM_CTOR_DEFAULT
+    XMINT2() =default;
     XM_CONSTEXPR XMINT2(int32_t _x, int32_t _y) : x(_x), y(_y) {}
     explicit XMINT2(_In_reads_(2) const int32_t *pArray) : x(pArray[0]), y(pArray[1]) {}
 
@@ -545,7 +537,7 @@ struct XMUINT2
     uint32_t x;
     uint32_t y;
 
-    XMUINT2() XM_CTOR_DEFAULT
+    XMUINT2() =default;
     XM_CONSTEXPR XMUINT2(uint32_t _x, uint32_t _y) : x(_x), y(_y) {}
     explicit XMUINT2(_In_reads_(2) const uint32_t *pArray) : x(pArray[0]), y(pArray[1]) {}
 
@@ -560,7 +552,7 @@ struct XMFLOAT3
     float y;
     float z;
 
-    XMFLOAT3() XM_CTOR_DEFAULT
+    XMFLOAT3() =default;
     XM_CONSTEXPR 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]) {}
 
@@ -570,7 +562,7 @@ struct XMFLOAT3
 // 3D Vector; 32 bit floating point components aligned on a 16 byte boundary
 __declspec(align(16)) struct XMFLOAT3A : public XMFLOAT3
 {
-    XMFLOAT3A() XM_CTOR_DEFAULT
+    XMFLOAT3A() =default;
     XM_CONSTEXPR XMFLOAT3A(float _x, float _y, float _z) : XMFLOAT3(_x, _y, _z) {}
     explicit XMFLOAT3A(_In_reads_(3) const float *pArray) : XMFLOAT3(pArray) {}
 
@@ -585,7 +577,7 @@ struct XMINT3
     int32_t y;
     int32_t z;
 
-    XMINT3() XM_CTOR_DEFAULT
+    XMINT3() =default;
     XM_CONSTEXPR XMINT3(int32_t _x, int32_t _y, int32_t _z) : x(_x), y(_y), z(_z) {}
     explicit XMINT3(_In_reads_(3) const int32_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]) {}
 
@@ -599,7 +591,7 @@ struct XMUINT3
     uint32_t y;
     uint32_t z;
 
-    XMUINT3() XM_CTOR_DEFAULT
+    XMUINT3() =default;
     XM_CONSTEXPR XMUINT3(uint32_t _x, uint32_t _y, uint32_t _z) : x(_x), y(_y), z(_z) {}
     explicit XMUINT3(_In_reads_(3) const uint32_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]) {}
 
@@ -615,7 +607,7 @@ struct XMFLOAT4
     float z;
     float w;
 
-    XMFLOAT4() XM_CTOR_DEFAULT
+    XMFLOAT4() =default;
     XM_CONSTEXPR XMFLOAT4(float _x, float _y, float _z, float _w) : x(_x), y(_y), z(_z), w(_w) {}
     explicit XMFLOAT4(_In_reads_(4) const float *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
 
@@ -625,7 +617,7 @@ struct XMFLOAT4
 // 4D Vector; 32 bit floating point components aligned on a 16 byte boundary
 __declspec(align(16)) struct XMFLOAT4A : public XMFLOAT4
 {
-    XMFLOAT4A() XM_CTOR_DEFAULT
+    XMFLOAT4A() =default;
     XM_CONSTEXPR XMFLOAT4A(float _x, float _y, float _z, float _w) : XMFLOAT4(_x, _y, _z, _w) {}
     explicit XMFLOAT4A(_In_reads_(4) const float *pArray) : XMFLOAT4(pArray) {}
 
@@ -641,7 +633,7 @@ struct XMINT4
     int32_t z;
     int32_t w;
 
-    XMINT4() XM_CTOR_DEFAULT
+    XMINT4() =default;
     XM_CONSTEXPR XMINT4(int32_t _x, int32_t _y, int32_t _z, int32_t _w) : x(_x), y(_y), z(_z), w(_w) {}
     explicit XMINT4(_In_reads_(4) const int32_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
 
@@ -656,7 +648,7 @@ struct XMUINT4
     uint32_t z;
     uint32_t w;
 
-    XMUINT4() XM_CTOR_DEFAULT
+    XMUINT4() =default;
     XM_CONSTEXPR XMUINT4(uint32_t _x, uint32_t _y, uint32_t _z, uint32_t _w) : x(_x), y(_y), z(_z), w(_w) {}
     explicit XMUINT4(_In_reads_(4) const uint32_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
 
@@ -678,7 +670,7 @@ struct XMFLOAT3X3
         float m[3][3];
     };
 
-    XMFLOAT3X3() XM_CTOR_DEFAULT
+    XMFLOAT3X3() =default;
     XM_CONSTEXPR XMFLOAT3X3(float m00, float m01, float m02,
                             float m10, float m11, float m12,
                             float m20, float m21, float m22)
@@ -709,7 +701,7 @@ struct XMFLOAT4X3
         float m[4][3];
     };
 
-    XMFLOAT4X3() XM_CTOR_DEFAULT
+    XMFLOAT4X3() =default;
     XM_CONSTEXPR XMFLOAT4X3(float m00, float m01, float m02,
                             float m10, float m11, float m12,
                             float m20, float m21, float m22,
@@ -730,7 +722,7 @@ struct XMFLOAT4X3
 // 4x3 Matrix: 32 bit floating point components aligned on a 16 byte boundary
 __declspec(align(16)) struct XMFLOAT4X3A : public XMFLOAT4X3
 {
-    XMFLOAT4X3A() XM_CTOR_DEFAULT
+    XMFLOAT4X3A() =default;
     XM_CONSTEXPR XMFLOAT4X3A(float m00, float m01, float m02,
                             float m10, float m11, float m12,
                             float m20, float m21, float m22,
@@ -760,7 +752,7 @@ struct XMFLOAT4X4
         float m[4][4];
     };
 
-    XMFLOAT4X4() XM_CTOR_DEFAULT
+    XMFLOAT4X4() =default;
     XM_CONSTEXPR 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,
@@ -780,7 +772,7 @@ struct XMFLOAT4X4
 // 4x4 Matrix: 32 bit floating point components aligned on a 16 byte boundary
 __declspec(align(16)) struct XMFLOAT4X4A : public XMFLOAT4X4
 {
-    XMFLOAT4X4A() XM_CTOR_DEFAULT
+    XMFLOAT4X4A() =default;
     XM_CONSTEXPR XMFLOAT4X4A(float m00, float m01, float m02, float m03,
                              float m10, float m11, float m12, float m13,
                              float m20, float m21, float m22, float m23,
diff --git a/Inc/DirectXMathMatrix.inl b/Inc/DirectXMathMatrix.inl
index 95e2c48..b474bf4 100644
--- a/Inc/DirectXMathMatrix.inl
+++ b/Inc/DirectXMathMatrix.inl
@@ -298,7 +298,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixMultiply
 #elif defined(_XM_SSE_INTRINSICS_)
     XMMATRIX mResult;
     // Splat the component X,Y,Z then W
-#if defined(_XM_AVX_INTRINSICS_) && (!defined(_MSC_VER) || (_MSC_VER >= 1800))
+#if defined(_XM_AVX_INTRINSICS_)
     XMVECTOR vX = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[0]) + 0);
     XMVECTOR vY = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[0]) + 1);
     XMVECTOR vZ = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[0]) + 2);
@@ -322,7 +322,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixMultiply
     vX = _mm_add_ps(vX,vY);
     mResult.r[0] = vX;
     // Repeat for the other 3 rows
-#if defined(_XM_AVX_INTRINSICS_) && (!defined(_MSC_VER) || (_MSC_VER >= 1800))
+#if defined(_XM_AVX_INTRINSICS_)
     vX = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[1]) + 0);
     vY = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[1]) + 1);
     vZ = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[1]) + 2);
@@ -342,7 +342,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixMultiply
     vY = _mm_add_ps(vY,vW);
     vX = _mm_add_ps(vX,vY);
     mResult.r[1] = vX;
-#if defined(_XM_AVX_INTRINSICS_) && (!defined(_MSC_VER) || (_MSC_VER >= 1800))
+#if defined(_XM_AVX_INTRINSICS_)
     vX = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[2]) + 0);
     vY = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[2]) + 1);
     vZ = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[2]) + 2);
@@ -362,7 +362,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixMultiply
     vY = _mm_add_ps(vY,vW);
     vX = _mm_add_ps(vX,vY);
     mResult.r[2] = vX;
-#if defined(_XM_AVX_INTRINSICS_) && (!defined(_MSC_VER) || (_MSC_VER >= 1800))
+#if defined(_XM_AVX_INTRINSICS_)
     vX = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[3]) + 0);
     vY = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[3]) + 1);
     vZ = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[3]) + 2);
@@ -479,7 +479,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixMultiplyTranspose
     return mResult;
 #elif defined(_XM_SSE_INTRINSICS_)
     // Splat the component X,Y,Z then W
-#if defined(_XM_AVX_INTRINSICS_) && (!defined(_MSC_VER) || (_MSC_VER >= 1800))
+#if defined(_XM_AVX_INTRINSICS_)
     XMVECTOR vX = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[0]) + 0);
     XMVECTOR vY = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[0]) + 1);
     XMVECTOR vZ = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[0]) + 2);
@@ -503,7 +503,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixMultiplyTranspose
     vX = _mm_add_ps(vX,vY);
     XMVECTOR r0 = vX;
     // Repeat for the other 3 rows
-#if defined(_XM_AVX_INTRINSICS_) && (!defined(_MSC_VER) || (_MSC_VER >= 1800))
+#if defined(_XM_AVX_INTRINSICS_)
     vX = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[1]) + 0);
     vY = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[1]) + 1);
     vZ = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[1]) + 2);
@@ -523,7 +523,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixMultiplyTranspose
     vY = _mm_add_ps(vY,vW);
     vX = _mm_add_ps(vX,vY);
     XMVECTOR r1 = vX;
-#if defined(_XM_AVX_INTRINSICS_) && (!defined(_MSC_VER) || (_MSC_VER >= 1800))
+#if defined(_XM_AVX_INTRINSICS_)
     vX = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[2]) + 0);
     vY = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[2]) + 1);
     vZ = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[2]) + 2);
@@ -543,7 +543,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixMultiplyTranspose
     vY = _mm_add_ps(vY,vW);
     vX = _mm_add_ps(vX,vY);
     XMVECTOR r2 = vX;
-#if defined(_XM_AVX_INTRINSICS_) && (!defined(_MSC_VER) || (_MSC_VER >= 1800))
+#if defined(_XM_AVX_INTRINSICS_)
     vX = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[3]) + 0);
     vY = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[3]) + 1);
     vZ = _mm_broadcast_ss(reinterpret_cast<const float*>(&M1.r[3]) + 2);
diff --git a/Inc/DirectXPackedVector.h b/Inc/DirectXPackedVector.h
index 1dcf3a7..527257d 100644
--- a/Inc/DirectXPackedVector.h
+++ b/Inc/DirectXPackedVector.h
@@ -49,7 +49,7 @@ struct XMCOLOR
         uint32_t c;
     };
 
-    XMCOLOR() XM_CTOR_DEFAULT
+    XMCOLOR() =default;
     XM_CONSTEXPR XMCOLOR(uint32_t Color) : c(Color) {}
     XMCOLOR(float _r, float _g, float _b, float _a);
     explicit XMCOLOR(_In_reads_(4) const float *pArray);
@@ -79,7 +79,7 @@ struct XMHALF2
         uint32_t v;
     };
 
-    XMHALF2() XM_CTOR_DEFAULT
+    XMHALF2() =default;
     explicit XM_CONSTEXPR XMHALF2(uint32_t Packed) : v(Packed) {}
     XM_CONSTEXPR XMHALF2(HALF _x, HALF _y) : x(_x), y(_y) {}
     explicit XMHALF2(_In_reads_(2) const HALF *pArray) : x(pArray[0]), y(pArray[1]) {}
@@ -104,7 +104,7 @@ struct XMSHORTN2
         uint32_t v;
     };
 
-    XMSHORTN2() XM_CTOR_DEFAULT
+    XMSHORTN2() =default;
     explicit XM_CONSTEXPR XMSHORTN2(uint32_t Packed) : v(Packed) {}
     XM_CONSTEXPR XMSHORTN2(int16_t _x, int16_t _y) : x(_x), y(_y) {}
     explicit XMSHORTN2(_In_reads_(2) const int16_t *pArray) : x(pArray[0]), y(pArray[1]) {}
@@ -128,7 +128,7 @@ struct XMSHORT2
         uint32_t v;
     };
 
-    XMSHORT2() XM_CTOR_DEFAULT
+    XMSHORT2() =default;
     explicit XM_CONSTEXPR XMSHORT2(uint32_t Packed) : v(Packed) {}
     XM_CONSTEXPR XMSHORT2(int16_t _x, int16_t _y) : x(_x), y(_y) {}
     explicit XMSHORT2(_In_reads_(2) const int16_t *pArray) : x(pArray[0]), y(pArray[1]) {}
@@ -152,7 +152,7 @@ struct XMUSHORTN2
         uint32_t v;
     };
 
-    XMUSHORTN2() XM_CTOR_DEFAULT
+    XMUSHORTN2() =default;
     explicit XM_CONSTEXPR XMUSHORTN2(uint32_t Packed) : v(Packed) {}
     XM_CONSTEXPR XMUSHORTN2(uint16_t _x, uint16_t _y) : x(_x), y(_y) {}
     explicit XMUSHORTN2(_In_reads_(2) const uint16_t *pArray) : x(pArray[0]), y(pArray[1]) {}
@@ -176,7 +176,7 @@ struct XMUSHORT2
         uint32_t v;
     };
 
-    XMUSHORT2() XM_CTOR_DEFAULT
+    XMUSHORT2() =default;
     explicit XM_CONSTEXPR XMUSHORT2(uint32_t Packed) : v(Packed) {}
     XM_CONSTEXPR XMUSHORT2(uint16_t _x, uint16_t _y) : x(_x), y(_y) {}
     explicit XMUSHORT2(_In_reads_(2) const uint16_t *pArray) : x(pArray[0]), y(pArray[1]) {}
@@ -201,7 +201,7 @@ struct XMBYTEN2
         uint16_t v;
     };
 
-    XMBYTEN2() XM_CTOR_DEFAULT
+    XMBYTEN2() =default;
     explicit XM_CONSTEXPR XMBYTEN2(uint16_t Packed) : v(Packed) {}
     XM_CONSTEXPR XMBYTEN2(int8_t _x, int8_t _y) : x(_x), y(_y) {}
     explicit XMBYTEN2(_In_reads_(2) const int8_t *pArray) : x(pArray[0]), y(pArray[1]) {}
@@ -225,7 +225,7 @@ struct XMBYTE2
         uint16_t v;
     };
 
-    XMBYTE2() XM_CTOR_DEFAULT
+    XMBYTE2() =default;
     explicit XM_CONSTEXPR XMBYTE2(uint16_t Packed) : v(Packed) {}
     XM_CONSTEXPR XMBYTE2(int8_t _x, int8_t _y) : x(_x), y(_y) {}
     explicit XMBYTE2(_In_reads_(2) const int8_t *pArray) : x(pArray[0]), y(pArray[1]) {}
@@ -249,7 +249,7 @@ struct XMUBYTEN2
         uint16_t v;
     };
 
-    XMUBYTEN2() XM_CTOR_DEFAULT
+    XMUBYTEN2() =default;
     explicit XM_CONSTEXPR XMUBYTEN2(uint16_t Packed) : v(Packed) {}
     XM_CONSTEXPR XMUBYTEN2(uint8_t _x, uint8_t _y) : x(_x), y(_y) {}
     explicit XMUBYTEN2(_In_reads_(2) const uint8_t *pArray) : x(pArray[0]), y(pArray[1]) {}
@@ -273,7 +273,7 @@ struct XMUBYTE2
         uint16_t v;
     };
 
-    XMUBYTE2() XM_CTOR_DEFAULT
+    XMUBYTE2() =default;
     explicit XM_CONSTEXPR XMUBYTE2(uint16_t Packed) : v(Packed) {}
     XM_CONSTEXPR XMUBYTE2(uint8_t _x, uint8_t _y) : x(_x), y(_y) {}
     explicit XMUBYTE2(_In_reads_(2) const uint8_t *pArray) : x(pArray[0]), y(pArray[1]) {}
@@ -299,7 +299,7 @@ struct XMU565
         uint16_t v;
     };
 
-    XMU565() XM_CTOR_DEFAULT
+    XMU565() =default;
     explicit XM_CONSTEXPR XMU565(uint16_t Packed) : v(Packed) {}
     XM_CONSTEXPR XMU565(uint8_t _x, uint8_t _y, uint8_t _z) : x(_x), y(_y), z(_z) {}
     explicit XMU565(_In_reads_(3) const uint8_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]) {}
@@ -337,7 +337,7 @@ struct XMFLOAT3PK
         uint32_t v;
     };
 
-    XMFLOAT3PK() XM_CTOR_DEFAULT
+    XMFLOAT3PK() =default;
     explicit XM_CONSTEXPR XMFLOAT3PK(uint32_t Packed) : v(Packed) {}
     XMFLOAT3PK(float _x, float _y, float _z);
     explicit XMFLOAT3PK(_In_reads_(3) const float *pArray);
@@ -370,7 +370,7 @@ struct XMFLOAT3SE
         uint32_t v;
     };
 
-    XMFLOAT3SE() XM_CTOR_DEFAULT
+    XMFLOAT3SE() =default;
     explicit XM_CONSTEXPR XMFLOAT3SE(uint32_t Packed) : v(Packed) {}
     XMFLOAT3SE(float _x, float _y, float _z);
     explicit XMFLOAT3SE(_In_reads_(3) const float *pArray);
@@ -397,7 +397,7 @@ struct XMHALF4
         uint64_t v;
     };
 
-    XMHALF4() XM_CTOR_DEFAULT
+    XMHALF4() =default;
     explicit XM_CONSTEXPR XMHALF4(uint64_t Packed) : v(Packed) {}
     XM_CONSTEXPR XMHALF4(HALF _x, HALF _y, HALF _z, HALF _w) : x(_x), y(_y), z(_z), w(_w) {}
     explicit XMHALF4(_In_reads_(4) const HALF *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
@@ -424,7 +424,7 @@ struct XMSHORTN4
         uint64_t v;
     };
 
-    XMSHORTN4() XM_CTOR_DEFAULT
+    XMSHORTN4() =default;
     explicit XM_CONSTEXPR XMSHORTN4(uint64_t Packed) : v(Packed) {}
     XM_CONSTEXPR XMSHORTN4(int16_t _x, int16_t _y, int16_t _z, int16_t _w) : x(_x), y(_y), z(_z), w(_w) {}
     explicit XMSHORTN4(_In_reads_(4) const int16_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
@@ -450,7 +450,7 @@ struct XMSHORT4
         uint64_t v;
     };
 
-    XMSHORT4() XM_CTOR_DEFAULT
+    XMSHORT4() =default;
     explicit XM_CONSTEXPR XMSHORT4(uint64_t Packed) : v(Packed) {}
     XM_CONSTEXPR XMSHORT4(int16_t _x, int16_t _y, int16_t _z, int16_t _w) : x(_x), y(_y), z(_z), w(_w) {}
     explicit XMSHORT4(_In_reads_(4) const int16_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
@@ -476,7 +476,7 @@ struct XMUSHORTN4
         uint64_t v;
     };
 
-    XMUSHORTN4() XM_CTOR_DEFAULT
+    XMUSHORTN4() =default;
     explicit XM_CONSTEXPR XMUSHORTN4(uint64_t Packed) : v(Packed) {}
     XM_CONSTEXPR XMUSHORTN4(uint16_t _x, uint16_t _y, uint16_t _z, uint16_t _w) : x(_x), y(_y), z(_z), w(_w) {}
     explicit XMUSHORTN4(_In_reads_(4) const uint16_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
@@ -502,7 +502,7 @@ struct XMUSHORT4
         uint64_t v;
     };
 
-    XMUSHORT4() XM_CTOR_DEFAULT
+    XMUSHORT4() =default;
     explicit XM_CONSTEXPR XMUSHORT4(uint64_t Packed) : v(Packed) {}
     XM_CONSTEXPR XMUSHORT4(uint16_t _x, uint16_t _y, uint16_t _z, uint16_t _w) : x(_x), y(_y), z(_z), w(_w) {}
     explicit XMUSHORT4(_In_reads_(4) const uint16_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
@@ -534,7 +534,7 @@ struct XMXDECN4
         uint32_t v;
     };
 
-    XMXDECN4() XM_CTOR_DEFAULT
+    XMXDECN4() =default;
     explicit XM_CONSTEXPR XMXDECN4(uint32_t Packed) : v(Packed) {}
     XMXDECN4(float _x, float _y, float _z, float _w);
     explicit XMXDECN4(_In_reads_(4) const float *pArray);
@@ -565,7 +565,7 @@ struct XM_DEPRECATED XMXDEC4
         uint32_t v;
     };
 
-    XMXDEC4() XM_CTOR_DEFAULT
+    XMXDEC4() =default;
     explicit XM_CONSTEXPR XMXDEC4(uint32_t Packed) : v(Packed) {}
     XMXDEC4(float _x, float _y, float _z, float _w);
     explicit XMXDEC4(_In_reads_(4) const float *pArray);
@@ -596,7 +596,7 @@ struct XM_DEPRECATED XMDECN4
         uint32_t v;
     };
 
-    XMDECN4() XM_CTOR_DEFAULT
+    XMDECN4() =default;
     explicit XM_CONSTEXPR XMDECN4(uint32_t Packed) : v(Packed) {}
     XMDECN4(float _x, float _y, float _z, float _w);
     explicit XMDECN4(_In_reads_(4) const float *pArray);
@@ -627,7 +627,7 @@ struct XM_DEPRECATED XMDEC4
         uint32_t v;
     };
 
-    XMDEC4() XM_CTOR_DEFAULT
+    XMDEC4() =default;
     explicit XM_CONSTEXPR XMDEC4(uint32_t Packed) : v(Packed) {}
     XMDEC4(float _x, float _y, float _z, float _w);
     explicit XMDEC4(_In_reads_(4) const float *pArray);
@@ -658,7 +658,7 @@ struct XMUDECN4
         uint32_t v;
     };
 
-    XMUDECN4() XM_CTOR_DEFAULT
+    XMUDECN4() =default;
     explicit XM_CONSTEXPR XMUDECN4(uint32_t Packed) : v(Packed) {}
     XMUDECN4(float _x, float _y, float _z, float _w);
     explicit XMUDECN4(_In_reads_(4) const float *pArray);
@@ -689,7 +689,7 @@ struct XMUDEC4
         uint32_t v;
     };
 
-    XMUDEC4() XM_CTOR_DEFAULT
+    XMUDEC4() =default;
     explicit XM_CONSTEXPR XMUDEC4(uint32_t Packed) : v(Packed) {}
     XMUDEC4(float _x, float _y, float _z, float _w);
     explicit XMUDEC4(_In_reads_(4) const float *pArray);
@@ -716,7 +716,7 @@ struct XMBYTEN4
         uint32_t v;
     };
 
-    XMBYTEN4() XM_CTOR_DEFAULT
+    XMBYTEN4() =default;
     XM_CONSTEXPR XMBYTEN4(int8_t _x, int8_t _y, int8_t _z, int8_t _w) : x(_x), y(_y), z(_z), w(_w) {}
     explicit XM_CONSTEXPR XMBYTEN4(uint32_t Packed) : v(Packed) {}
     explicit XMBYTEN4(_In_reads_(4) const int8_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
@@ -742,7 +742,7 @@ struct XMBYTE4
         uint32_t v;
     };
 
-    XMBYTE4() XM_CTOR_DEFAULT
+    XMBYTE4() =default;
     XM_CONSTEXPR XMBYTE4(int8_t _x, int8_t _y, int8_t _z, int8_t _w) : x(_x), y(_y), z(_z), w(_w) {}
     explicit XM_CONSTEXPR XMBYTE4(uint32_t Packed) : v(Packed) {}
     explicit XMBYTE4(_In_reads_(4) const int8_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
@@ -768,7 +768,7 @@ struct XMUBYTEN4
         uint32_t v;
     };
 
-    XMUBYTEN4() XM_CTOR_DEFAULT
+    XMUBYTEN4() =default;
     XM_CONSTEXPR XMUBYTEN4(uint8_t _x, uint8_t _y, uint8_t _z, uint8_t _w) : x(_x), y(_y), z(_z), w(_w) {}
     explicit XM_CONSTEXPR XMUBYTEN4(uint32_t Packed) : v(Packed) {}
     explicit XMUBYTEN4(_In_reads_(4) const uint8_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
@@ -794,7 +794,7 @@ struct XMUBYTE4
         uint32_t v;
     };
 
-    XMUBYTE4() XM_CTOR_DEFAULT
+    XMUBYTE4() =default;
     XM_CONSTEXPR XMUBYTE4(uint8_t _x, uint8_t _y, uint8_t _z, uint8_t _w) : x(_x), y(_y), z(_z), w(_w) {}
     explicit XM_CONSTEXPR XMUBYTE4(uint32_t Packed) : v(Packed) {}
     explicit XMUBYTE4(_In_reads_(4) const uint8_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
@@ -821,7 +821,7 @@ struct XMUNIBBLE4
         uint16_t v;
     };
 
-    XMUNIBBLE4() XM_CTOR_DEFAULT
+    XMUNIBBLE4() =default;
     explicit XM_CONSTEXPR XMUNIBBLE4(uint16_t Packed) : v(Packed) {}
     XM_CONSTEXPR XMUNIBBLE4(uint8_t _x, uint8_t _y, uint8_t _z, uint8_t _w) : x(_x), y(_y), z(_z), w(_w) {}
     explicit XMUNIBBLE4(_In_reads_(4) const uint8_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {}
@@ -850,7 +850,7 @@ struct XMU555
         uint16_t v;
     };
 
-    XMU555() XM_CTOR_DEFAULT
+    XMU555() =default;
     explicit XM_CONSTEXPR XMU555(uint16_t Packed) : v(Packed) {}
     XM_CONSTEXPR XMU555(uint8_t _x, uint8_t _y, uint8_t _z, bool _w) : x(_x), y(_y), z(_z), w(_w ? 0x1 : 0) {}
     XMU555(_In_reads_(3) const uint8_t *pArray, _In_ bool _w) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(_w ? 0x1 : 0) {}