Small optimization for multiplying Mat44 with a Vec3 normal

[Kermalis]

In C#'s System.Numerics.Vector3 struct, there are two methods for Vector3 * Matrix4x4:

• Position vectors: Vector3.Transform()
• Normal vectors: Vector3.TransformNormal()

The C# implementations:

The only difference is that the final addition with the translation component of the matrix is skipped for TransformNormal(). For lots of operations with normals, this can be pretty nice, since it's "free performance" if you remember to use it lol. I'm not sure how much the library itself would make use of this though.

You can of course throw normals into Vector3.Transform() but you'd be missing out on the small optimization that Vector3.TransformNormal() exists to provide you. If you know you're definitely dealing with a normal vector (like Vec3::sAxisY()) then Vector3.TransformNormal() is the better choice.

I apologize if Jolt already has this somewhere... I couldn't find it myself but I'd love to know if it exists.
If it doesn't exist, I understand that in Jolt this would be a bit cumbersome to do since it directly overloads the * operator, but there could be a helper function for it (which is what I'm doing for myself).

It's pretty simple to implement for anyone curious:

Vec3 TransformNormal(Vec3Arg inV) const
{
#if defined(JPH_USE_SSE)
	__m128 t = _mm_mul_ps(mCol[0].mValue, _mm_shuffle_ps(inV.mValue, inV.mValue, _MM_SHUFFLE(0, 0, 0, 0)));
	t = _mm_add_ps(t, _mm_mul_ps(mCol[1].mValue, _mm_shuffle_ps(inV.mValue, inV.mValue, _MM_SHUFFLE(1, 1, 1, 1))));
	t = _mm_add_ps(t, _mm_mul_ps(mCol[2].mValue, _mm_shuffle_ps(inV.mValue, inV.mValue, _MM_SHUFFLE(2, 2, 2, 2))));
	return Vec3::sFixW(t);
#elif defined(JPH_USE_NEON)
	Type t = vmulq_f32(mCol[0].mValue, vdupq_laneq_f32(inV.mValue, 0));
	t = vmlaq_f32(t, mCol[1].mValue, vdupq_laneq_f32(inV.mValue, 1));
	t = vmlaq_f32(t, mCol[2].mValue, vdupq_laneq_f32(inV.mValue, 2));
	return Vec3::sFixW(t);
#elif defined(JPH_USE_RVV)
	const vfloat32m1_t v0 = __riscv_vfmv_v_f_f32m1(inV.mF32[0], 4);
	const vfloat32m1_t v1 = __riscv_vfmv_v_f_f32m1(inV.mF32[1], 4);
	const vfloat32m1_t v2 = __riscv_vfmv_v_f_f32m1(inV.mF32[2], 4);

	const vfloat32m1_t col0 = __riscv_vle32_v_f32m1(mCol[0].mF32, 4);
	const vfloat32m1_t col1 = __riscv_vle32_v_f32m1(mCol[1].mF32, 4);
	const vfloat32m1_t col2 = __riscv_vle32_v_f32m1(mCol[2].mF32, 4);

	const vfloat32m1_t mul1 = __riscv_vfmul_vv_f32m1(col1, v1, 4);
	const vfloat32m1_t mul2 = __riscv_vfmul_vv_f32m1(col2, v2, 4);

	vfloat32m1_t t = __riscv_vfmul_vv_f32m1(col0, v0, 4);
	t = __riscv_vfadd_vv_f32m1(t, mul1, 4);
	t = __riscv_vfadd_vv_f32m1(t, mul2, 4);

	Type v;
	__riscv_vse32_v_f32m1(v.mData, t, 4);
	return Vec3::sFixW(v);
#else
	return Vec3(
		(mCol[0].mF32[0] * inV.mF32[0]) + (mCol[1].mF32[0] * inV.mF32[1]) + (mCol[2].mF32[0] * inV.mF32[2]),
		(mCol[0].mF32[1] * inV.mF32[0]) + (mCol[1].mF32[1] * inV.mF32[1]) + (mCol[2].mF32[1] * inV.mF32[2]),
		(mCol[0].mF32[2] * inV.mF32[0]) + (mCol[1].mF32[2] * inV.mF32[1]) + (mCol[2].mF32[2] * inV.mF32[2]));
#endif
}

And Jolt's v5.6.0 operator for reference:

Vec3 Mat44::operator * (Vec3Arg inV) const
{
#if defined(JPH_USE_SSE)
	__m128 t = _mm_mul_ps(mCol[0].mValue, _mm_shuffle_ps(inV.mValue, inV.mValue, _MM_SHUFFLE(0, 0, 0, 0)));
	t = _mm_add_ps(t, _mm_mul_ps(mCol[1].mValue, _mm_shuffle_ps(inV.mValue, inV.mValue, _MM_SHUFFLE(1, 1, 1, 1))));
	t = _mm_add_ps(t, _mm_mul_ps(mCol[2].mValue, _mm_shuffle_ps(inV.mValue, inV.mValue, _MM_SHUFFLE(2, 2, 2, 2))));
	t = _mm_add_ps(t, mCol[3].mValue);
	return Vec3::sFixW(t);
#elif defined(JPH_USE_NEON)
	Type t = vmulq_f32(mCol[0].mValue, vdupq_laneq_f32(inV.mValue, 0));
	t = vmlaq_f32(t, mCol[1].mValue, vdupq_laneq_f32(inV.mValue, 1));
	t = vmlaq_f32(t, mCol[2].mValue, vdupq_laneq_f32(inV.mValue, 2));
	t = vaddq_f32(t, mCol[3].mValue); // Don't combine this with the first mul into a fused multiply add, causes precision issues
	return Vec3::sFixW(t);
#elif defined(JPH_USE_RVV)
	const vfloat32m1_t v0 = __riscv_vfmv_v_f_f32m1(inV.mF32[0], 4);
	const vfloat32m1_t v1 = __riscv_vfmv_v_f_f32m1(inV.mF32[1], 4);
	const vfloat32m1_t v2 = __riscv_vfmv_v_f_f32m1(inV.mF32[2], 4);

	const vfloat32m1_t col0 = __riscv_vle32_v_f32m1(mCol[0].mF32, 4);
	const vfloat32m1_t col1 = __riscv_vle32_v_f32m1(mCol[1].mF32, 4);
	const vfloat32m1_t col2 = __riscv_vle32_v_f32m1(mCol[2].mF32, 4);
	const vfloat32m1_t col3 = __riscv_vle32_v_f32m1(mCol[3].mF32, 4);

	const vfloat32m1_t mul1 = __riscv_vfmul_vv_f32m1(col1, v1, 4);
	const vfloat32m1_t mul2 = __riscv_vfmul_vv_f32m1(col2, v2, 4);

	vfloat32m1_t t = __riscv_vfmul_vv_f32m1(col0, v0, 4);
	t = __riscv_vfadd_vv_f32m1(t, mul1, 4);
	t = __riscv_vfadd_vv_f32m1(t, mul2, 4);
	t = __riscv_vfadd_vv_f32m1(t, col3, 4);

	Type v;
	__riscv_vse32_v_f32m1(v.mData, t, 4);
	return Vec3::sFixW(v);
#else
	return Vec3(
		mCol[0].mF32[0] * inV.mF32[0] + mCol[1].mF32[0] * inV.mF32[1] + mCol[2].mF32[0] * inV.mF32[2] + mCol[3].mF32[0],
		mCol[0].mF32[1] * inV.mF32[0] + mCol[1].mF32[1] * inV.mF32[1] + mCol[2].mF32[1] * inV.mF32[2] + mCol[3].mF32[1],
		mCol[0].mF32[2] * inV.mF32[0] + mCol[1].mF32[2] * inV.mF32[1] + mCol[2].mF32[2] * inV.mF32[2] + mCol[3].mF32[2]);
#endif
}

I'm curious to hear back if there is something like this already or if there is any pushback for adding it natively if there isn't something like it!

[jrouwe]

I think you're looking for Mat44::Multiply3x3.

[Kermalis]

Ah I just realized the Vec3Arg overload of Multiply3x3. I originally looked at the Mat44 one and didn't see it. Thanks :)