Incorrect type alignment about luabridge3 HOT 9 CLOSED

typedef __m128d SSEType;

struct alignas(16) OtherClass
{
public:
	SSEType XY;
	SSEType ZW;
};

void __VectorStoreFloat3(const OtherClass& Vec, double* Dst)
{
	_mm_storeu_pd(Dst, Vec.XY);
	_mm_store_sd(Dst + 2, Vec.ZW);
}

void __VectorStoreAligned(const OtherClass& Vec, double* Dst)
{
	_mm_store_pd(Dst, Vec.XY);
	_mm_store_pd(Dst + 2, Vec.ZW);
}

OtherClass __MakeVectorRegisterDouble(double X, double Y, double Z, double W)
{
	OtherClass Result;
	Result.XY = _mm_setr_pd(X, Y);
	Result.ZW = _mm_setr_pd(Z, W);
	return Result;
}

OtherClass __VectorLoadAligned(const double* Ptr)
{
	OtherClass Result;
	Result.XY = _mm_load_pd((const double*)(Ptr));
	Result.ZW = _mm_load_pd((const double*)(Ptr + 2));
	return Result;
}

OtherClass __VectorLoadAligned(const MyQuat* Ptr)
{
	return __VectorLoadAligned((const double*)(Ptr));
}

template<typename T>
struct alignas(16) MyTransform
{
public:
	OtherClass Rotation;
	OtherClass Translation;
	OtherClass Scale3D;

	MyTransform(const MyQuat& InRotation, const MyVector& InTranslation, const MyVector& InScale3D)
	{
		Rotation = __VectorLoadAligned(&InRotation);
		Translation = __MakeVectorRegisterDouble(InTranslation.X, InTranslation.Y, InTranslation.Z, 0.0f);
		Scale3D = __MakeVectorRegisterDouble(InScale3D.X, InScale3D.Y, InScale3D.Z, 0.0f);
	}

	MyRotation Rotator() const
	{
		MyQuat OutRotation;
		__VectorStoreAligned(Rotation, (double*)&OutRotation);
		return OutRotation.Rotator();
	}

	MyVector GetTranslation() const
	{
		MyVector OutTranslation;
		__VectorStoreFloat3(Translation, (double*)&OutTranslation);
		return OutTranslation;
	}

	MyVector GetScale3D() const
	{
		MyVector OutScale3D;
		__VectorStoreFloat3(Scale3D, (double*)&OutScale3D);
		return OutScale3D;
	}

	MyString ToString() const
	{
		const MyRotation R(Rotator());
		const MyVector TT(GetTranslation());
		const MyVector S(GetScale3D());

		return MyString::fmt("%f,%f,%f|%f,%f,%f|%f,%f,%f", TT.X, TT.Y, TT.Z, R.Pitch, R.Yaw, R.Roll, S.X, S.Y, S.Z);
	}
};

using FMyTransform = MyTransform<double>;

		.beginClass<FMyTransform>("Trans")
			.addConstructor<void(const MyQuat&, const MyVector&, const MyVector&)>()
			.addFunction("__tostring", &FMyTransform::ToString)
		.endClass()

.addStaticProperty("Identity", &MyLuaConstants::Identity, false)

class MyLuaConstants
{
public:
	static MyQuat Identity;
};

MyQuat MyLuaConstants::Identity(MyQuat(0, 0, 0, 1));

.addStaticProperty("Identity", []() -> MyQuat { return MyQuat:Identity; })