Merge pull request #38738 from akien-mga/cause-we-never-go-out-of-style

Style: Remove new line at block start, enforce line between functions, enforce braces in if and loop blocks

7 files changed, 18 insertions, 86 deletions

diff --git a/servers/physics_3d/joints/cone_twist_joint_3d_sw.cpp b/servers/physics_3d/joints/cone_twist_joint_3d_sw.cpp
index 56dd8044e4..9d10ede608 100644
--- a/servers/physics_3d/joints/cone_twist_joint_3d_sw.cpp
+++ b/servers/physics_3d/joints/cone_twist_joint_3d_sw.cpp
@@ -52,7 +52,6 @@ Written by: Marcus Hennix
 #include "cone_twist_joint_3d_sw.h"
 
 static void plane_space(const Vector3 &n, Vector3 &p, Vector3 &q) {
-
 	if (Math::abs(n.z) > Math_SQRT12) {
 		// choose p in y-z plane
 		real_t a = n[1] * n[1] + n[2] * n[2];
@@ -87,7 +86,6 @@ static _FORCE_INLINE_ real_t atan2fast(real_t y, real_t x) {
 
 ConeTwistJoint3DSW::ConeTwistJoint3DSW(Body3DSW *rbA, Body3DSW *rbB, const Transform &rbAFrame, const Transform &rbBFrame) :
 		Joint3DSW(_arr, 2) {
-
 	A = rbA;
 	B = rbB;
 
@@ -238,7 +236,6 @@ bool ConeTwistJoint3DSW::setup(real_t p_timestep) {
 }
 
 void ConeTwistJoint3DSW::solve(real_t p_timestep) {
-
 	Vector3 pivotAInW = A->get_transform().xform(m_rbAFrame.origin);
 	Vector3 pivotBInW = B->get_transform().xform(m_rbBFrame.origin);
 
@@ -309,27 +306,21 @@ void ConeTwistJoint3DSW::solve(real_t p_timestep) {
 }
 
 void ConeTwistJoint3DSW::set_param(PhysicsServer3D::ConeTwistJointParam p_param, real_t p_value) {
-
 	switch (p_param) {
 		case PhysicsServer3D::CONE_TWIST_JOINT_SWING_SPAN: {
-
 			m_swingSpan1 = p_value;
 			m_swingSpan2 = p_value;
 		} break;
 		case PhysicsServer3D::CONE_TWIST_JOINT_TWIST_SPAN: {
-
 			m_twistSpan = p_value;
 		} break;
 		case PhysicsServer3D::CONE_TWIST_JOINT_BIAS: {
-
 			m_biasFactor = p_value;
 		} break;
 		case PhysicsServer3D::CONE_TWIST_JOINT_SOFTNESS: {
-
 			m_limitSoftness = p_value;
 		} break;
 		case PhysicsServer3D::CONE_TWIST_JOINT_RELAXATION: {
-
 			m_relaxationFactor = p_value;
 		} break;
 		case PhysicsServer3D::CONE_TWIST_MAX:
@@ -338,26 +329,20 @@ void ConeTwistJoint3DSW::set_param(PhysicsServer3D::ConeTwistJointParam p_param,
 }
 
 real_t ConeTwistJoint3DSW::get_param(PhysicsServer3D::ConeTwistJointParam p_param) const {
-
 	switch (p_param) {
 		case PhysicsServer3D::CONE_TWIST_JOINT_SWING_SPAN: {
-
 			return m_swingSpan1;
 		} break;
 		case PhysicsServer3D::CONE_TWIST_JOINT_TWIST_SPAN: {
-
 			return m_twistSpan;
 		} break;
 		case PhysicsServer3D::CONE_TWIST_JOINT_BIAS: {
-
 			return m_biasFactor;
 		} break;
 		case PhysicsServer3D::CONE_TWIST_JOINT_SOFTNESS: {
-
 			return m_limitSoftness;
 		} break;
 		case PhysicsServer3D::CONE_TWIST_JOINT_RELAXATION: {
-
 			return m_relaxationFactor;
 		} break;
 		case PhysicsServer3D::CONE_TWIST_MAX:
diff --git a/servers/physics_3d/joints/generic_6dof_joint_3d_sw.cpp b/servers/physics_3d/joints/generic_6dof_joint_3d_sw.cpp
index 9f387ea5c5..423bbc0dfd 100644
--- a/servers/physics_3d/joints/generic_6dof_joint_3d_sw.cpp
+++ b/servers/physics_3d/joints/generic_6dof_joint_3d_sw.cpp
@@ -83,8 +83,9 @@ int G6DOFRotationalLimitMotor3DSW::testLimitValue(real_t test_value) {
 real_t G6DOFRotationalLimitMotor3DSW::solveAngularLimits(
 		real_t timeStep, Vector3 &axis, real_t jacDiagABInv,
 		Body3DSW *body0, Body3DSW *body1) {
-	if (!needApplyTorques())
+	if (!needApplyTorques()) {
 		return 0.0f;
+	}
 
 	real_t target_velocity = m_targetVelocity;
 	real_t maxMotorForce = m_maxMotorForce;
@@ -138,8 +139,9 @@ real_t G6DOFRotationalLimitMotor3DSW::solveAngularLimits(
 	Vector3 motorImp = clippedMotorImpulse * axis;
 
 	body0->apply_torque_impulse(motorImp);
-	if (body1)
+	if (body1) {
 		body1->apply_torque_impulse(-motorImp);
+	}
 
 	return clippedMotorImpulse;
 }
@@ -155,7 +157,6 @@ real_t G6DOFTranslationalLimitMotor3DSW::solveLinearAxis(
 		int limit_index,
 		const Vector3 &axis_normal_on_a,
 		const Vector3 &anchorPos) {
-
 	///find relative velocity
 	//    Vector3 rel_pos1 = pointInA - body1->get_transform().origin;
 	//    Vector3 rel_pos2 = pointInB - body2->get_transform().origin;
@@ -303,7 +304,6 @@ bool Generic6DOFJoint3DSW::testAngularLimitMotor(int axis_index) {
 }
 
 bool Generic6DOFJoint3DSW::setup(real_t p_timestep) {
-
 	// Clear accumulated impulses for the next simulation step
 	m_linearLimits.m_accumulatedImpulse = Vector3(real_t(0.), real_t(0.), real_t(0.));
 	int i;
@@ -327,10 +327,11 @@ bool Generic6DOFJoint3DSW::setup(real_t p_timestep) {
 	//linear part
 	for (i = 0; i < 3; i++) {
 		if (m_linearLimits.enable_limit[i] && m_linearLimits.isLimited(i)) {
-			if (m_useLinearReferenceFrameA)
+			if (m_useLinearReferenceFrameA) {
 				normalWorld = m_calculatedTransformA.basis.get_axis(i);
-			else
+			} else {
 				normalWorld = m_calculatedTransformB.basis.get_axis(i);
+			}
 
 			buildLinearJacobian(
 					m_jacLinear[i], normalWorld,
@@ -369,10 +370,11 @@ void Generic6DOFJoint3DSW::solve(real_t p_timestep) {
 		if (m_linearLimits.enable_limit[i] && m_linearLimits.isLimited(i)) {
 			jacDiagABInv = real_t(1.) / m_jacLinear[i].getDiagonal();
 
-			if (m_useLinearReferenceFrameA)
+			if (m_useLinearReferenceFrameA) {
 				linear_axis = m_calculatedTransformA.basis.get_axis(i);
-			else
+			} else {
 				linear_axis = m_calculatedTransformB.basis.get_axis(i);
+			}
 
 			m_linearLimits.solveLinearAxis(
 					m_timeStep,
@@ -388,7 +390,6 @@ void Generic6DOFJoint3DSW::solve(real_t p_timestep) {
 	real_t angularJacDiagABInv;
 	for (i = 0; i < 3; i++) {
 		if (m_angularLimits[i].m_enableLimit && m_angularLimits[i].needApplyTorques()) {
-
 			// get axis
 			angular_axis = getAxis(i);
 
@@ -426,75 +427,60 @@ void Generic6DOFJoint3DSW::calcAnchorPos() {
 } // Generic6DOFJointSW::calcAnchorPos()
 
 void Generic6DOFJoint3DSW::set_param(Vector3::Axis p_axis, PhysicsServer3D::G6DOFJointAxisParam p_param, real_t p_value) {
-
 	ERR_FAIL_INDEX(p_axis, 3);
 	switch (p_param) {
 		case PhysicsServer3D::G6DOF_JOINT_LINEAR_LOWER_LIMIT: {
-
 			m_linearLimits.m_lowerLimit[p_axis] = p_value;
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_LINEAR_UPPER_LIMIT: {
-
 			m_linearLimits.m_upperLimit[p_axis] = p_value;
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_LINEAR_LIMIT_SOFTNESS: {
-
 			m_linearLimits.m_limitSoftness[p_axis] = p_value;
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_LINEAR_RESTITUTION: {
-
 			m_linearLimits.m_restitution[p_axis] = p_value;
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_LINEAR_DAMPING: {
-
 			m_linearLimits.m_damping[p_axis] = p_value;
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_ANGULAR_LOWER_LIMIT: {
-
 			m_angularLimits[p_axis].m_loLimit = p_value;
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_ANGULAR_UPPER_LIMIT: {
-
 			m_angularLimits[p_axis].m_hiLimit = p_value;
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_ANGULAR_LIMIT_SOFTNESS: {
-
 			m_angularLimits[p_axis].m_limitSoftness = p_value;
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_ANGULAR_DAMPING: {
-
 			m_angularLimits[p_axis].m_damping = p_value;
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_ANGULAR_RESTITUTION: {
-
 			m_angularLimits[p_axis].m_bounce = p_value;
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_ANGULAR_FORCE_LIMIT: {
-
 			m_angularLimits[p_axis].m_maxLimitForce = p_value;
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_ANGULAR_ERP: {
-
 			m_angularLimits[p_axis].m_ERP = p_value;
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_ANGULAR_MOTOR_TARGET_VELOCITY: {
-
 			m_angularLimits[p_axis].m_targetVelocity = p_value;
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_ANGULAR_MOTOR_FORCE_LIMIT: {
-
 			m_angularLimits[p_axis].m_maxLimitForce = p_value;
 
 		} break;
@@ -531,71 +517,57 @@ real_t Generic6DOFJoint3DSW::get_param(Vector3::Axis p_axis, PhysicsServer3D::G6
 	ERR_FAIL_INDEX_V(p_axis, 3, 0);
 	switch (p_param) {
 		case PhysicsServer3D::G6DOF_JOINT_LINEAR_LOWER_LIMIT: {
-
 			return m_linearLimits.m_lowerLimit[p_axis];
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_LINEAR_UPPER_LIMIT: {
-
 			return m_linearLimits.m_upperLimit[p_axis];
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_LINEAR_LIMIT_SOFTNESS: {
-
 			return m_linearLimits.m_limitSoftness[p_axis];
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_LINEAR_RESTITUTION: {
-
 			return m_linearLimits.m_restitution[p_axis];
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_LINEAR_DAMPING: {
-
 			return m_linearLimits.m_damping[p_axis];
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_ANGULAR_LOWER_LIMIT: {
-
 			return m_angularLimits[p_axis].m_loLimit;
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_ANGULAR_UPPER_LIMIT: {
-
 			return m_angularLimits[p_axis].m_hiLimit;
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_ANGULAR_LIMIT_SOFTNESS: {
-
 			return m_angularLimits[p_axis].m_limitSoftness;
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_ANGULAR_DAMPING: {
-
 			return m_angularLimits[p_axis].m_damping;
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_ANGULAR_RESTITUTION: {
-
 			return m_angularLimits[p_axis].m_bounce;
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_ANGULAR_FORCE_LIMIT: {
-
 			return m_angularLimits[p_axis].m_maxLimitForce;
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_ANGULAR_ERP: {
-
 			return m_angularLimits[p_axis].m_ERP;
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_ANGULAR_MOTOR_TARGET_VELOCITY: {
-
 			return m_angularLimits[p_axis].m_targetVelocity;
 
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_ANGULAR_MOTOR_FORCE_LIMIT: {
-
 			return m_angularLimits[p_axis].m_maxMotorForce;
 
 		} break;
@@ -630,20 +602,16 @@ real_t Generic6DOFJoint3DSW::get_param(Vector3::Axis p_axis, PhysicsServer3D::G6
 }
 
 void Generic6DOFJoint3DSW::set_flag(Vector3::Axis p_axis, PhysicsServer3D::G6DOFJointAxisFlag p_flag, bool p_value) {
-
 	ERR_FAIL_INDEX(p_axis, 3);
 
 	switch (p_flag) {
 		case PhysicsServer3D::G6DOF_JOINT_FLAG_ENABLE_LINEAR_LIMIT: {
-
 			m_linearLimits.enable_limit[p_axis] = p_value;
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_FLAG_ENABLE_ANGULAR_LIMIT: {
-
 			m_angularLimits[p_axis].m_enableLimit = p_value;
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_FLAG_ENABLE_MOTOR: {
-
 			m_angularLimits[p_axis].m_enableMotor = p_value;
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_FLAG_ENABLE_LINEAR_MOTOR: {
@@ -659,20 +627,17 @@ void Generic6DOFJoint3DSW::set_flag(Vector3::Axis p_axis, PhysicsServer3D::G6DOF
 			break; // Can't happen, but silences warning
 	}
 }
-bool Generic6DOFJoint3DSW::get_flag(Vector3::Axis p_axis, PhysicsServer3D::G6DOFJointAxisFlag p_flag) const {
 
+bool Generic6DOFJoint3DSW::get_flag(Vector3::Axis p_axis, PhysicsServer3D::G6DOFJointAxisFlag p_flag) const {
 	ERR_FAIL_INDEX_V(p_axis, 3, 0);
 	switch (p_flag) {
 		case PhysicsServer3D::G6DOF_JOINT_FLAG_ENABLE_LINEAR_LIMIT: {
-
 			return m_linearLimits.enable_limit[p_axis];
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_FLAG_ENABLE_ANGULAR_LIMIT: {
-
 			return m_angularLimits[p_axis].m_enableLimit;
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_FLAG_ENABLE_MOTOR: {
-
 			return m_angularLimits[p_axis].m_enableMotor;
 		} break;
 		case PhysicsServer3D::G6DOF_JOINT_FLAG_ENABLE_LINEAR_MOTOR: {
diff --git a/servers/physics_3d/joints/hinge_joint_3d_sw.cpp b/servers/physics_3d/joints/hinge_joint_3d_sw.cpp
index dea1be5040..a879b4ca7f 100644
--- a/servers/physics_3d/joints/hinge_joint_3d_sw.cpp
+++ b/servers/physics_3d/joints/hinge_joint_3d_sw.cpp
@@ -50,7 +50,6 @@ subject to the following restrictions:
 #include "hinge_joint_3d_sw.h"
 
 static void plane_space(const Vector3 &n, Vector3 &p, Vector3 &q) {
-
 	if (Math::abs(n.z) > Math_SQRT12) {
 		// choose p in y-z plane
 		real_t a = n[1] * n[1] + n[2] * n[2];
@@ -70,7 +69,6 @@ static void plane_space(const Vector3 &n, Vector3 &p, Vector3 &q) {
 
 HingeJoint3DSW::HingeJoint3DSW(Body3DSW *rbA, Body3DSW *rbB, const Transform &frameA, const Transform &frameB) :
 		Joint3DSW(_arr, 2) {
-
 	A = rbA;
 	B = rbB;
 
@@ -103,7 +101,6 @@ HingeJoint3DSW::HingeJoint3DSW(Body3DSW *rbA, Body3DSW *rbB, const Transform &fr
 HingeJoint3DSW::HingeJoint3DSW(Body3DSW *rbA, Body3DSW *rbB, const Vector3 &pivotInA, const Vector3 &pivotInB,
 		const Vector3 &axisInA, const Vector3 &axisInB) :
 		Joint3DSW(_arr, 2) {
-
 	A = rbA;
 	B = rbB;
 
@@ -158,7 +155,6 @@ HingeJoint3DSW::HingeJoint3DSW(Body3DSW *rbA, Body3DSW *rbB, const Vector3 &pivo
 }
 
 bool HingeJoint3DSW::setup(real_t p_step) {
-
 	m_appliedImpulse = real_t(0.);
 
 	if (!m_angularOnly) {
@@ -254,7 +250,6 @@ bool HingeJoint3DSW::setup(real_t p_step) {
 }
 
 void HingeJoint3DSW::solve(real_t p_step) {
-
 	Vector3 pivotAInW = A->get_transform().xform(m_rbAFrame.origin);
 	Vector3 pivotBInW = B->get_transform().xform(m_rbBFrame.origin);
 
@@ -365,12 +360,14 @@ void HingeJoint3DSW::solve(real_t p_step) {
 		}
 	}
 }
+
 /*
 void	HingeJointSW::updateRHS(real_t	timeStep)
 {
 	(void)timeStep;
 
 }
+
 */
 
 static _FORCE_INLINE_ real_t atan2fast(real_t y, real_t x) {
@@ -397,9 +394,7 @@ real_t HingeJoint3DSW::get_hinge_angle() {
 }
 
 void HingeJoint3DSW::set_param(PhysicsServer3D::HingeJointParam p_param, real_t p_value) {
-
 	switch (p_param) {
-
 		case PhysicsServer3D::HINGE_JOINT_BIAS:
 			tau = p_value;
 			break;
@@ -430,9 +425,7 @@ void HingeJoint3DSW::set_param(PhysicsServer3D::HingeJointParam p_param, real_t
 }
 
 real_t HingeJoint3DSW::get_param(PhysicsServer3D::HingeJointParam p_param) const {
-
 	switch (p_param) {
-
 		case PhysicsServer3D::HINGE_JOINT_BIAS:
 			return tau;
 		case PhysicsServer3D::HINGE_JOINT_LIMIT_UPPER:
@@ -457,7 +450,6 @@ real_t HingeJoint3DSW::get_param(PhysicsServer3D::HingeJointParam p_param) const
 }
 
 void HingeJoint3DSW::set_flag(PhysicsServer3D::HingeJointFlag p_flag, bool p_value) {
-
 	switch (p_flag) {
 		case PhysicsServer3D::HINGE_JOINT_FLAG_USE_LIMIT:
 			m_useLimit = p_value;
@@ -469,8 +461,8 @@ void HingeJoint3DSW::set_flag(PhysicsServer3D::HingeJointFlag p_flag, bool p_val
 			break; // Can't happen, but silences warning
 	}
 }
-bool HingeJoint3DSW::get_flag(PhysicsServer3D::HingeJointFlag p_flag) const {
 
+bool HingeJoint3DSW::get_flag(PhysicsServer3D::HingeJointFlag p_flag) const {
 	switch (p_flag) {
 		case PhysicsServer3D::HINGE_JOINT_FLAG_USE_LIMIT:
 			return m_useLimit;
diff --git a/servers/physics_3d/joints/hinge_joint_3d_sw.h b/servers/physics_3d/joints/hinge_joint_3d_sw.h
index eebead20b8..c5af888eca 100644
--- a/servers/physics_3d/joints/hinge_joint_3d_sw.h
+++ b/servers/physics_3d/joints/hinge_joint_3d_sw.h
@@ -54,7 +54,6 @@ subject to the following restrictions:
 */
 
 class HingeJoint3DSW : public Joint3DSW {
-
 	union {
 		struct {
 			Body3DSW *A;
diff --git a/servers/physics_3d/joints/pin_joint_3d_sw.cpp b/servers/physics_3d/joints/pin_joint_3d_sw.cpp
index dd6b315152..230904408b 100644
--- a/servers/physics_3d/joints/pin_joint_3d_sw.cpp
+++ b/servers/physics_3d/joints/pin_joint_3d_sw.cpp
@@ -50,7 +50,6 @@ subject to the following restrictions:
 #include "pin_joint_3d_sw.h"
 
 bool PinJoint3DSW::setup(real_t p_step) {
-
 	m_appliedImpulse = real_t(0.);
 
 	Vector3 normal(0, 0, 0);
@@ -74,7 +73,6 @@ bool PinJoint3DSW::setup(real_t p_step) {
 }
 
 void PinJoint3DSW::solve(real_t p_step) {
-
 	Vector3 pivotAInW = A->get_transform().xform(m_pivotInA);
 	Vector3 pivotBInW = B->get_transform().xform(m_pivotInB);
 
@@ -111,10 +109,12 @@ void PinJoint3DSW::solve(real_t p_step) {
 
 		real_t impulseClamp = m_impulseClamp;
 		if (impulseClamp > 0) {
-			if (impulse < -impulseClamp)
+			if (impulse < -impulseClamp) {
 				impulse = -impulseClamp;
-			if (impulse > impulseClamp)
+			}
+			if (impulse > impulseClamp) {
 				impulse = impulseClamp;
+			}
 		}
 
 		m_appliedImpulse += impulse;
@@ -127,7 +127,6 @@ void PinJoint3DSW::solve(real_t p_step) {
 }
 
 void PinJoint3DSW::set_param(PhysicsServer3D::PinJointParam p_param, real_t p_value) {
-
 	switch (p_param) {
 		case PhysicsServer3D::PIN_JOINT_BIAS:
 			m_tau = p_value;
@@ -142,7 +141,6 @@ void PinJoint3DSW::set_param(PhysicsServer3D::PinJointParam p_param, real_t p_va
 }
 
 real_t PinJoint3DSW::get_param(PhysicsServer3D::PinJointParam p_param) const {
-
 	switch (p_param) {
 		case PhysicsServer3D::PIN_JOINT_BIAS:
 			return m_tau;
@@ -157,7 +155,6 @@ real_t PinJoint3DSW::get_param(PhysicsServer3D::PinJointParam p_param) const {
 
 PinJoint3DSW::PinJoint3DSW(Body3DSW *p_body_a, const Vector3 &p_pos_a, Body3DSW *p_body_b, const Vector3 &p_pos_b) :
 		Joint3DSW(_arr, 2) {
-
 	A = p_body_a;
 	B = p_body_b;
 	m_pivotInA = p_pos_a;
diff --git a/servers/physics_3d/joints/pin_joint_3d_sw.h b/servers/physics_3d/joints/pin_joint_3d_sw.h
index 8e81ccf5e0..0181a4455b 100644
--- a/servers/physics_3d/joints/pin_joint_3d_sw.h
+++ b/servers/physics_3d/joints/pin_joint_3d_sw.h
@@ -54,7 +54,6 @@ subject to the following restrictions:
 */
 
 class PinJoint3DSW : public Joint3DSW {
-
 	union {
 		struct {
 			Body3DSW *A;
diff --git a/servers/physics_3d/joints/slider_joint_3d_sw.cpp b/servers/physics_3d/joints/slider_joint_3d_sw.cpp
index 57ad64ca21..5b4609f24e 100644
--- a/servers/physics_3d/joints/slider_joint_3d_sw.cpp
+++ b/servers/physics_3d/joints/slider_joint_3d_sw.cpp
@@ -116,7 +116,6 @@ SliderJoint3DSW::SliderJoint3DSW(Body3DSW *rbA, Body3DSW *rbB, const Transform &
 		Joint3DSW(_arr, 2),
 		m_frameInA(frameInA),
 		m_frameInB(frameInB) {
-
 	A = rbA;
 	B = rbB;
 
@@ -129,7 +128,6 @@ SliderJoint3DSW::SliderJoint3DSW(Body3DSW *rbA, Body3DSW *rbB, const Transform &
 //-----------------------------------------------------------------------------
 
 bool SliderJoint3DSW::setup(real_t p_step) {
-
 	//calculate transforms
 	m_calculatedTransformA = A->get_transform() * m_frameInA;
 	m_calculatedTransformB = B->get_transform() * m_frameInB;
@@ -182,7 +180,6 @@ bool SliderJoint3DSW::setup(real_t p_step) {
 //-----------------------------------------------------------------------------
 
 void SliderJoint3DSW::solve(real_t p_step) {
-
 	int i;
 	// linear
 	Vector3 velA = A->get_velocity_in_local_point(m_relPosA);
@@ -379,7 +376,6 @@ Vector3 SliderJoint3DSW::getAncorInB() {
 } // SliderJointSW::getAncorInB();
 
 void SliderJoint3DSW::set_param(PhysicsServer3D::SliderJointParam p_param, real_t p_value) {
-
 	switch (p_param) {
 		case PhysicsServer3D::SLIDER_JOINT_LINEAR_LIMIT_UPPER:
 			m_upperLinLimit = p_value;
@@ -455,7 +451,6 @@ void SliderJoint3DSW::set_param(PhysicsServer3D::SliderJointParam p_param, real_
 }
 
 real_t SliderJoint3DSW::get_param(PhysicsServer3D::SliderJointParam p_param) const {
-
 	switch (p_param) {
 		case PhysicsServer3D::SLIDER_JOINT_LINEAR_LIMIT_UPPER:
 			return m_upperLinLimit;