Add explicit scalar no-intrinsics codepath to XMMatrixRotationQuaternion, XMQuaternionRotationRollPitchYaw(FromVector)

Author: walbourn

Inc/DirectXMathMatrix.inl

@@ -1779,8 +1779,42 @@ inline XMMATRIX XM_CALLCONV XMMatrixRotationAxis
 
 inline XMMATRIX XM_CALLCONV XMMatrixRotationQuaternion(FXMVECTOR Quaternion) noexcept
 {
-#if defined(_XM_NO_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_)
+#if defined(_XM_NO_INTRINSICS_)
+
+    float qx = Quaternion.vector4_f32[0];
+    float qxx = qx * qx;
+
+    float qy = Quaternion.vector4_f32[1];
+    float qyy = qy * qy;
+
+    float qz = Quaternion.vector4_f32[2];
+    float qzz = qz * qz;
+
+    float qw = Quaternion.vector4_f32[3];
 
+    XMMATRIX M;
+    M.m[0][0] = 1.f - 2.f * qyy - 2.f * qzz;
+    M.m[0][1] = 2.f * qx * qy + 2.f * qz * qw;
+    M.m[0][2] = 2.f * qx * qz - 2.f * qy * qw;
+    M.m[0][3] = 0.f;
+
+    M.m[1][0] = 2.f * qx * qy - 2.f * qz * qw;
+    M.m[1][1] = 1.f - 2.f * qxx - 2.f * qzz;
+    M.m[1][2] = 2.f * qy * qz + 2.f * qx * qw;
+    M.m[1][3] = 0.f;
+
+    M.m[2][0] = 2.f * qx * qz + 2.f * qy * qw;
+    M.m[2][1] = 2.f * qy * qz - 2.f * qx * qw;
+    M.m[2][2] = 1.f - 2.f * qxx - 2.f * qyy;
+    M.m[2][3] = 0.f;
+
+    M.m[3][0] = 0.f;
+    M.m[3][1] = 0.f;
+    M.m[3][2] = 0.f;
+    M.m[3][3] = 1.0f;
+    return M;
+
+#elif defined(_XM_ARM_NEON_INTRINSICS_)
     static const XMVECTORF32 Constant1110 = { { { 1.0f, 1.0f, 1.0f, 0.0f } } };
 
     XMVECTOR Q0 = XMVectorAdd(Quaternion, Quaternion);

Inc/DirectXMathMisc.inl

@@ -228,16 +228,14 @@ inline XMVECTOR XM_CALLCONV XMQuaternionConjugate(FXMVECTOR Q) noexcept
 
 inline XMVECTOR XM_CALLCONV XMQuaternionInverse(FXMVECTOR Q) noexcept
 {
-    const XMVECTOR  Zero = XMVectorZero();
-
     XMVECTOR L = XMVector4LengthSq(Q);
     XMVECTOR Conjugate = XMQuaternionConjugate(Q);
 
     XMVECTOR Control = XMVectorLessOrEqual(L, g_XMEpsilon.v);
 
     XMVECTOR Result = XMVectorDivide(Conjugate, L);
 
-    Result = XMVectorSelect(Result, Zero, Control);
+    Result = XMVectorSelect(Result, g_XMZero, Control);
 
     return Result;
 }
@@ -582,9 +580,30 @@ inline XMVECTOR XM_CALLCONV XMQuaternionRotationRollPitchYaw
     float Roll
 ) noexcept
 {
+#if defined(_XM_NO_INTRINSICS_)
+    const float halfpitch = Pitch * 0.5f;
+    float cp = cosf(halfpitch);
+    float sp = sinf(halfpitch);
+
+    const float halfyaw = Yaw * 0.5f;
+    float cy = cosf(halfyaw);
+    float sy = sinf(halfyaw);
+
+    const float halfroll = Roll * 0.5f;
+    float cr = cosf(halfroll);
+    float sr = sinf(halfroll);
+
+    XMVECTORF32 vResult = { { {
+            cr * sp * cy + sr * cp * sy,
+            cr * cp * sy - sr * sp * cy,
+            sr * cp * cy - cr * sp * sy,
+            cr * cp * cy + sr * sp * sy
+        } } };
+    return vResult;
+#else
     XMVECTOR Angles = XMVectorSet(Pitch, Yaw, Roll, 0.0f);
-    XMVECTOR Q = XMQuaternionRotationRollPitchYawFromVector(Angles);
-    return Q;
+    return XMQuaternionRotationRollPitchYawFromVector(Angles);
+#endif
 }
 
 //------------------------------------------------------------------------------
@@ -594,6 +613,27 @@ inline XMVECTOR XM_CALLCONV XMQuaternionRotationRollPitchYawFromVector
     FXMVECTOR Angles // <Pitch, Yaw, Roll, 0>
 ) noexcept
 {
+#if defined(_XM_NO_INTRINSICS_)
+    const float halfpitch = Angles.vector4_f32[0] * 0.5f;
+    float cp = cosf(halfpitch);
+    float sp = sinf(halfpitch);
+
+    const float halfyaw = Angles.vector4_f32[1] * 0.5f;
+    float cy = cosf(halfyaw);
+    float sy = sinf(halfyaw);
+
+    const float halfroll = Angles.vector4_f32[2] * 0.5f;
+    float cr = cosf(halfroll);
+    float sr = sinf(halfroll);
+
+    XMVECTORF32 vResult = { { {
+            cr * sp * cy + sr * cp * sy,
+            cr * cp * sy - sr * sp * cy,
+            sr * cp * cy - cr * sp * sy,
+            cr * cp * cy + sr * sp * sy
+        } } };
+    return vResult;
+#else
     static const XMVECTORF32  Sign = { { { 1.0f, -1.0f, -1.0f, 1.0f } } };
 
     XMVECTOR HalfAngles = XMVectorMultiply(Angles, g_XMOneHalf.v);
@@ -615,6 +655,7 @@ inline XMVECTOR XM_CALLCONV XMQuaternionRotationRollPitchYawFromVector
     XMVECTOR Q = XMVectorMultiplyAdd(Q1, R1, Q0);
 
     return Q;
+#endif
 }
 
 //------------------------------------------------------------------------------