clang-format: Disable alignment of operands, too unreliable

Sets `AlignOperands` to `DontAlign`.

`clang-format` developers seem to mostly care about space-based indentation and
every other version of clang-format breaks the bad mismatch of tabs and spaces
that it seems to use for operand alignment. So it's better without, so that it
respects our two-tabs `ContinuationIndentWidth`.

6 files changed, 110 insertions, 92 deletions

diff --git a/servers/physics_3d/godot_body_pair_3d.cpp b/servers/physics_3d/godot_body_pair_3d.cpp
index 457abfb71a..f7d9ed9ee9 100644
--- a/servers/physics_3d/godot_body_pair_3d.cpp
+++ b/servers/physics_3d/godot_body_pair_3d.cpp
@@ -495,8 +495,7 @@ void GodotBodyPair3D::solve(real_t p_step) {
 			Vector3 temp1 = inv_inertia_tensor_A.xform(c.rA.cross(tv));
 			Vector3 temp2 = inv_inertia_tensor_B.xform(c.rB.cross(tv));
 
-			real_t t = -tvl /
-					   (inv_mass_A + inv_mass_B + tv.dot(temp1.cross(c.rA) + temp2.cross(c.rB)));
+			real_t t = -tvl / (inv_mass_A + inv_mass_B + tv.dot(temp1.cross(c.rA) + temp2.cross(c.rB)));
 
 			Vector3 jt = t * tv;
 
@@ -863,8 +862,7 @@ void GodotBodySoftBodyPair3D::solve(real_t p_step) {
 
 			Vector3 temp1 = body_inv_inertia_tensor.xform(c.rA.cross(tv));
 
-			real_t t = -tvl /
-					   (body_inv_mass + node_inv_mass + tv.dot(temp1.cross(c.rA)));
+			real_t t = -tvl / (body_inv_mass + node_inv_mass + tv.dot(temp1.cross(c.rA)));
 
 			Vector3 jt = t * tv;
 
diff --git a/servers/physics_3d/joints/godot_cone_twist_joint_3d.cpp b/servers/physics_3d/joints/godot_cone_twist_joint_3d.cpp
index 31a87fc595..864086c956 100644
--- a/servers/physics_3d/joints/godot_cone_twist_joint_3d.cpp
+++ b/servers/physics_3d/joints/godot_cone_twist_joint_3d.cpp
@@ -129,16 +129,18 @@ bool GodotConeTwistJoint3D::setup(real_t p_timestep) {
 		plane_space(normal[0], normal[1], normal[2]);
 
 		for (int i = 0; i < 3; i++) {
-			memnew_placement(&m_jac[i], GodotJacobianEntry3D(
-												A->get_principal_inertia_axes().transposed(),
-												B->get_principal_inertia_axes().transposed(),
-												pivotAInW - A->get_transform().origin - A->get_center_of_mass(),
-												pivotBInW - B->get_transform().origin - B->get_center_of_mass(),
-												normal[i],
-												A->get_inv_inertia(),
-												A->get_inv_mass(),
-												B->get_inv_inertia(),
-												B->get_inv_mass()));
+			memnew_placement(
+					&m_jac[i],
+					GodotJacobianEntry3D(
+							A->get_principal_inertia_axes().transposed(),
+							B->get_principal_inertia_axes().transposed(),
+							pivotAInW - A->get_transform().origin - A->get_center_of_mass(),
+							pivotBInW - B->get_transform().origin - B->get_center_of_mass(),
+							normal[i],
+							A->get_inv_inertia(),
+							A->get_inv_mass(),
+							B->get_inv_inertia(),
+							B->get_inv_mass()));
 		}
 	}
 
@@ -192,8 +194,7 @@ bool GodotConeTwistJoint3D::setup(real_t p_timestep) {
 		real_t swingAxisSign = (b2Axis1.dot(b1Axis1) >= 0.0f) ? 1.0f : -1.0f;
 		m_swingAxis *= swingAxisSign;
 
-		m_kSwing = real_t(1.) / (A->compute_angular_impulse_denominator(m_swingAxis) +
-										B->compute_angular_impulse_denominator(m_swingAxis));
+		m_kSwing = real_t(1.) / (A->compute_angular_impulse_denominator(m_swingAxis) + B->compute_angular_impulse_denominator(m_swingAxis));
 	}
 
 	// Twist limits
@@ -212,8 +213,7 @@ bool GodotConeTwistJoint3D::setup(real_t p_timestep) {
 			m_twistAxis.normalize();
 			m_twistAxis *= -1.0f;
 
-			m_kTwist = real_t(1.) / (A->compute_angular_impulse_denominator(m_twistAxis) +
-											B->compute_angular_impulse_denominator(m_twistAxis));
+			m_kTwist = real_t(1.) / (A->compute_angular_impulse_denominator(m_twistAxis) + B->compute_angular_impulse_denominator(m_twistAxis));
 
 		} else if (twist > m_twistSpan * lockedFreeFactor) {
 			m_twistCorrection = (twist - m_twistSpan);
@@ -222,8 +222,7 @@ bool GodotConeTwistJoint3D::setup(real_t p_timestep) {
 			m_twistAxis = (b2Axis1 + b1Axis1) * 0.5f;
 			m_twistAxis.normalize();
 
-			m_kTwist = real_t(1.) / (A->compute_angular_impulse_denominator(m_twistAxis) +
-											B->compute_angular_impulse_denominator(m_twistAxis));
+			m_kTwist = real_t(1.) / (A->compute_angular_impulse_denominator(m_twistAxis) + B->compute_angular_impulse_denominator(m_twistAxis));
 		}
 	}
 
diff --git a/servers/physics_3d/joints/godot_generic_6dof_joint_3d.cpp b/servers/physics_3d/joints/godot_generic_6dof_joint_3d.cpp
index b88e2d1190..915bb528e9 100644
--- a/servers/physics_3d/joints/godot_generic_6dof_joint_3d.cpp
+++ b/servers/physics_3d/joints/godot_generic_6dof_joint_3d.cpp
@@ -279,25 +279,30 @@ void GodotGeneric6DOFJoint3D::calculateTransforms() {
 void GodotGeneric6DOFJoint3D::buildLinearJacobian(
 		GodotJacobianEntry3D &jacLinear, const Vector3 &normalWorld,
 		const Vector3 &pivotAInW, const Vector3 &pivotBInW) {
-	memnew_placement(&jacLinear, GodotJacobianEntry3D(
-										 A->get_principal_inertia_axes().transposed(),
-										 B->get_principal_inertia_axes().transposed(),
-										 pivotAInW - A->get_transform().origin - A->get_center_of_mass(),
-										 pivotBInW - B->get_transform().origin - B->get_center_of_mass(),
-										 normalWorld,
-										 A->get_inv_inertia(),
-										 A->get_inv_mass(),
-										 B->get_inv_inertia(),
-										 B->get_inv_mass()));
+	memnew_placement(
+			&jacLinear,
+			GodotJacobianEntry3D(
+					A->get_principal_inertia_axes().transposed(),
+					B->get_principal_inertia_axes().transposed(),
+					pivotAInW - A->get_transform().origin - A->get_center_of_mass(),
+					pivotBInW - B->get_transform().origin - B->get_center_of_mass(),
+					normalWorld,
+					A->get_inv_inertia(),
+					A->get_inv_mass(),
+					B->get_inv_inertia(),
+					B->get_inv_mass()));
 }
 
 void GodotGeneric6DOFJoint3D::buildAngularJacobian(
 		GodotJacobianEntry3D &jacAngular, const Vector3 &jointAxisW) {
-	memnew_placement(&jacAngular, GodotJacobianEntry3D(jointAxisW,
-										  A->get_principal_inertia_axes().transposed(),
-										  B->get_principal_inertia_axes().transposed(),
-										  A->get_inv_inertia(),
-										  B->get_inv_inertia()));
+	memnew_placement(
+			&jacAngular,
+			GodotJacobianEntry3D(
+					jointAxisW,
+					A->get_principal_inertia_axes().transposed(),
+					B->get_principal_inertia_axes().transposed(),
+					A->get_inv_inertia(),
+					B->get_inv_inertia()));
 }
 
 bool GodotGeneric6DOFJoint3D::testAngularLimitMotor(int axis_index) {
diff --git a/servers/physics_3d/joints/godot_hinge_joint_3d.cpp b/servers/physics_3d/joints/godot_hinge_joint_3d.cpp
index 7b7ca1b3ac..cf77129a30 100644
--- a/servers/physics_3d/joints/godot_hinge_joint_3d.cpp
+++ b/servers/physics_3d/joints/godot_hinge_joint_3d.cpp
@@ -149,16 +149,18 @@ bool GodotHingeJoint3D::setup(real_t p_step) {
 		plane_space(normal[0], normal[1], normal[2]);
 
 		for (int i = 0; i < 3; i++) {
-			memnew_placement(&m_jac[i], GodotJacobianEntry3D(
-												A->get_principal_inertia_axes().transposed(),
-												B->get_principal_inertia_axes().transposed(),
-												pivotAInW - A->get_transform().origin - A->get_center_of_mass(),
-												pivotBInW - B->get_transform().origin - B->get_center_of_mass(),
-												normal[i],
-												A->get_inv_inertia(),
-												A->get_inv_mass(),
-												B->get_inv_inertia(),
-												B->get_inv_mass()));
+			memnew_placement(
+					&m_jac[i],
+					GodotJacobianEntry3D(
+							A->get_principal_inertia_axes().transposed(),
+							B->get_principal_inertia_axes().transposed(),
+							pivotAInW - A->get_transform().origin - A->get_center_of_mass(),
+							pivotBInW - B->get_transform().origin - B->get_center_of_mass(),
+							normal[i],
+							A->get_inv_inertia(),
+							A->get_inv_mass(),
+							B->get_inv_inertia(),
+							B->get_inv_mass()));
 		}
 	}
 
@@ -175,23 +177,32 @@ bool GodotHingeJoint3D::setup(real_t p_step) {
 	Vector3 jointAxis1 = A->get_transform().basis.xform(jointAxis1local);
 	Vector3 hingeAxisWorld = A->get_transform().basis.xform(m_rbAFrame.basis.get_axis(2));
 
-	memnew_placement(&m_jacAng[0], GodotJacobianEntry3D(jointAxis0,
-										   A->get_principal_inertia_axes().transposed(),
-										   B->get_principal_inertia_axes().transposed(),
-										   A->get_inv_inertia(),
-										   B->get_inv_inertia()));
-
-	memnew_placement(&m_jacAng[1], GodotJacobianEntry3D(jointAxis1,
-										   A->get_principal_inertia_axes().transposed(),
-										   B->get_principal_inertia_axes().transposed(),
-										   A->get_inv_inertia(),
-										   B->get_inv_inertia()));
-
-	memnew_placement(&m_jacAng[2], GodotJacobianEntry3D(hingeAxisWorld,
-										   A->get_principal_inertia_axes().transposed(),
-										   B->get_principal_inertia_axes().transposed(),
-										   A->get_inv_inertia(),
-										   B->get_inv_inertia()));
+	memnew_placement(
+			&m_jacAng[0],
+			GodotJacobianEntry3D(
+					jointAxis0,
+					A->get_principal_inertia_axes().transposed(),
+					B->get_principal_inertia_axes().transposed(),
+					A->get_inv_inertia(),
+					B->get_inv_inertia()));
+
+	memnew_placement(
+			&m_jacAng[1],
+			GodotJacobianEntry3D(
+					jointAxis1,
+					A->get_principal_inertia_axes().transposed(),
+					B->get_principal_inertia_axes().transposed(),
+					A->get_inv_inertia(),
+					B->get_inv_inertia()));
+
+	memnew_placement(
+			&m_jacAng[2],
+			GodotJacobianEntry3D(
+					hingeAxisWorld,
+					A->get_principal_inertia_axes().transposed(),
+					B->get_principal_inertia_axes().transposed(),
+					A->get_inv_inertia(),
+					B->get_inv_inertia()));
 
 	// Compute limit information
 	real_t hingeAngle = get_hinge_angle();
@@ -220,8 +231,7 @@ bool GodotHingeJoint3D::setup(real_t p_step) {
 
 	//Compute K = J*W*J' for hinge axis
 	Vector3 axisA = A->get_transform().basis.xform(m_rbAFrame.basis.get_axis(2));
-	m_kHinge = 1.0f / (A->compute_angular_impulse_denominator(axisA) +
-							  B->compute_angular_impulse_denominator(axisA));
+	m_kHinge = 1.0f / (A->compute_angular_impulse_denominator(axisA) + B->compute_angular_impulse_denominator(axisA));
 
 	return true;
 }
@@ -284,7 +294,7 @@ void GodotHingeJoint3D::solve(real_t p_step) {
 			if (len > real_t(0.00001)) {
 				Vector3 normal = velrelOrthog.normalized();
 				real_t denom = A->compute_angular_impulse_denominator(normal) +
-							   B->compute_angular_impulse_denominator(normal);
+						B->compute_angular_impulse_denominator(normal);
 				// scale for mass and relaxation
 				velrelOrthog *= (real_t(1.) / denom) * m_relaxationFactor;
 			}
@@ -295,7 +305,7 @@ void GodotHingeJoint3D::solve(real_t p_step) {
 			if (len2 > real_t(0.00001)) {
 				Vector3 normal2 = angularError.normalized();
 				real_t denom2 = A->compute_angular_impulse_denominator(normal2) +
-								B->compute_angular_impulse_denominator(normal2);
+						B->compute_angular_impulse_denominator(normal2);
 				angularError *= (real_t(1.) / denom2) * relaxation;
 			}
 
diff --git a/servers/physics_3d/joints/godot_pin_joint_3d.cpp b/servers/physics_3d/joints/godot_pin_joint_3d.cpp
index 10d52ad5e9..e9e81b61a7 100644
--- a/servers/physics_3d/joints/godot_pin_joint_3d.cpp
+++ b/servers/physics_3d/joints/godot_pin_joint_3d.cpp
@@ -63,16 +63,18 @@ bool GodotPinJoint3D::setup(real_t p_step) {
 
 	for (int i = 0; i < 3; i++) {
 		normal[i] = 1;
-		memnew_placement(&m_jac[i], GodotJacobianEntry3D(
-											A->get_principal_inertia_axes().transposed(),
-											B->get_principal_inertia_axes().transposed(),
-											A->get_transform().xform(m_pivotInA) - A->get_transform().origin - A->get_center_of_mass(),
-											B->get_transform().xform(m_pivotInB) - B->get_transform().origin - B->get_center_of_mass(),
-											normal,
-											A->get_inv_inertia(),
-											A->get_inv_mass(),
-											B->get_inv_inertia(),
-											B->get_inv_mass()));
+		memnew_placement(
+				&m_jac[i],
+				GodotJacobianEntry3D(
+						A->get_principal_inertia_axes().transposed(),
+						B->get_principal_inertia_axes().transposed(),
+						A->get_transform().xform(m_pivotInA) - A->get_transform().origin - A->get_center_of_mass(),
+						B->get_transform().xform(m_pivotInB) - B->get_transform().origin - B->get_center_of_mass(),
+						normal,
+						A->get_inv_inertia(),
+						A->get_inv_mass(),
+						B->get_inv_inertia(),
+						B->get_inv_mass()));
 		normal[i] = 0;
 	}
 
diff --git a/servers/physics_3d/joints/godot_slider_joint_3d.cpp b/servers/physics_3d/joints/godot_slider_joint_3d.cpp
index 3be111ac92..1f463ad24c 100644
--- a/servers/physics_3d/joints/godot_slider_joint_3d.cpp
+++ b/servers/physics_3d/joints/godot_slider_joint_3d.cpp
@@ -112,16 +112,18 @@ bool GodotSliderJoint3D::setup(real_t p_step) {
 	//linear part
 	for (i = 0; i < 3; i++) {
 		normalWorld = m_calculatedTransformA.basis.get_axis(i);
-		memnew_placement(&m_jacLin[i], GodotJacobianEntry3D(
-											   A->get_principal_inertia_axes().transposed(),
-											   B->get_principal_inertia_axes().transposed(),
-											   m_relPosA - A->get_center_of_mass(),
-											   m_relPosB - B->get_center_of_mass(),
-											   normalWorld,
-											   A->get_inv_inertia(),
-											   A->get_inv_mass(),
-											   B->get_inv_inertia(),
-											   B->get_inv_mass()));
+		memnew_placement(
+				&m_jacLin[i],
+				GodotJacobianEntry3D(
+						A->get_principal_inertia_axes().transposed(),
+						B->get_principal_inertia_axes().transposed(),
+						m_relPosA - A->get_center_of_mass(),
+						m_relPosB - B->get_center_of_mass(),
+						normalWorld,
+						A->get_inv_inertia(),
+						A->get_inv_mass(),
+						B->get_inv_inertia(),
+						B->get_inv_mass()));
 		m_jacLinDiagABInv[i] = real_t(1.) / m_jacLin[i].getDiagonal();
 		m_depth[i] = m_delta.dot(normalWorld);
 	}
@@ -129,12 +131,14 @@ bool GodotSliderJoint3D::setup(real_t p_step) {
 	// angular part
 	for (i = 0; i < 3; i++) {
 		normalWorld = m_calculatedTransformA.basis.get_axis(i);
-		memnew_placement(&m_jacAng[i], GodotJacobianEntry3D(
-											   normalWorld,
-											   A->get_principal_inertia_axes().transposed(),
-											   B->get_principal_inertia_axes().transposed(),
-											   A->get_inv_inertia(),
-											   B->get_inv_inertia()));
+		memnew_placement(
+				&m_jacAng[i],
+				GodotJacobianEntry3D(
+						normalWorld,
+						A->get_principal_inertia_axes().transposed(),
+						B->get_principal_inertia_axes().transposed(),
+						A->get_inv_inertia(),
+						B->get_inv_inertia()));
 	}
 	testAngLimits();
 	Vector3 axisA = m_calculatedTransformA.basis.get_axis(0);