Style: Enforce braces around if blocks and loops

Using clang-tidy's `readability-braces-around-statements`.
https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html

servers/audio/audio_driver_dummy.cpp

@@ -86,20 +86,23 @@ AudioDriver::SpeakerMode AudioDriverDummy::get_speaker_mode() const {
 };
 
 void AudioDriverDummy::lock() {
-	if (!thread)
+	if (!thread) {
 		return;
+	}
 	mutex.lock();
 };
 
 void AudioDriverDummy::unlock() {
-	if (!thread)
+	if (!thread) {
 		return;
+	}
 	mutex.unlock();
 };
 
 void AudioDriverDummy::finish() {
-	if (!thread)
+	if (!thread) {
 		return;
+	}
 
 	exit_thread = true;
 	Thread::wait_to_finish(thread);

servers/audio/audio_filter_sw.cpp

@@ -54,8 +54,9 @@ void AudioFilterSW::prepare_coefficients(Coeffs *p_coeffs) {
 	int sr_limit = (sampling_rate / 2) + 512;
 
 	double final_cutoff = (cutoff > sr_limit) ? sr_limit : cutoff;
-	if (final_cutoff < 1)
+	if (final_cutoff < 1) {
 		final_cutoff = 1; //don't allow less than this
+	}
 
 	double omega = 2.0 * Math_PI * final_cutoff / sampling_rate;
 
@@ -67,15 +68,17 @@ void AudioFilterSW::prepare_coefficients(Coeffs *p_coeffs) {
 		Q = 0.0001;
 	}
 
-	if (mode == BANDPASS)
+	if (mode == BANDPASS) {
 		Q *= 2.0;
-	else if (mode == PEAK)
+	} else if (mode == PEAK) {
 		Q *= 3.0;
+	}
 
 	double tmpgain = gain;
 
-	if (tmpgain < 0.001)
+	if (tmpgain < 0.001) {
 		tmpgain = 0.001;
+	}
 
 	if (stages > 1) {
 		Q = (Q > 1.0 ? Math::pow(Q, 1.0 / stages) : Q);
@@ -142,8 +145,9 @@ void AudioFilterSW::prepare_coefficients(Coeffs *p_coeffs) {
 		} break;
 		case LOWSHELF: {
 			double tmpq = Math::sqrt(Q);
-			if (tmpq <= 0)
+			if (tmpq <= 0) {
 				tmpq = 0.001;
+			}
 			double beta = Math::sqrt(tmpgain) / tmpq;
 
 			a0 = (tmpgain + 1.0) + (tmpgain - 1.0) * cos_v + beta * sin_v;
@@ -156,8 +160,9 @@ void AudioFilterSW::prepare_coefficients(Coeffs *p_coeffs) {
 		} break;
 		case HIGHSHELF: {
 			double tmpq = Math::sqrt(Q);
-			if (tmpq <= 0)
+			if (tmpq <= 0) {
 				tmpq = 0.001;
+			}
 			double beta = Math::sqrt(tmpgain) / tmpq;
 
 			a0 = (tmpgain + 1.0) - (tmpgain - 1.0) * cos_v + beta * sin_v;
@@ -235,8 +240,9 @@ void AudioFilterSW::Processor::set_filter(AudioFilterSW *p_filter, bool p_clear_
 }
 
 void AudioFilterSW::Processor::update_coeffs(int p_interp_buffer_len) {
-	if (!filter)
+	if (!filter) {
 		return;
+	}
 
 	if (p_interp_buffer_len) { //interpolate
 		Coeffs old_coeffs = coeffs;
@@ -253,8 +259,9 @@ void AudioFilterSW::Processor::update_coeffs(int p_interp_buffer_len) {
 }
 
 void AudioFilterSW::Processor::process(float *p_samples, int p_amount, int p_stride, bool p_interpolate) {
-	if (!filter)
+	if (!filter) {
 		return;
+	}
 
 	if (p_interpolate) {
 		for (int i = 0; i < p_amount; i++) {

servers/audio/audio_rb_resampler.cpp

@@ -34,8 +34,9 @@
 #include "servers/audio_server.h"
 
 int AudioRBResampler::get_channel_count() const {
-	if (!rb)
+	if (!rb) {
 		return 0;
+	}
 
 	return channels;
 }
@@ -101,8 +102,9 @@ uint32_t AudioRBResampler::_resample(AudioFrame *p_dest, int p_todo, int32_t p_i
 }
 
 bool AudioRBResampler::mix(AudioFrame *p_dest, int p_frames) {
-	if (!rb)
+	if (!rb) {
 		return false;
+	}
 
 	int32_t increment = (src_mix_rate * MIX_FRAC_LEN) / target_mix_rate;
 	int read_space = get_reader_space();
@@ -125,8 +127,9 @@ bool AudioRBResampler::mix(AudioFrame *p_dest, int p_frames) {
 				break;
 		}
 
-		if (src_read > read_space)
+		if (src_read > read_space) {
 			src_read = read_space;
+		}
 
 		rb_read_pos = (rb_read_pos + src_read) & rb_mask;
 
@@ -147,8 +150,9 @@ bool AudioRBResampler::mix(AudioFrame *p_dest, int p_frames) {
 }
 
 int AudioRBResampler::get_num_of_ready_frames() {
-	if (!is_ready())
+	if (!is_ready()) {
 		return 0;
+	}
 	int32_t increment = (src_mix_rate * MIX_FRAC_LEN) / target_mix_rate;
 	int read_space = get_reader_space();
 	return (int64_t(read_space) << MIX_FRAC_BITS) / increment;
@@ -192,8 +196,9 @@ Error AudioRBResampler::setup(int p_channels, int p_src_mix_rate, int p_target_m
 }
 
 void AudioRBResampler::clear() {
-	if (!rb)
+	if (!rb) {
 		return;
+	}
 
 	//should be stopped at this point but just in case
 	memdelete_arr(rb);

servers/audio/audio_stream.cpp

@@ -244,8 +244,9 @@ Ref<AudioStream> AudioStreamRandomPitch::get_audio_stream() const {
 }
 
 void AudioStreamRandomPitch::set_random_pitch(float p_pitch) {
-	if (p_pitch < 1)
+	if (p_pitch < 1) {
 		p_pitch = 1;
+	}
 	random_pitch = p_pitch;
 }
 
@@ -256,8 +257,9 @@ float AudioStreamRandomPitch::get_random_pitch() const {
 Ref<AudioStreamPlayback> AudioStreamRandomPitch::instance_playback() {
 	Ref<AudioStreamPlaybackRandomPitch> playback;
 	playback.instance();
-	if (audio_stream.is_valid())
+	if (audio_stream.is_valid()) {
 		playback->playback = audio_stream->instance_playback();
+	}
 
 	playbacks.insert(playback.ptr());
 	playback->random_pitch = Ref<AudioStreamRandomPitch>((AudioStreamRandomPitch *)this);

servers/audio/effects/audio_effect_chorus.cpp

@@ -81,8 +81,9 @@ void AudioEffectChorusInstance::_process_chunk(const AudioFrame *p_src_frames, A
 		}
 
 		//low pass filter
-		if (v.cutoff == 0)
+		if (v.cutoff == 0) {
 			continue;
+		}
 		float auxlp = expf(-2.0 * Math_PI * v.cutoff / mix_rate);
 		float c1 = 1.0 - auxlp;
 		float c2 = auxlp;

servers/audio/effects/audio_effect_compressor.cpp

@@ -66,11 +66,13 @@ void AudioEffectCompressorInstance::process(const AudioFrame *p_src_frames, Audi
 
 		float overdb = 2.08136898f * Math::linear2db(peak / threshold);
 
-		if (overdb < 0.0) //we only care about what goes over to compress
+		if (overdb < 0.0) { //we only care about what goes over to compress
 			overdb = 0.0;
+		}
 
-		if (overdb - rundb > 5) // diffeence is too large
+		if (overdb - rundb > 5) { // diffeence is too large
 			averatio = 4;
+		}
 
 		if (overdb > rundb) {
 			rundb = overdb + atcoef * (rundb - overdb);
@@ -101,8 +103,9 @@ void AudioEffectCompressorInstance::process(const AudioFrame *p_src_frames, Audi
 			gr_meter = grv;
 		} else {
 			gr_meter *= gr_meter_decay;
-			if (gr_meter > 1)
+			if (gr_meter > 1) {
 				gr_meter = 1;
+			}
 		}
 
 		p_dst_frames[i] = p_src_frames[i] * grv * makeup * mix + p_src_frames[i] * (1.0 - mix);

servers/audio/effects/audio_effect_delay.cpp

@@ -105,8 +105,9 @@ void AudioEffectDelayInstance::_process_chunk(const AudioFrame *p_src_frames, Au
 
 		ring_buffer_pos++;
 
-		if ((++feedback_buffer_pos) >= feedback_delay_frames)
+		if ((++feedback_buffer_pos) >= feedback_delay_frames) {
 			feedback_buffer_pos = 0;
+		}
 	}
 }
 

servers/audio/effects/audio_effect_distortion.cpp

@@ -59,10 +59,11 @@ void AudioEffectDistortionInstance::process(const AudioFrame *p_src_frames, Audi
 		switch (base->mode) {
 			case AudioEffectDistortion::MODE_CLIP: {
 				a = powf(a, 1.0001 - drive_f);
-				if (a > 1.0)
+				if (a > 1.0) {
 					a = 1.0;
-				else if (a < (-1.0))
+				} else if (a < (-1.0)) {
 					a = -1.0;
+				}
 
 			} break;
 			case AudioEffectDistortion::MODE_ATAN: {

servers/audio/effects/audio_effect_filter.cpp

@@ -36,12 +36,15 @@ void AudioEffectFilterInstance::_process_filter(const AudioFrame *p_src_frames,
 	for (int i = 0; i < p_frame_count; i++) {
 		float f = p_src_frames[i].l;
 		filter_process[0][0].process_one(f);
-		if (S > 1)
+		if (S > 1) {
 			filter_process[0][1].process_one(f);
-		if (S > 2)
+		}
+		if (S > 2) {
 			filter_process[0][2].process_one(f);
-		if (S > 3)
+		}
+		if (S > 3) {
 			filter_process[0][3].process_one(f);
+		}
 
 		p_dst_frames[i].l = f;
 	}
@@ -49,12 +52,15 @@ void AudioEffectFilterInstance::_process_filter(const AudioFrame *p_src_frames,
 	for (int i = 0; i < p_frame_count; i++) {
 		float f = p_src_frames[i].r;
 		filter_process[1][0].process_one(f);
-		if (S > 1)
+		if (S > 1) {
 			filter_process[1][1].process_one(f);
-		if (S > 2)
+		}
+		if (S > 2) {
 			filter_process[1][2].process_one(f);
-		if (S > 3)
+		}
+		if (S > 3) {
 			filter_process[1][3].process_one(f);
+		}
 
 		p_dst_frames[i].r = f;
 	}

servers/audio/effects/audio_effect_filter.h

@@ -99,8 +99,9 @@ class AudioEffectLowPassFilter : public AudioEffectFilter {
 	GDCLASS(AudioEffectLowPassFilter, AudioEffectFilter);
 
 	void _validate_property(PropertyInfo &property) const {
-		if (property.name == "gain")
+		if (property.name == "gain") {
 			property.usage = 0;
+		}
 	}
 
 public:
@@ -111,8 +112,9 @@ public:
 class AudioEffectHighPassFilter : public AudioEffectFilter {
 	GDCLASS(AudioEffectHighPassFilter, AudioEffectFilter);
 	void _validate_property(PropertyInfo &property) const {
-		if (property.name == "gain")
+		if (property.name == "gain") {
 			property.usage = 0;
+		}
 	}
 
 public:
@@ -123,8 +125,9 @@ public:
 class AudioEffectBandPassFilter : public AudioEffectFilter {
 	GDCLASS(AudioEffectBandPassFilter, AudioEffectFilter);
 	void _validate_property(PropertyInfo &property) const {
-		if (property.name == "gain")
+		if (property.name == "gain") {
 			property.usage = 0;
+		}
 	}
 
 public:

servers/audio/effects/audio_effect_pitch_shift.cpp

@@ -94,7 +94,9 @@ void SMBPitchShift::PitchShift(float pitchShift, long numSampsToProcess, long ff
 	freqPerBin = sampleRate/(double)fftFrameSize;
 	expct = 2.*Math_PI*(double)stepSize/(double)fftFrameSize;
 	inFifoLatency = fftFrameSize-stepSize;
-	if (gRover == 0) gRover = inFifoLatency;
+	if (gRover == 0) { gRover = inFifoLatency;
+
+}
 
 	/* initialize our static arrays */
 
@@ -142,8 +144,10 @@ void SMBPitchShift::PitchShift(float pitchShift, long numSampsToProcess, long ff
 
 				/* map delta phase into +/- Pi interval */
 				qpd = tmp/Math_PI;
-				if (qpd >= 0) qpd += qpd&1;
-				else qpd -= qpd&1;
+				if (qpd >= 0) { qpd += qpd&1;
+				} else { qpd -= qpd&1;
+
+}
 				tmp -= Math_PI*(double)qpd;
 
 				/* get deviation from bin frequency from the +/- Pi interval */
@@ -200,7 +204,9 @@ void SMBPitchShift::PitchShift(float pitchShift, long numSampsToProcess, long ff
 			}
 
 			/* zero negative frequencies */
-			for (k = fftFrameSize+2; k < 2*fftFrameSize; k++) gFFTworksp[k] = 0.;
+			for (k = fftFrameSize+2; k < 2*fftFrameSize; k++) { gFFTworksp[k] = 0.;
+
+}
 
 			/* do inverse transform */
 			smbFft(gFFTworksp, fftFrameSize, 1);
@@ -210,13 +216,17 @@ void SMBPitchShift::PitchShift(float pitchShift, long numSampsToProcess, long ff
 				window = -.5*cos(2.*Math_PI*(double)k/(double)fftFrameSize)+.5;
 				gOutputAccum[k] += 2.*window*gFFTworksp[2*k]/(fftFrameSize2*osamp);
 			}
-			for (k = 0; k < stepSize; k++) gOutFIFO[k] = gOutputAccum[k];
+			for (k = 0; k < stepSize; k++) { gOutFIFO[k] = gOutputAccum[k];
+
+}
 
 			/* shift accumulator */
 			memmove(gOutputAccum, gOutputAccum+stepSize, fftFrameSize*sizeof(float));
 
 			/* move input FIFO */
-			for (k = 0; k < inFifoLatency; k++) gInFIFO[k] = gInFIFO[k+stepSize];
+			for (k = 0; k < inFifoLatency; k++) { gInFIFO[k] = gInFIFO[k+stepSize];
+
+}
 		}
 	}
 
@@ -245,7 +255,9 @@ void SMBPitchShift::smbFft(float *fftBuffer, long fftFrameSize, long sign)
 
 	for (i = 2; i < 2*fftFrameSize-2; i += 2) {
 		for (bitm = 2, j = 0; bitm < 2*fftFrameSize; bitm <<= 1) {
-			if (i & bitm) j++;
+			if (i & bitm) { j++;
+
+}
 			j <<= 1;
 		}
 		if (i < j) {

servers/audio/effects/audio_effect_spectrum_analyzer.cpp

@@ -50,8 +50,9 @@ static void smbFft(float *fftBuffer, long fftFrameSize, long sign)
 
 	for (i = 2; i < 2 * fftFrameSize - 2; i += 2) {
 		for (bitm = 2, j = 0; bitm < 2 * fftFrameSize; bitm <<= 1) {
-			if (i & bitm)
+			if (i & bitm) {
 				j++;
+			}
 			j <<= 1;
 		}
 		if (i < j) {

servers/audio/effects/eq.cpp

@@ -42,22 +42,25 @@ static int solve_quadratic(double a, double b, double c, double *r1, double *r2)
 	//solves quadractic and returns number of roots
 
 	double base = 2 * a;
-	if (base == 0.0f)
+	if (base == 0.0f) {
 		return 0;
+	}
 
 	double squared = b * b - 4 * a * c;
-	if (squared < 0.0)
+	if (squared < 0.0) {
 		return 0;
+	}
 
 	squared = sqrt(squared);
 
 	*r1 = (-b + squared) / base;
 	*r2 = (-b - squared) / base;
 
-	if (*r1 == *r2)
+	if (*r1 == *r2) {
 		return 1;
-	else
+	} else {
 		return 2;
+	}
 }
 
 EQ::BandProcess::BandProcess() {

servers/audio/effects/reverb.cpp

@@ -57,22 +57,27 @@ const float Reverb::allpass_tunings[MAX_ALLPASS] = {
 };
 
 void Reverb::process(float *p_src, float *p_dst, int p_frames) {
-	if (p_frames > INPUT_BUFFER_MAX_SIZE)
+	if (p_frames > INPUT_BUFFER_MAX_SIZE) {
 		p_frames = INPUT_BUFFER_MAX_SIZE;
+	}
 
 	int predelay_frames = lrint((params.predelay / 1000.0) * params.mix_rate);
-	if (predelay_frames < 10)
+	if (predelay_frames < 10) {
 		predelay_frames = 10;
-	if (predelay_frames >= echo_buffer_size)
+	}
+	if (predelay_frames >= echo_buffer_size) {
 		predelay_frames = echo_buffer_size - 1;
+	}
 
 	for (int i = 0; i < p_frames; i++) {
-		if (echo_buffer_pos >= echo_buffer_size)
+		if (echo_buffer_pos >= echo_buffer_size) {
 			echo_buffer_pos = 0;
+		}
 
 		int read_pos = echo_buffer_pos - predelay_frames;
-		while (read_pos < 0)
+		while (read_pos < 0) {
 			read_pos += echo_buffer_size;
+		}
 
 		float in = undenormalise(echo_buffer[read_pos] * params.predelay_fb + p_src[i]);
 
@@ -104,8 +109,9 @@ void Reverb::process(float *p_src, float *p_dst, int p_frames) {
 
 		int size_limit = c.size - lrintf((float)c.extra_spread_frames * (1.0 - params.extra_spread));
 		for (int j = 0; j < p_frames; j++) {
-			if (c.pos >= size_limit) //reset this now just in case
+			if (c.pos >= size_limit) { //reset this now just in case
 				c.pos = 0;
+			}
 
 			float out = undenormalise(c.buffer[c.pos] * c.feedback);
 			out = out * (1.0 - c.damp) + c.damp_h * c.damp; //lowpass
@@ -156,8 +162,9 @@ void Reverb::process(float *p_src, float *p_dst, int p_frames) {
 		int size_limit = a.size - lrintf((float)a.extra_spread_frames * (1.0 - params.extra_spread));
 
 		for (int j = 0; j < p_frames; j++) {
-			if (a.pos >= size_limit)
+			if (a.pos >= size_limit) {
 				a.pos = 0;
+			}
 
 			float aux = a.buffer[a.pos];
 			a.buffer[a.pos] = undenormalise(allpass_feedback * aux + p_dst[j]);
@@ -200,10 +207,12 @@ void Reverb::set_predelay_feedback(float p_predelay_fb) {
 }
 
 void Reverb::set_highpass(float p_frq) {
-	if (p_frq > 1)
+	if (p_frq > 1) {
 		p_frq = 1;
-	if (p_frq < 0)
+	}
+	if (p_frq < 0) {
 		p_frq = 0;
+	}
 	params.hpf = p_frq;
 }
 
@@ -230,13 +239,15 @@ void Reverb::configure_buffers() {
 		c.extra_spread_frames = lrint(params.extra_spread_base * params.mix_rate);
 
 		int len = lrint(comb_tunings[i] * params.mix_rate) + c.extra_spread_frames;
-		if (len < 5)
+		if (len < 5) {
 			len = 5; //may this happen?
+		}
 
 		c.buffer = memnew_arr(float, len);
 		c.pos = 0;
-		for (int j = 0; j < len; j++)
+		for (int j = 0; j < len; j++) {
 			c.buffer[j] = 0;
+		}
 		c.size = len;
 	}
 
@@ -246,13 +257,15 @@ void Reverb::configure_buffers() {
 		a.extra_spread_frames = lrint(params.extra_spread_base * params.mix_rate);
 
 		int len = lrint(allpass_tunings[i] * params.mix_rate) + a.extra_spread_frames;
-		if (len < 5)
+		if (len < 5) {
 			len = 5; //may this happen?
+		}
 
 		a.buffer = memnew_arr(float, len);
 		a.pos = 0;
-		for (int j = 0; j < len; j++)
+		for (int j = 0; j < len; j++) {
 			a.buffer[j] = 0;
+		}
 		a.size = len;
 	}
 
@@ -273,10 +286,11 @@ void Reverb::update_parameters() {
 	for (int i = 0; i < MAX_COMBS; i++) {
 		Comb &c = comb[i];
 		c.feedback = room_offset + params.room_size * room_scale;
-		if (c.feedback < room_offset)
+		if (c.feedback < room_offset) {
 			c.feedback = room_offset;
-		else if (c.feedback > (room_offset + room_scale))
+		} else if (c.feedback > (room_offset + room_scale)) {
 			c.feedback = (room_offset + room_scale);
+		}
 
 		float auxdmp = params.damp / 2.0 + 0.5; //only half the range (0.5 .. 1.0  is enough)
 		auxdmp *= auxdmp;
@@ -286,19 +300,22 @@ void Reverb::update_parameters() {
 }
 
 void Reverb::clear_buffers() {
-	if (echo_buffer)
+	if (echo_buffer) {
 		memdelete_arr(echo_buffer);
+	}
 
 	for (int i = 0; i < MAX_COMBS; i++) {
-		if (comb[i].buffer)
+		if (comb[i].buffer) {
 			memdelete_arr(comb[i].buffer);
+		}
 
 		comb[i].buffer = nullptr;
 	}
 
 	for (int i = 0; i < MAX_ALLPASS; i++) {
-		if (allpass[i].buffer)
+		if (allpass[i].buffer) {
 			memdelete_arr(allpass[i].buffer);
+		}
 
 		allpass[i].buffer = nullptr;
 	}

servers/audio_server.cpp

@@ -55,17 +55,20 @@ void AudioDriver::set_singleton() {
 }
 
 void AudioDriver::audio_server_process(int p_frames, int32_t *p_buffer, bool p_update_mix_time) {
-	if (p_update_mix_time)
+	if (p_update_mix_time) {
 		update_mix_time(p_frames);
+	}
 
-	if (AudioServer::get_singleton())
+	if (AudioServer::get_singleton()) {
 		AudioServer::get_singleton()->_driver_process(p_frames, p_buffer);
+	}
 }
 
 void AudioDriver::update_mix_time(int p_frames) {
 	_last_mix_frames = p_frames;
-	if (OS::get_singleton())
+	if (OS::get_singleton()) {
 		_last_mix_time = OS::get_singleton()->get_ticks_usec();
+	}
 }
 
 double AudioDriver::get_time_since_last_mix() const {
@@ -340,23 +343,26 @@ void AudioServer::_mix_step() {
 		//process effects
 		if (!bus->bypass) {
 			for (int j = 0; j < bus->effects.size(); j++) {
-				if (!bus->effects[j].enabled)
+				if (!bus->effects[j].enabled) {
 					continue;
+				}
 
 #ifdef DEBUG_ENABLED
 				uint64_t ticks = OS::get_singleton()->get_ticks_usec();
 #endif
 
 				for (int k = 0; k < bus->channels.size(); k++) {
-					if (!(bus->channels[k].active || bus->channels[k].effect_instances[j]->process_silence()))
+					if (!(bus->channels[k].active || bus->channels[k].effect_instances[j]->process_silence())) {
 						continue;
+					}
 					bus->channels.write[k].effect_instances.write[j]->process(bus->channels[k].buffer.ptr(), temp_buffer.write[k].ptrw(), buffer_size);
 				}
 
 				//swap buffers, so internal buffer always has the right data
 				for (int k = 0; k < bus->channels.size(); k++) {
-					if (!(buses[i]->channels[k].active || bus->channels[k].effect_instances[j]->process_silence()))
+					if (!(buses[i]->channels[k].active || bus->channels[k].effect_instances[j]->process_silence())) {
 						continue;
+					}
 					SWAP(bus->channels.write[k].buffer, temp_buffer.write[k]);
 				}
 
@@ -383,8 +389,9 @@ void AudioServer::_mix_step() {
 		}
 
 		for (int k = 0; k < bus->channels.size(); k++) {
-			if (!bus->channels[k].active)
+			if (!bus->channels[k].active) {
 				continue;
+			}
 
 			AudioFrame *buf = bus->channels.write[k].buffer.ptrw();
 
@@ -445,10 +452,12 @@ void AudioServer::_mix_step() {
 }
 
 bool AudioServer::thread_has_channel_mix_buffer(int p_bus, int p_buffer) const {
-	if (p_bus < 0 || p_bus >= buses.size())
+	if (p_bus < 0 || p_bus >= buses.size()) {
 		return false;
-	if (p_buffer < 0 || p_buffer >= buses[p_bus]->channels.size())
+	}
+	if (p_buffer < 0 || p_buffer >= buses[p_bus]->channels.size()) {
 		return false;
+	}
 	return true;
 }
 
@@ -563,10 +572,11 @@ void AudioServer::add_bus(int p_at_pos) {
 	if (p_at_pos >= buses.size()) {
 		p_at_pos = -1;
 	} else if (p_at_pos == 0) {
-		if (buses.size() > 1)
+		if (buses.size() > 1) {
 			p_at_pos = 1;
-		else
+		} else {
 			p_at_pos = -1;
+		}
 	}
 
 	String attempt = "New Bus";
@@ -601,10 +611,11 @@ void AudioServer::add_bus(int p_at_pos) {
 
 	bus_map[attempt] = bus;
 
-	if (p_at_pos == -1)
+	if (p_at_pos == -1) {
 		buses.push_back(bus);
-	else
+	} else {
 		buses.insert(p_at_pos, bus);
+	}
 
 	emit_signal("bus_layout_changed");
 }
@@ -615,8 +626,9 @@ void AudioServer::move_bus(int p_bus, int p_to_pos) {
 
 	MARK_EDITED
 
-	if (p_bus == p_to_pos)
+	if (p_bus == p_to_pos) {
 		return;
+	}
 
 	Bus *bus = buses[p_bus];
 	buses.remove(p_bus);
@@ -638,8 +650,9 @@ int AudioServer::get_bus_count() const {
 
 void AudioServer::set_bus_name(int p_bus, const String &p_name) {
 	ERR_FAIL_INDEX(p_bus, buses.size());
-	if (p_bus == 0 && p_name != "Master")
+	if (p_bus == 0 && p_name != "Master") {
 		return; //bus 0 is always master
+	}
 
 	MARK_EDITED
 
@@ -923,8 +936,9 @@ void AudioServer::init() {
 	set_bus_count(1);
 	set_bus_name(0, "Master");
 
-	if (AudioDriver::get_singleton())
+	if (AudioDriver::get_singleton()) {
 		AudioDriver::get_singleton()->start();
+	}
 
 #ifdef TOOLS_ENABLED
 	set_edited(false); //avoid editors from thinking this was edited
@@ -942,28 +956,33 @@ void AudioServer::update() {
 		uint64_t server_time = prof_time;
 
 		// Subtract the server time from the driver time
-		if (driver_time > server_time)
+		if (driver_time > server_time) {
 			driver_time -= server_time;
+		}
 
 		Array values;
 
 		for (int i = buses.size() - 1; i >= 0; i--) {
 			Bus *bus = buses[i];
-			if (bus->bypass)
+			if (bus->bypass) {
 				continue;
+			}
 
 			for (int j = 0; j < bus->effects.size(); j++) {
-				if (!bus->effects[j].enabled)
+				if (!bus->effects[j].enabled) {
 					continue;
+				}
 
 				values.push_back(String(bus->name) + bus->effects[j].effect->get_name());
 				values.push_back(USEC_TO_SEC(bus->effects[j].prof_time));
 
 				// Subtract the effect time from the driver and server times
-				if (driver_time > bus->effects[j].prof_time)
+				if (driver_time > bus->effects[j].prof_time) {
 					driver_time -= bus->effects[j].prof_time;
-				if (server_time > bus->effects[j].prof_time)
+				}
+				if (server_time > bus->effects[j].prof_time) {
 					server_time -= bus->effects[j].prof_time;
+				}
 			}
 		}
 
@@ -979,12 +998,14 @@ void AudioServer::update() {
 	// Reset profiling times
 	for (int i = buses.size() - 1; i >= 0; i--) {
 		Bus *bus = buses[i];
-		if (bus->bypass)
+		if (bus->bypass) {
 			continue;
+		}
 
 		for (int j = 0; j < bus->effects.size(); j++) {
-			if (!bus->effects[j].enabled)
+			if (!bus->effects[j].enabled) {
 				continue;
+			}
 
 			bus->effects.write[j].prof_time = 0;
 		}
@@ -1348,8 +1369,9 @@ bool AudioBusLayout::_get(const StringName &p_name, Variant &r_ret) const {
 	String s = p_name;
 	if (s.begins_with("bus/")) {
 		int index = s.get_slice("/", 1).to_int();
-		if (index < 0 || index >= buses.size())
+		if (index < 0 || index >= buses.size()) {
 			return false;
+		}
 
 		const Bus &bus = buses[index];
 

servers/physics_2d/area_2d_sw.cpp

@@ -47,13 +47,15 @@ Area2DSW::BodyKey::BodyKey(Area2DSW *p_body, uint32_t p_body_shape, uint32_t p_a
 }
 
 void Area2DSW::_shapes_changed() {
-	if (!moved_list.in_list() && get_space())
+	if (!moved_list.in_list() && get_space()) {
 		get_space()->area_add_to_moved_list(&moved_list);
+	}
 }
 
 void Area2DSW::set_transform(const Transform2D &p_transform) {
-	if (!moved_list.in_list() && get_space())
+	if (!moved_list.in_list() && get_space()) {
 		get_space()->area_add_to_moved_list(&moved_list);
+	}
 
 	_set_transform(p_transform);
 	_set_inv_transform(p_transform.affine_inverse());
@@ -61,10 +63,12 @@ void Area2DSW::set_transform(const Transform2D &p_transform) {
 
 void Area2DSW::set_space(Space2DSW *p_space) {
 	if (get_space()) {
-		if (monitor_query_list.in_list())
+		if (monitor_query_list.in_list()) {
 			get_space()->area_remove_from_monitor_query_list(&monitor_query_list);
-		if (moved_list.in_list())
+		}
+		if (moved_list.in_list()) {
 			get_space()->area_remove_from_moved_list(&moved_list);
+		}
 	}
 
 	monitored_bodies.clear();
@@ -89,8 +93,9 @@ void Area2DSW::set_monitor_callback(ObjectID p_id, const StringName &p_method) {
 
 	_shape_changed();
 
-	if (!moved_list.in_list() && get_space())
+	if (!moved_list.in_list() && get_space()) {
 		get_space()->area_add_to_moved_list(&moved_list);
+	}
 }
 
 void Area2DSW::set_area_monitor_callback(ObjectID p_id, const StringName &p_method) {
@@ -109,14 +114,16 @@ void Area2DSW::set_area_monitor_callback(ObjectID p_id, const StringName &p_meth
 
 	_shape_changed();
 
-	if (!moved_list.in_list() && get_space())
+	if (!moved_list.in_list() && get_space()) {
 		get_space()->area_add_to_moved_list(&moved_list);
+	}
 }
 
 void Area2DSW::set_space_override_mode(PhysicsServer2D::AreaSpaceOverrideMode p_mode) {
 	bool do_override = p_mode != PhysicsServer2D::AREA_SPACE_OVERRIDE_DISABLED;
-	if (do_override == (space_override_mode != PhysicsServer2D::AREA_SPACE_OVERRIDE_DISABLED))
+	if (do_override == (space_override_mode != PhysicsServer2D::AREA_SPACE_OVERRIDE_DISABLED)) {
 		return;
+	}
 	_unregister_shapes();
 	space_override_mode = p_mode;
 	_shape_changed();
@@ -177,13 +184,15 @@ Variant Area2DSW::get_param(PhysicsServer2D::AreaParameter p_param) const {
 void Area2DSW::_queue_monitor_update() {
 	ERR_FAIL_COND(!get_space());
 
-	if (!monitor_query_list.in_list())
+	if (!monitor_query_list.in_list()) {
 		get_space()->area_add_to_monitor_query_list(&monitor_query_list);
+	}
 }
 
 void Area2DSW::set_monitorable(bool p_monitorable) {
-	if (monitorable == p_monitorable)
+	if (monitorable == p_monitorable) {
 		return;
+	}
 
 	monitorable = p_monitorable;
 	_set_static(!monitorable);
@@ -193,8 +202,9 @@ void Area2DSW::call_queries() {
 	if (monitor_callback_id.is_valid() && !monitored_bodies.empty()) {
 		Variant res[5];
 		Variant *resptr[5];
-		for (int i = 0; i < 5; i++)
+		for (int i = 0; i < 5; i++) {
 			resptr[i] = &res[i];
+		}
 
 		Object *obj = ObjectDB::get_instance(monitor_callback_id);
 		if (!obj) {
@@ -204,8 +214,9 @@ void Area2DSW::call_queries() {
 		}
 
 		for (Map<BodyKey, BodyState>::Element *E = monitored_bodies.front(); E; E = E->next()) {
-			if (E->get().state == 0)
+			if (E->get().state == 0) {
 				continue; //nothing happened
+			}
 
 			res[0] = E->get().state > 0 ? PhysicsServer2D::AREA_BODY_ADDED : PhysicsServer2D::AREA_BODY_REMOVED;
 			res[1] = E->key().rid;
@@ -223,8 +234,9 @@ void Area2DSW::call_queries() {
 	if (area_monitor_callback_id.is_valid() && !monitored_areas.empty()) {
 		Variant res[5];
 		Variant *resptr[5];
-		for (int i = 0; i < 5; i++)
+		for (int i = 0; i < 5; i++) {
 			resptr[i] = &res[i];
+		}
 
 		Object *obj = ObjectDB::get_instance(area_monitor_callback_id);
 		if (!obj) {
@@ -234,8 +246,9 @@ void Area2DSW::call_queries() {
 		}
 
 		for (Map<BodyKey, BodyState>::Element *E = monitored_areas.front(); E; E = E->next()) {
-			if (E->get().state == 0)
+			if (E->get().state == 0) {
 				continue; //nothing happened
+			}
 
 			res[0] = E->get().state > 0 ? PhysicsServer2D::AREA_BODY_ADDED : PhysicsServer2D::AREA_BODY_REMOVED;
 			res[1] = E->key().rid;

servers/physics_2d/area_2d_sw.h

@@ -71,10 +71,12 @@ class Area2DSW : public CollisionObject2DSW {
 			if (rid == p_key.rid) {
 				if (body_shape == p_key.body_shape) {
 					return area_shape < p_key.area_shape;
-				} else
+				} else {
 					return body_shape < p_key.body_shape;
-			} else
+				}
+			} else {
 				return rid < p_key.rid;
+			}
 		}
 
 		_FORCE_INLINE_ BodyKey() {}
@@ -166,29 +168,33 @@ public:
 void Area2DSW::add_body_to_query(Body2DSW *p_body, uint32_t p_body_shape, uint32_t p_area_shape) {
 	BodyKey bk(p_body, p_body_shape, p_area_shape);
 	monitored_bodies[bk].inc();
-	if (!monitor_query_list.in_list())
+	if (!monitor_query_list.in_list()) {
 		_queue_monitor_update();
+	}
 }
 
 void Area2DSW::remove_body_from_query(Body2DSW *p_body, uint32_t p_body_shape, uint32_t p_area_shape) {
 	BodyKey bk(p_body, p_body_shape, p_area_shape);
 	monitored_bodies[bk].dec();
-	if (!monitor_query_list.in_list())
+	if (!monitor_query_list.in_list()) {
 		_queue_monitor_update();
+	}
 }
 
 void Area2DSW::add_area_to_query(Area2DSW *p_area, uint32_t p_area_shape, uint32_t p_self_shape) {
 	BodyKey bk(p_area, p_area_shape, p_self_shape);
 	monitored_areas[bk].inc();
-	if (!monitor_query_list.in_list())
+	if (!monitor_query_list.in_list()) {
 		_queue_monitor_update();
+	}
 }
 
 void Area2DSW::remove_area_from_query(Area2DSW *p_area, uint32_t p_area_shape, uint32_t p_self_shape) {
 	BodyKey bk(p_area, p_area_shape, p_self_shape);
 	monitored_areas[bk].dec();
-	if (!monitor_query_list.in_list())
+	if (!monitor_query_list.in_list()) {
 		_queue_monitor_update();
+	}
 }
 
 #endif // AREA_2D_SW_H

servers/physics_2d/area_pair_2d_sw.cpp

@@ -42,16 +42,20 @@ bool AreaPair2DSW::setup(real_t p_step) {
 
 	if (result != colliding) {
 		if (result) {
-			if (area->get_space_override_mode() != PhysicsServer2D::AREA_SPACE_OVERRIDE_DISABLED)
+			if (area->get_space_override_mode() != PhysicsServer2D::AREA_SPACE_OVERRIDE_DISABLED) {
 				body->add_area(area);
-			if (area->has_monitor_callback())
+			}
+			if (area->has_monitor_callback()) {
 				area->add_body_to_query(body, body_shape, area_shape);
+			}
 
 		} else {
-			if (area->get_space_override_mode() != PhysicsServer2D::AREA_SPACE_OVERRIDE_DISABLED)
+			if (area->get_space_override_mode() != PhysicsServer2D::AREA_SPACE_OVERRIDE_DISABLED) {
 				body->remove_area(area);
-			if (area->has_monitor_callback())
+			}
+			if (area->has_monitor_callback()) {
 				area->remove_body_from_query(body, body_shape, area_shape);
+			}
 		}
 
 		colliding = result;
@@ -71,16 +75,19 @@ AreaPair2DSW::AreaPair2DSW(Body2DSW *p_body, int p_body_shape, Area2DSW *p_area,
 	colliding = false;
 	body->add_constraint(this, 0);
 	area->add_constraint(this);
-	if (p_body->get_mode() == PhysicsServer2D::BODY_MODE_KINEMATIC) //need to be active to process pair
+	if (p_body->get_mode() == PhysicsServer2D::BODY_MODE_KINEMATIC) { //need to be active to process pair
 		p_body->set_active(true);
+	}
 }
 
 AreaPair2DSW::~AreaPair2DSW() {
 	if (colliding) {
-		if (area->get_space_override_mode() != PhysicsServer2D::AREA_SPACE_OVERRIDE_DISABLED)
+		if (area->get_space_override_mode() != PhysicsServer2D::AREA_SPACE_OVERRIDE_DISABLED) {
 			body->remove_area(area);
-		if (area->has_monitor_callback())
+		}
+		if (area->has_monitor_callback()) {
 			area->remove_body_from_query(body, body_shape, area_shape);
+		}
 	}
 	body->remove_constraint(this);
 	area->remove_constraint(this);
@@ -98,18 +105,22 @@ bool Area2Pair2DSW::setup(real_t p_step) {
 
 	if (result != colliding) {
 		if (result) {
-			if (area_b->has_area_monitor_callback() && area_a->is_monitorable())
+			if (area_b->has_area_monitor_callback() && area_a->is_monitorable()) {
 				area_b->add_area_to_query(area_a, shape_a, shape_b);
+			}
 
-			if (area_a->has_area_monitor_callback() && area_b->is_monitorable())
+			if (area_a->has_area_monitor_callback() && area_b->is_monitorable()) {
 				area_a->add_area_to_query(area_b, shape_b, shape_a);
+			}
 
 		} else {
-			if (area_b->has_area_monitor_callback() && area_a->is_monitorable())
+			if (area_b->has_area_monitor_callback() && area_a->is_monitorable()) {
 				area_b->remove_area_from_query(area_a, shape_a, shape_b);
+			}
 
-			if (area_a->has_area_monitor_callback() && area_b->is_monitorable())
+			if (area_a->has_area_monitor_callback() && area_b->is_monitorable()) {
 				area_a->remove_area_from_query(area_b, shape_b, shape_a);
+			}
 		}
 
 		colliding = result;
@@ -133,11 +144,13 @@ Area2Pair2DSW::Area2Pair2DSW(Area2DSW *p_area_a, int p_shape_a, Area2DSW *p_area
 
 Area2Pair2DSW::~Area2Pair2DSW() {
 	if (colliding) {
-		if (area_b->has_area_monitor_callback())
+		if (area_b->has_area_monitor_callback()) {
 			area_b->remove_area_from_query(area_a, shape_a, shape_b);
+		}
 
-		if (area_a->has_area_monitor_callback())
+		if (area_a->has_area_monitor_callback()) {
 			area_a->remove_area_from_query(area_b, shape_b, shape_a);
+		}
 	}
 
 	area_a->remove_constraint(this);

servers/physics_2d/body_2d_sw.cpp

@@ -34,8 +34,9 @@
 #include "space_2d_sw.h"
 
 void Body2DSW::_update_inertia() {
-	if (!user_inertia && get_space() && !inertia_update_list.in_list())
+	if (!user_inertia && get_space() && !inertia_update_list.in_list()) {
 		get_space()->body_add_to_inertia_update_list(&inertia_update_list);
+	}
 }
 
 void Body2DSW::update_inertias() {
@@ -74,10 +75,11 @@ void Body2DSW::update_inertias() {
 
 			_inv_inertia = inertia > 0 ? (1.0 / inertia) : 0;
 
-			if (mass)
+			if (mass) {
 				_inv_mass = 1.0 / mass;
-			else
+			} else {
 				_inv_mass = 0;
+			}
 
 		} break;
 		case PhysicsServer2D::BODY_MODE_KINEMATIC:
@@ -97,18 +99,22 @@ void Body2DSW::update_inertias() {
 }
 
 void Body2DSW::set_active(bool p_active) {
-	if (active == p_active)
+	if (active == p_active) {
 		return;
+	}
 
 	active = p_active;
 	if (!p_active) {
-		if (get_space())
+		if (get_space()) {
 			get_space()->body_remove_from_active_list(&active_list);
+		}
 	} else {
-		if (mode == PhysicsServer2D::BODY_MODE_STATIC)
+		if (mode == PhysicsServer2D::BODY_MODE_STATIC) {
 			return; //static bodies can't become active
-		if (get_space())
+		}
+		if (get_space()) {
 			get_space()->body_add_to_active_list(&active_list);
+		}
 
 		//still_time=0;
 	}
@@ -265,8 +271,9 @@ void Body2DSW::set_state(PhysicsServer2D::BodyState p_state, const Variant &p_va
 				Transform2D t = p_variant;
 				t.orthonormalize();
 				new_transform = get_transform(); //used as old to compute motion
-				if (t == new_transform)
+				if (t == new_transform) {
 					break;
+				}
 				_set_transform(t);
 				_set_inv_transform(get_transform().inverse());
 			}
@@ -293,8 +300,9 @@ void Body2DSW::set_state(PhysicsServer2D::BodyState p_state, const Variant &p_va
 		} break;
 		case PhysicsServer2D::BODY_STATE_SLEEPING: {
 			//?
-			if (mode == PhysicsServer2D::BODY_MODE_STATIC || mode == PhysicsServer2D::BODY_MODE_KINEMATIC)
+			if (mode == PhysicsServer2D::BODY_MODE_STATIC || mode == PhysicsServer2D::BODY_MODE_KINEMATIC) {
 				break;
+			}
 			bool do_sleep = p_variant;
 			if (do_sleep) {
 				linear_velocity = Vector2();
@@ -303,14 +311,16 @@ void Body2DSW::set_state(PhysicsServer2D::BodyState p_state, const Variant &p_va
 				//biased_angular_velocity=Vector3();
 				set_active(false);
 			} else {
-				if (mode != PhysicsServer2D::BODY_MODE_STATIC)
+				if (mode != PhysicsServer2D::BODY_MODE_STATIC) {
 					set_active(true);
+				}
 			}
 		} break;
 		case PhysicsServer2D::BODY_STATE_CAN_SLEEP: {
 			can_sleep = p_variant;
-			if (mode == PhysicsServer2D::BODY_MODE_RIGID && !active && !can_sleep)
+			if (mode == PhysicsServer2D::BODY_MODE_RIGID && !active && !can_sleep) {
 				set_active(true);
+			}
 
 		} break;
 	}
@@ -342,20 +352,24 @@ void Body2DSW::set_space(Space2DSW *p_space) {
 	if (get_space()) {
 		wakeup_neighbours();
 
-		if (inertia_update_list.in_list())
+		if (inertia_update_list.in_list()) {
 			get_space()->body_remove_from_inertia_update_list(&inertia_update_list);
-		if (active_list.in_list())
+		}
+		if (active_list.in_list()) {
 			get_space()->body_remove_from_active_list(&active_list);
-		if (direct_state_query_list.in_list())
+		}
+		if (direct_state_query_list.in_list()) {
 			get_space()->body_remove_from_state_query_list(&direct_state_query_list);
+		}
 	}
 
 	_set_space(p_space);
 
 	if (get_space()) {
 		_update_inertia();
-		if (active)
+		if (active) {
 			get_space()->body_add_to_active_list(&active_list);
+		}
 		/*
 		_update_queries();
 		if (is_active()) {
@@ -385,8 +399,9 @@ void Body2DSW::_compute_area_gravity_and_dampenings(const Area2DSW *p_area) {
 }
 
 void Body2DSW::integrate_forces(real_t p_step) {
-	if (mode == PhysicsServer2D::BODY_MODE_STATIC)
+	if (mode == PhysicsServer2D::BODY_MODE_STATIC) {
 		return;
+	}
 
 	Area2DSW *def_area = get_space()->get_default_area();
 	// Area2DSW *damp_area = def_area;
@@ -428,15 +443,17 @@ void Body2DSW::integrate_forces(real_t p_step) {
 	gravity *= gravity_scale;
 
 	// If less than 0, override dampenings with that of the Body2D
-	if (angular_damp >= 0)
+	if (angular_damp >= 0) {
 		area_angular_damp = angular_damp;
+	}
 	/*
 	else
 		area_angular_damp=damp_area->get_angular_damp();
 	*/
 
-	if (linear_damp >= 0)
+	if (linear_damp >= 0) {
 		area_linear_damp = linear_damp;
+	}
 	/*
 	else
 		area_linear_damp=damp_area->get_linear_damp();
@@ -472,13 +489,15 @@ void Body2DSW::integrate_forces(real_t p_step) {
 
 			real_t damp = 1.0 - p_step * area_linear_damp;
 
-			if (damp < 0) // reached zero in the given time
+			if (damp < 0) { // reached zero in the given time
 				damp = 0;
+			}
 
 			real_t angular_damp = 1.0 - p_step * area_angular_damp;
 
-			if (angular_damp < 0) // reached zero in the given time
+			if (angular_damp < 0) { // reached zero in the given time
 				angular_damp = 0;
+			}
 
 			linear_velocity *= damp;
 			angular_velocity *= angular_damp;
@@ -509,17 +528,20 @@ void Body2DSW::integrate_forces(real_t p_step) {
 }
 
 void Body2DSW::integrate_velocities(real_t p_step) {
-	if (mode == PhysicsServer2D::BODY_MODE_STATIC)
+	if (mode == PhysicsServer2D::BODY_MODE_STATIC) {
 		return;
+	}
 
-	if (fi_callback)
+	if (fi_callback) {
 		get_space()->body_add_to_state_query_list(&direct_state_query_list);
+	}
 
 	if (mode == PhysicsServer2D::BODY_MODE_KINEMATIC) {
 		_set_transform(new_transform, false);
 		_set_inv_transform(new_transform.affine_inverse());
-		if (contacts.size() == 0 && linear_velocity == Vector2() && angular_velocity == 0)
+		if (contacts.size() == 0 && linear_velocity == Vector2() && angular_velocity == 0) {
 			set_active(false); //stopped moving, deactivate
+		}
 		return;
 	}
 
@@ -532,8 +554,9 @@ void Body2DSW::integrate_velocities(real_t p_step) {
 	_set_transform(Transform2D(angle, pos), continuous_cd_mode == PhysicsServer2D::CCD_MODE_DISABLED);
 	_set_inv_transform(get_transform().inverse());
 
-	if (continuous_cd_mode != PhysicsServer2D::CCD_MODE_DISABLED)
+	if (continuous_cd_mode != PhysicsServer2D::CCD_MODE_DISABLED) {
 		new_transform = get_transform();
+	}
 
 	//_update_inertia_tensor();
 }
@@ -545,14 +568,17 @@ void Body2DSW::wakeup_neighbours() {
 		int bc = c->get_body_count();
 
 		for (int i = 0; i < bc; i++) {
-			if (i == E->get())
+			if (i == E->get()) {
 				continue;
+			}
 			Body2DSW *b = n[i];
-			if (b->mode != PhysicsServer2D::BODY_MODE_RIGID)
+			if (b->mode != PhysicsServer2D::BODY_MODE_RIGID) {
 				continue;
+			}
 
-			if (!b->is_active())
+			if (!b->is_active()) {
 				b->set_active(true);
+			}
 		}
 	}
 }
@@ -581,12 +607,13 @@ void Body2DSW::call_queries() {
 }
 
 bool Body2DSW::sleep_test(real_t p_step) {
-	if (mode == PhysicsServer2D::BODY_MODE_STATIC || mode == PhysicsServer2D::BODY_MODE_KINEMATIC)
+	if (mode == PhysicsServer2D::BODY_MODE_STATIC || mode == PhysicsServer2D::BODY_MODE_KINEMATIC) {
 		return true; //
-	else if (mode == PhysicsServer2D::BODY_MODE_CHARACTER)
+	} else if (mode == PhysicsServer2D::BODY_MODE_CHARACTER) {
 		return !active; // characters and kinematic bodies don't sleep unless asked to sleep
-	else if (!can_sleep)
+	} else if (!can_sleep) {
 		return false;
+	}
 
 	if (Math::abs(angular_velocity) < get_space()->get_body_angular_velocity_sleep_threshold() && Math::abs(linear_velocity.length_squared()) < get_space()->get_body_linear_velocity_sleep_threshold() * get_space()->get_body_linear_velocity_sleep_threshold()) {
 		still_time += p_step;
@@ -650,8 +677,9 @@ Body2DSW::Body2DSW() :
 }
 
 Body2DSW::~Body2DSW() {
-	if (fi_callback)
+	if (fi_callback) {
 		memdelete(fi_callback);
+	}
 }
 
 PhysicsDirectBodyState2DSW *PhysicsDirectBodyState2DSW::singleton = nullptr;

servers/physics_2d/body_2d_sw.h

@@ -146,16 +146,18 @@ public:
 		int index = areas.find(AreaCMP(p_area));
 		if (index > -1) {
 			areas.write[index].refCount -= 1;
-			if (areas[index].refCount < 1)
+			if (areas[index].refCount < 1) {
 				areas.remove(index);
+			}
 		}
 	}
 
 	_FORCE_INLINE_ void set_max_contacts_reported(int p_size) {
 		contacts.resize(p_size);
 		contact_count = 0;
-		if (mode == PhysicsServer2D::BODY_MODE_KINEMATIC && p_size)
+		if (mode == PhysicsServer2D::BODY_MODE_KINEMATIC && p_size) {
 			set_active(true);
+		}
 	}
 
 	_FORCE_INLINE_ int get_max_contacts_reported() const { return contacts.size(); }
@@ -219,8 +221,9 @@ public:
 	_FORCE_INLINE_ bool is_active() const { return active; }
 
 	_FORCE_INLINE_ void wakeup() {
-		if ((!get_space()) || mode == PhysicsServer2D::BODY_MODE_STATIC || mode == PhysicsServer2D::BODY_MODE_KINEMATIC)
+		if ((!get_space()) || mode == PhysicsServer2D::BODY_MODE_STATIC || mode == PhysicsServer2D::BODY_MODE_KINEMATIC) {
 			return;
+		}
 		set_active(true);
 	}
 
@@ -293,8 +296,9 @@ public:
 void Body2DSW::add_contact(const Vector2 &p_local_pos, const Vector2 &p_local_normal, real_t p_depth, int p_local_shape, const Vector2 &p_collider_pos, int p_collider_shape, ObjectID p_collider_instance_id, const RID &p_collider, const Vector2 &p_collider_velocity_at_pos) {
 	int c_max = contacts.size();
 
-	if (c_max == 0)
+	if (c_max == 0) {
 		return;
+	}
 
 	Contact *c = contacts.ptrw();
 
@@ -315,8 +319,9 @@ void Body2DSW::add_contact(const Vector2 &p_local_pos, const Vector2 &p_local_no
 		if (least_deep >= 0 && least_depth < p_depth) {
 			idx = least_deep;
 		}
-		if (idx == -1)
+		if (idx == -1) {
 			return; //none least deepe than this
+		}
 	}
 
 	c[idx].local_pos = p_local_pos;

servers/physics_2d/body_pair_2d_sw.cpp

@@ -161,8 +161,9 @@ void BodyPair2DSW::_validate_contacts() {
 bool BodyPair2DSW::_test_ccd(real_t p_step, Body2DSW *p_A, int p_shape_A, const Transform2D &p_xform_A, Body2DSW *p_B, int p_shape_B, const Transform2D &p_xform_B, bool p_swap_result) {
 	Vector2 motion = p_A->get_linear_velocity() * p_step;
 	real_t mlen = motion.length();
-	if (mlen < CMP_EPSILON)
+	if (mlen < CMP_EPSILON) {
 		return false;
+	}
 
 	Vector2 mnormal = motion / mlen;
 
@@ -188,8 +189,9 @@ bool BodyPair2DSW::_test_ccd(real_t p_step, Body2DSW *p_A, int p_shape_A, const
 	Vector2 local_to = from_inv.xform(to);
 
 	Vector2 rpos, rnorm;
-	if (!p_B->get_shape(p_shape_B)->intersect_segment(local_from, local_to, rpos, rnorm))
+	if (!p_B->get_shape(p_shape_B)->intersect_segment(local_from, local_to, rpos, rnorm)) {
 		return false;
+	}
 
 	//ray hit something
 
@@ -200,10 +202,11 @@ bool BodyPair2DSW::_test_ccd(real_t p_step, Body2DSW *p_A, int p_shape_A, const
 
 	//create a contact
 
-	if (p_swap_result)
+	if (p_swap_result) {
 		_contact_added_callback(contact_B, contact_A);
-	else
+	} else {
 		_contact_added_callback(contact_A, contact_B);
+	}
 
 	return true;
 }
@@ -261,13 +264,15 @@ bool BodyPair2DSW::setup(real_t p_step) {
 		//test ccd (currently just a raycast)
 
 		if (A->get_continuous_collision_detection_mode() == PhysicsServer2D::CCD_MODE_CAST_RAY && A->get_mode() > PhysicsServer2D::BODY_MODE_KINEMATIC) {
-			if (_test_ccd(p_step, A, shape_A, xform_A, B, shape_B, xform_B))
+			if (_test_ccd(p_step, A, shape_A, xform_A, B, shape_B, xform_B)) {
 				collided = true;
+			}
 		}
 
 		if (B->get_continuous_collision_detection_mode() == PhysicsServer2D::CCD_MODE_CAST_RAY && B->get_mode() > PhysicsServer2D::BODY_MODE_KINEMATIC) {
-			if (_test_ccd(p_step, B, shape_B, xform_B, A, shape_A, xform_A, true))
+			if (_test_ccd(p_step, B, shape_B, xform_B, A, shape_A, xform_A, true)) {
 				collided = true;
+			}
 		}
 
 		if (!collided) {
@@ -276,8 +281,9 @@ bool BodyPair2DSW::setup(real_t p_step) {
 		}
 	}
 
-	if (oneway_disabled)
+	if (oneway_disabled) {
 		return false;
+	}
 
 	//if (!prev_collided) {
 	{
@@ -287,10 +293,12 @@ bool BodyPair2DSW::setup(real_t p_step) {
 			if (B->get_linear_velocity().dot(direction) >= 0) {
 				for (int i = 0; i < contact_count; i++) {
 					Contact &c = contacts[i];
-					if (!c.reused)
+					if (!c.reused) {
 						continue;
-					if (c.normal.dot(direction) > 0) //greater (normal inverted)
+					}
+					if (c.normal.dot(direction) > 0) { //greater (normal inverted)
 						continue;
+					}
 
 					valid = true;
 					break;
@@ -310,10 +318,12 @@ bool BodyPair2DSW::setup(real_t p_step) {
 			if (A->get_linear_velocity().dot(direction) >= 0) {
 				for (int i = 0; i < contact_count; i++) {
 					Contact &c = contacts[i];
-					if (!c.reused)
+					if (!c.reused) {
 						continue;
-					if (c.normal.dot(direction) < 0) //less (normal ok)
+					}
+					if (c.normal.dot(direction) < 0) { //less (normal ok)
 						continue;
+					}
 
 					valid = true;
 					break;
@@ -331,12 +341,13 @@ bool BodyPair2DSW::setup(real_t p_step) {
 
 	real_t bias = 0.3;
 	if (shape_A_ptr->get_custom_bias() || shape_B_ptr->get_custom_bias()) {
-		if (shape_A_ptr->get_custom_bias() == 0)
+		if (shape_A_ptr->get_custom_bias() == 0) {
 			bias = shape_B_ptr->get_custom_bias();
-		else if (shape_B_ptr->get_custom_bias() == 0)
+		} else if (shape_B_ptr->get_custom_bias() == 0) {
 			bias = shape_A_ptr->get_custom_bias();
-		else
+		} else {
 			bias = (shape_B_ptr->get_custom_bias() + shape_A_ptr->get_custom_bias()) * 0.5;
+		}
 	}
 
 	cc = 0;
@@ -437,15 +448,17 @@ bool BodyPair2DSW::setup(real_t p_step) {
 }
 
 void BodyPair2DSW::solve(real_t p_step) {
-	if (!collided)
+	if (!collided) {
 		return;
+	}
 
 	for (int i = 0; i < contact_count; ++i) {
 		Contact &c = contacts[i];
 		cc++;
 
-		if (!c.active)
+		if (!c.active) {
 			continue;
+		}
 
 		// Relative velocity at contact
 

servers/physics_2d/broad_phase_2d_basic.cpp

@@ -87,8 +87,9 @@ int BroadPhase2DBasic::cull_segment(const Vector2 &p_from, const Vector2 &p_to,
 			p_results[rc] = E->get().owner;
 			p_result_indices[rc] = E->get().subindex;
 			rc++;
-			if (rc >= p_max_results)
+			if (rc >= p_max_results) {
 				break;
+			}
 		}
 	}
 
@@ -104,8 +105,9 @@ int BroadPhase2DBasic::cull_aabb(const Rect2 &p_aabb, CollisionObject2DSW **p_re
 			p_results[rc] = E->get().owner;
 			p_result_indices[rc] = E->get().subindex;
 			rc++;
-			if (rc >= p_max_results)
+			if (rc >= p_max_results) {
 				break;
+			}
 		}
 	}
 
@@ -129,8 +131,9 @@ void BroadPhase2DBasic::update() {
 			Element *elem_A = &I->get();
 			Element *elem_B = &J->get();
 
-			if (elem_A->owner == elem_B->owner)
+			if (elem_A->owner == elem_B->owner) {
 				continue;
+			}
 
 			bool pair_ok = elem_A->aabb.intersects(elem_B->aabb) && (!elem_A->_static || !elem_B->_static);
 
@@ -139,15 +142,17 @@ void BroadPhase2DBasic::update() {
 			Map<PairKey, void *>::Element *E = pair_map.find(key);
 
 			if (!pair_ok && E) {
-				if (unpair_callback)
+				if (unpair_callback) {
 					unpair_callback(elem_A->owner, elem_A->subindex, elem_B->owner, elem_B->subindex, E->get(), unpair_userdata);
+				}
 				pair_map.erase(key);
 			}
 
 			if (pair_ok && !E) {
 				void *data = nullptr;
-				if (pair_callback)
+				if (pair_callback) {
 					data = pair_callback(elem_A->owner, elem_A->subindex, elem_B->owner, elem_B->subindex, unpair_userdata);
+				}
 				pair_map.insert(key, data);
 			}
 		}

servers/physics_2d/broad_phase_2d_hash_grid.cpp

@@ -93,12 +93,15 @@ void BroadPhase2DHashGrid::_enter_grid(Element *p_elem, const Rect2 &p_rect, boo
 	if (sz.width * sz.height > large_object_min_surface) {
 		//large object, do not use grid, must check against all elements
 		for (Map<ID, Element>::Element *E = element_map.front(); E; E = E->next()) {
-			if (E->key() == p_elem->self)
+			if (E->key() == p_elem->self) {
 				continue; // do not pair against itself
-			if (E->get().owner == p_elem->owner)
+			}
+			if (E->get().owner == p_elem->owner) {
 				continue;
-			if (E->get()._static && p_static)
+			}
+			if (E->get()._static && p_static) {
 				continue;
+			}
 
 			_pair_attempt(p_elem, &E->get());
 		}
@@ -149,15 +152,17 @@ void BroadPhase2DHashGrid::_enter_grid(Element *p_elem, const Rect2 &p_rect, boo
 
 			if (entered) {
 				for (Map<Element *, RC>::Element *E = pb->object_set.front(); E; E = E->next()) {
-					if (E->key()->owner == p_elem->owner)
+					if (E->key()->owner == p_elem->owner) {
 						continue;
+					}
 					_pair_attempt(p_elem, E->key());
 				}
 
 				if (!p_static) {
 					for (Map<Element *, RC>::Element *E = pb->static_object_set.front(); E; E = E->next()) {
-						if (E->key()->owner == p_elem->owner)
+						if (E->key()->owner == p_elem->owner) {
 							continue;
+						}
 						_pair_attempt(p_elem, E->key());
 					}
 				}
@@ -168,12 +173,15 @@ void BroadPhase2DHashGrid::_enter_grid(Element *p_elem, const Rect2 &p_rect, boo
 	//pair separatedly with large elements
 
 	for (Map<Element *, RC>::Element *E = large_elements.front(); E; E = E->next()) {
-		if (E->key() == p_elem)
+		if (E->key() == p_elem) {
 			continue; // do not pair against itself
-		if (E->key()->owner == p_elem->owner)
+		}
+		if (E->key()->owner == p_elem->owner) {
 			continue;
-		if (E->key()->_static && p_static)
+		}
+		if (E->key()->_static && p_static) {
 			continue;
+		}
 
 		_pair_attempt(E->key(), p_elem);
 	}
@@ -234,15 +242,17 @@ void BroadPhase2DHashGrid::_exit_grid(Element *p_elem, const Rect2 &p_rect, bool
 
 			if (exited) {
 				for (Map<Element *, RC>::Element *E = pb->object_set.front(); E; E = E->next()) {
-					if (E->key()->owner == p_elem->owner)
+					if (E->key()->owner == p_elem->owner) {
 						continue;
+					}
 					_unpair_attempt(p_elem, E->key());
 				}
 
 				if (!p_static) {
 					for (Map<Element *, RC>::Element *E = pb->static_object_set.front(); E; E = E->next()) {
-						if (E->key()->owner == p_elem->owner)
+						if (E->key()->owner == p_elem->owner) {
 							continue;
+						}
 						_unpair_attempt(p_elem, E->key());
 					}
 				}
@@ -272,12 +282,15 @@ void BroadPhase2DHashGrid::_exit_grid(Element *p_elem, const Rect2 &p_rect, bool
 	}
 
 	for (Map<Element *, RC>::Element *E = large_elements.front(); E; E = E->next()) {
-		if (E->key() == p_elem)
+		if (E->key() == p_elem) {
 			continue; // do not pair against itself
-		if (E->key()->owner == p_elem->owner)
+		}
+		if (E->key()->owner == p_elem->owner) {
 			continue;
-		if (E->key()->_static && p_static)
+		}
+		if (E->key()->_static && p_static) {
 			continue;
+		}
 
 		//unpair from large elements
 		_unpair_attempt(p_elem, E->key());
@@ -304,8 +317,9 @@ void BroadPhase2DHashGrid::move(ID p_id, const Rect2 &p_aabb) {
 
 	Element &e = E->get();
 
-	if (p_aabb == e.aabb)
+	if (p_aabb == e.aabb) {
 		return;
+	}
 
 	if (p_aabb != Rect2()) {
 		_enter_grid(&e, p_aabb, e._static);
@@ -328,11 +342,13 @@ void BroadPhase2DHashGrid::set_static(ID p_id, bool p_static) {
 
 	Element &e = E->get();
 
-	if (e._static == p_static)
+	if (e._static == p_static) {
 		return;
+	}
 
-	if (e.aabb != Rect2())
+	if (e.aabb != Rect2()) {
 		_exit_grid(&e, e.aabb, e._static);
+	}
 
 	e._static = p_static;
 
@@ -348,8 +364,9 @@ void BroadPhase2DHashGrid::remove(ID p_id) {
 
 	Element &e = E->get();
 
-	if (e.aabb != Rect2())
+	if (e.aabb != Rect2()) {
 		_exit_grid(&e, e.aabb, e._static);
+	}
 
 	element_map.erase(p_id);
 }
@@ -389,22 +406,27 @@ void BroadPhase2DHashGrid::_cull(const Point2i p_cell, const Rect2 &p_aabb, cons
 		pb = pb->next;
 	}
 
-	if (!pb)
+	if (!pb) {
 		return;
+	}
 
 	for (Map<Element *, RC>::Element *E = pb->object_set.front(); E; E = E->next()) {
-		if (index >= p_max_results)
+		if (index >= p_max_results) {
 			break;
-		if (E->key()->pass == pass)
+		}
+		if (E->key()->pass == pass) {
 			continue;
+		}
 
 		E->key()->pass = pass;
 
-		if (use_aabb && !p_aabb.intersects(E->key()->aabb))
+		if (use_aabb && !p_aabb.intersects(E->key()->aabb)) {
 			continue;
+		}
 
-		if (use_segment && !E->key()->aabb.intersects_segment(p_from, p_to))
+		if (use_segment && !E->key()->aabb.intersects_segment(p_from, p_to)) {
 			continue;
+		}
 
 		p_results[index] = E->key()->owner;
 		p_result_indices[index] = E->key()->subindex;
@@ -412,17 +434,20 @@ void BroadPhase2DHashGrid::_cull(const Point2i p_cell, const Rect2 &p_aabb, cons
 	}
 
 	for (Map<Element *, RC>::Element *E = pb->static_object_set.front(); E; E = E->next()) {
-		if (index >= p_max_results)
+		if (index >= p_max_results) {
 			break;
-		if (E->key()->pass == pass)
+		}
+		if (E->key()->pass == pass) {
 			continue;
+		}
 
 		if (use_aabb && !p_aabb.intersects(E->key()->aabb)) {
 			continue;
 		}
 
-		if (use_segment && !E->key()->aabb.intersects_segment(p_from, p_to))
+		if (use_segment && !E->key()->aabb.intersects_segment(p_from, p_to)) {
 			continue;
+		}
 
 		E->key()->pass = pass;
 		p_results[index] = E->key()->owner;
@@ -435,14 +460,17 @@ int BroadPhase2DHashGrid::cull_segment(const Vector2 &p_from, const Vector2 &p_t
 	pass++;
 
 	Vector2 dir = (p_to - p_from);
-	if (dir == Vector2())
+	if (dir == Vector2()) {
 		return 0;
+	}
 	//avoid divisions by zero
 	dir.normalize();
-	if (dir.x == 0.0)
+	if (dir.x == 0.0) {
 		dir.x = 0.000001;
-	if (dir.y == 0.0)
+	}
+	if (dir.y == 0.0) {
 		dir.y = 0.000001;
+	}
 	Vector2 delta = dir.abs();
 
 	delta.x = cell_size / delta.x;
@@ -455,15 +483,17 @@ int BroadPhase2DHashGrid::cull_segment(const Vector2 &p_from, const Vector2 &p_t
 
 	Vector2 max;
 
-	if (dir.x < 0)
+	if (dir.x < 0) {
 		max.x = (Math::floor((double)pos.x) * cell_size - p_from.x) / dir.x;
-	else
+	} else {
 		max.x = (Math::floor((double)pos.x + 1) * cell_size - p_from.x) / dir.x;
+	}
 
-	if (dir.y < 0)
+	if (dir.y < 0) {
 		max.y = (Math::floor((double)pos.y) * cell_size - p_from.y) / dir.y;
-	else
+	} else {
 		max.y = (Math::floor((double)pos.y + 1) * cell_size - p_from.y) / dir.y;
+	}
 
 	int cullcount = 0;
 	_cull<false, true>(pos, Rect2(), p_from, p_to, p_results, p_max_results, p_result_indices, cullcount);
@@ -481,30 +511,35 @@ int BroadPhase2DHashGrid::cull_segment(const Vector2 &p_from, const Vector2 &p_t
 		}
 
 		if (step.x > 0) {
-			if (pos.x >= end.x)
+			if (pos.x >= end.x) {
 				reached_x = true;
+			}
 		} else if (pos.x <= end.x) {
 			reached_x = true;
 		}
 
 		if (step.y > 0) {
-			if (pos.y >= end.y)
+			if (pos.y >= end.y) {
 				reached_y = true;
+			}
 		} else if (pos.y <= end.y) {
 			reached_y = true;
 		}
 
 		_cull<false, true>(pos, Rect2(), p_from, p_to, p_results, p_max_results, p_result_indices, cullcount);
 
-		if (reached_x && reached_y)
+		if (reached_x && reached_y) {
 			break;
+		}
 	}
 
 	for (Map<Element *, RC>::Element *E = large_elements.front(); E; E = E->next()) {
-		if (cullcount >= p_max_results)
+		if (cullcount >= p_max_results) {
 			break;
-		if (E->key()->pass == pass)
+		}
+		if (E->key()->pass == pass) {
 			continue;
+		}
 
 		E->key()->pass = pass;
 
@@ -513,8 +548,9 @@ int BroadPhase2DHashGrid::cull_segment(const Vector2 &p_from, const Vector2 &p_t
 			continue;
 		*/
 
-		if (!E->key()->aabb.intersects_segment(p_from, p_to))
+		if (!E->key()->aabb.intersects_segment(p_from, p_to)) {
 			continue;
+		}
 
 		p_results[cullcount] = E->key()->owner;
 		p_result_indices[cullcount] = E->key()->subindex;
@@ -538,15 +574,18 @@ int BroadPhase2DHashGrid::cull_aabb(const Rect2 &p_aabb, CollisionObject2DSW **p
 	}
 
 	for (Map<Element *, RC>::Element *E = large_elements.front(); E; E = E->next()) {
-		if (cullcount >= p_max_results)
+		if (cullcount >= p_max_results) {
 			break;
-		if (E->key()->pass == pass)
+		}
+		if (E->key()->pass == pass) {
 			continue;
+		}
 
 		E->key()->pass = pass;
 
-		if (!p_aabb.intersects(E->key()->aabb))
+		if (!p_aabb.intersects(E->key()->aabb)) {
 			continue;
+		}
 
 		/*
 		if (!E->key()->aabb.intersects_segment(p_from,p_to))
@@ -589,8 +628,9 @@ BroadPhase2DHashGrid::BroadPhase2DHashGrid() {
 	large_object_min_surface = GLOBAL_DEF("physics/2d/large_object_surface_threshold_in_cells", 512);
 	ProjectSettings::get_singleton()->set_custom_property_info("physics/2d/large_object_surface_threshold_in_cells", PropertyInfo(Variant::INT, "physics/2d/large_object_surface_threshold_in_cells", PROPERTY_HINT_RANGE, "0,1024,1,or_greater"));
 
-	for (uint32_t i = 0; i < hash_table_size; i++)
+	for (uint32_t i = 0; i < hash_table_size; i++) {
 		hash_table[i] = nullptr;
+	}
 	pass = 1;
 
 	current = 0;

servers/physics_2d/collision_object_2d_sw.cpp

@@ -87,13 +87,15 @@ void CollisionObject2DSW::set_shape_as_disabled(int p_idx, bool p_disabled) {
 	ERR_FAIL_INDEX(p_idx, shapes.size());
 
 	CollisionObject2DSW::Shape &shape = shapes.write[p_idx];
-	if (shape.disabled == p_disabled)
+	if (shape.disabled == p_disabled) {
 		return;
+	}
 
 	shape.disabled = p_disabled;
 
-	if (!space)
+	if (!space) {
 		return;
+	}
 
 	if (p_disabled && shape.bpid != 0) {
 		space->get_broadphase()->remove(shape.bpid);
@@ -124,8 +126,9 @@ void CollisionObject2DSW::remove_shape(int p_index) {
 	//remove anything from shape to be erased to end, so subindices don't change
 	ERR_FAIL_INDEX(p_index, shapes.size());
 	for (int i = p_index; i < shapes.size(); i++) {
-		if (shapes[i].bpid == 0)
+		if (shapes[i].bpid == 0) {
 			continue;
+		}
 		//should never get here with a null owner
 		space->get_broadphase()->remove(shapes[i].bpid);
 		shapes.write[i].bpid = 0;
@@ -141,12 +144,14 @@ void CollisionObject2DSW::remove_shape(int p_index) {
 }
 
 void CollisionObject2DSW::_set_static(bool p_static) {
-	if (_static == p_static)
+	if (_static == p_static) {
 		return;
+	}
 	_static = p_static;
 
-	if (!space)
+	if (!space) {
 		return;
+	}
 	for (int i = 0; i < get_shape_count(); i++) {
 		const Shape &s = shapes[i];
 		if (s.bpid > 0) {
@@ -166,14 +171,16 @@ void CollisionObject2DSW::_unregister_shapes() {
 }
 
 void CollisionObject2DSW::_update_shapes() {
-	if (!space)
+	if (!space) {
 		return;
+	}
 
 	for (int i = 0; i < shapes.size(); i++) {
 		Shape &s = shapes.write[i];
 
-		if (s.disabled)
+		if (s.disabled) {
 			continue;
+		}
 
 		if (s.bpid == 0) {
 			s.bpid = space->get_broadphase()->create(this, i);
@@ -192,13 +199,15 @@ void CollisionObject2DSW::_update_shapes() {
 }
 
 void CollisionObject2DSW::_update_shapes_with_motion(const Vector2 &p_motion) {
-	if (!space)
+	if (!space) {
 		return;
+	}
 
 	for (int i = 0; i < shapes.size(); i++) {
 		Shape &s = shapes.write[i];
-		if (s.disabled)
+		if (s.disabled) {
 			continue;
+		}
 
 		if (s.bpid == 0) {
 			s.bpid = space->get_broadphase()->create(this, i);

servers/physics_2d/collision_solver_2d_sat.cpp

@@ -45,10 +45,11 @@ struct _CollectorCallback2D {
 		if (normal.dot(p_point_A) >= normal.dot(p_point_B))
 			return;
 		*/
-		if (swap)
+		if (swap) {
 			callback(p_point_B, p_point_A, userdata);
-		else
+		} else {
 			callback(p_point_A, p_point_B, userdata);
+		}
 	}
 };
 
@@ -113,14 +114,16 @@ _FORCE_INLINE_ static void _generate_contacts_edge_edge(const Vector2 *p_points_
 		if (dvec[i].a) {
 			Vector2 a = p_points_A[dvec[i].idx];
 			Vector2 b = n.plane_project(dB, a);
-			if (n.dot(a) > n.dot(b) - CMP_EPSILON)
+			if (n.dot(a) > n.dot(b) - CMP_EPSILON) {
 				continue;
+			}
 			p_collector->call(a, b);
 		} else {
 			Vector2 b = p_points_B[dvec[i].idx];
 			Vector2 a = n.plane_project(dA, b);
-			if (n.dot(a) > n.dot(b) - CMP_EPSILON)
+			if (n.dot(a) > n.dot(b) - CMP_EPSILON) {
 				continue;
+			}
 			p_collector->call(a, b);
 		}
 	}
@@ -203,18 +206,22 @@ public:
 	_FORCE_INLINE_ bool test_cast() {
 		if (castA) {
 			Vector2 na = motion_A.normalized();
-			if (!test_axis(na))
+			if (!test_axis(na)) {
 				return false;
-			if (!test_axis(na.tangent()))
+			}
+			if (!test_axis(na.tangent())) {
 				return false;
+			}
 		}
 
 		if (castB) {
 			Vector2 nb = motion_B.normalized();
-			if (!test_axis(nb))
+			if (!test_axis(nb)) {
 				return false;
-			if (!test_axis(nb.tangent()))
+			}
+			if (!test_axis(nb.tangent())) {
 				return false;
+			}
 		}
 
 		return true;
@@ -231,15 +238,17 @@ public:
 
 		real_t min_A, max_A, min_B, max_B;
 
-		if (castA)
+		if (castA) {
 			shape_A->project_range_cast(motion_A, axis, *transform_A, min_A, max_A);
-		else
+		} else {
 			shape_A->project_range(axis, *transform_A, min_A, max_A);
+		}
 
-		if (castB)
+		if (castB) {
 			shape_B->project_range_cast(motion_B, axis, *transform_B, min_B, max_B);
-		else
+		} else {
 			shape_B->project_range(axis, *transform_B, min_B, max_B);
+		}
 
 		if (withMargin) {
 			min_A -= margin_A;
@@ -255,8 +264,9 @@ public:
 		real_t dmax = max_B - (min_A + max_A) * 0.5;
 
 		if (dmin > 0.0 || dmax < 0.0) {
-			if (callback && callback->sep_axis)
+			if (callback && callback->sep_axis) {
 				*callback->sep_axis = axis;
+			}
 #ifdef DEBUG_ENABLED
 			best_axis_count++;
 #endif
@@ -295,14 +305,16 @@ public:
 
 	_FORCE_INLINE_ void generate_contacts() {
 		// nothing to do, don't generate
-		if (best_axis == Vector2(0.0, 0.0))
+		if (best_axis == Vector2(0.0, 0.0)) {
 			return;
+		}
 
 		if (callback) {
 			callback->collided = true;
 
-			if (!callback->callback)
+			if (!callback->callback) {
 				return; //only collide, no callback
+			}
 		}
 		static const int max_supports = 2;
 
@@ -343,8 +355,9 @@ public:
 			callback->normal = best_axis;
 			_generate_contacts_from_supports(supports_A, support_count_A, supports_B, support_count_B, callback);
 
-			if (callback->sep_axis && *callback->sep_axis != Vector2())
+			if (callback->sep_axis && *callback->sep_axis != Vector2()) {
 				*callback->sep_axis = Vector2(); //invalidate previous axis (no test)
+			}
 		}
 	}
 
@@ -384,29 +397,37 @@ static void _collision_segment_segment(const Shape2DSW *p_a, const Transform2D &
 
 	SeparatorAxisTest2D<SegmentShape2DSW, SegmentShape2DSW, castA, castB, withMargin> separator(segment_A, p_transform_a, segment_B, p_transform_b, p_collector, p_motion_a, p_motion_b, p_margin_A, p_margin_B);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 	//this collision is kind of pointless
 
-	if (!separator.test_cast())
+	if (!separator.test_cast()) {
 		return;
+	}
 
-	if (!separator.test_axis(segment_A->get_xformed_normal(p_transform_a)))
+	if (!separator.test_axis(segment_A->get_xformed_normal(p_transform_a))) {
 		return;
-	if (!separator.test_axis(segment_B->get_xformed_normal(p_transform_b)))
+	}
+	if (!separator.test_axis(segment_B->get_xformed_normal(p_transform_b))) {
 		return;
+	}
 
 	if (withMargin) {
 		//points grow to circles
 
-		if (TEST_POINT(p_transform_a.xform(segment_A->get_a()), p_transform_b.xform(segment_B->get_a())))
+		if (TEST_POINT(p_transform_a.xform(segment_A->get_a()), p_transform_b.xform(segment_B->get_a()))) {
 			return;
-		if (TEST_POINT(p_transform_a.xform(segment_A->get_a()), p_transform_b.xform(segment_B->get_b())))
+		}
+		if (TEST_POINT(p_transform_a.xform(segment_A->get_a()), p_transform_b.xform(segment_B->get_b()))) {
 			return;
-		if (TEST_POINT(p_transform_a.xform(segment_A->get_b()), p_transform_b.xform(segment_B->get_a())))
+		}
+		if (TEST_POINT(p_transform_a.xform(segment_A->get_b()), p_transform_b.xform(segment_B->get_a()))) {
 			return;
-		if (TEST_POINT(p_transform_a.xform(segment_A->get_b()), p_transform_b.xform(segment_B->get_b())))
+		}
+		if (TEST_POINT(p_transform_a.xform(segment_A->get_b()), p_transform_b.xform(segment_B->get_b()))) {
 			return;
+		}
 	}
 
 	separator.generate_contacts();
@@ -419,23 +440,28 @@ static void _collision_segment_circle(const Shape2DSW *p_a, const Transform2D &p
 
 	SeparatorAxisTest2D<SegmentShape2DSW, CircleShape2DSW, castA, castB, withMargin> separator(segment_A, p_transform_a, circle_B, p_transform_b, p_collector, p_motion_a, p_motion_b, p_margin_A, p_margin_B);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
-	if (!separator.test_cast())
+	if (!separator.test_cast()) {
 		return;
+	}
 
 	//segment normal
 	if (!separator.test_axis(
-				(p_transform_a.xform(segment_A->get_b()) - p_transform_a.xform(segment_A->get_a())).normalized().tangent()))
+				(p_transform_a.xform(segment_A->get_b()) - p_transform_a.xform(segment_A->get_a())).normalized().tangent())) {
 		return;
+	}
 
 	//endpoint a vs circle
-	if (TEST_POINT(p_transform_a.xform(segment_A->get_a()), p_transform_b.get_origin()))
+	if (TEST_POINT(p_transform_a.xform(segment_A->get_a()), p_transform_b.get_origin())) {
 		return;
+	}
 	//endpoint b vs circle
-	if (TEST_POINT(p_transform_a.xform(segment_A->get_b()), p_transform_b.get_origin()))
+	if (TEST_POINT(p_transform_a.xform(segment_A->get_b()), p_transform_b.get_origin())) {
 		return;
+	}
 
 	separator.generate_contacts();
 }
@@ -447,20 +473,25 @@ static void _collision_segment_rectangle(const Shape2DSW *p_a, const Transform2D
 
 	SeparatorAxisTest2D<SegmentShape2DSW, RectangleShape2DSW, castA, castB, withMargin> separator(segment_A, p_transform_a, rectangle_B, p_transform_b, p_collector, p_motion_a, p_motion_b, p_margin_A, p_margin_B);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
-	if (!separator.test_cast())
+	if (!separator.test_cast()) {
 		return;
+	}
 
-	if (!separator.test_axis(segment_A->get_xformed_normal(p_transform_a)))
+	if (!separator.test_axis(segment_A->get_xformed_normal(p_transform_a))) {
 		return;
+	}
 
-	if (!separator.test_axis(p_transform_b.elements[0].normalized()))
+	if (!separator.test_axis(p_transform_b.elements[0].normalized())) {
 		return;
+	}
 
-	if (!separator.test_axis(p_transform_b.elements[1].normalized()))
+	if (!separator.test_axis(p_transform_b.elements[1].normalized())) {
 		return;
+	}
 
 	if (withMargin) {
 		Transform2D inv = p_transform_b.affine_inverse();
@@ -468,30 +499,38 @@ static void _collision_segment_rectangle(const Shape2DSW *p_a, const Transform2D
 		Vector2 a = p_transform_a.xform(segment_A->get_a());
 		Vector2 b = p_transform_a.xform(segment_A->get_b());
 
-		if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, inv, a)))
+		if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, inv, a))) {
 			return;
-		if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, inv, b)))
+		}
+		if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, inv, b))) {
 			return;
+		}
 
 		if (castA) {
-			if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, inv, a + p_motion_a)))
+			if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, inv, a + p_motion_a))) {
 				return;
-			if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, inv, b + p_motion_a)))
+			}
+			if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, inv, b + p_motion_a))) {
 				return;
+			}
 		}
 
 		if (castB) {
-			if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, inv, a - p_motion_b)))
+			if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, inv, a - p_motion_b))) {
 				return;
-			if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, inv, b - p_motion_b)))
+			}
+			if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, inv, b - p_motion_b))) {
 				return;
+			}
 		}
 
 		if (castA && castB) {
-			if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, inv, a - p_motion_b + p_motion_a)))
+			if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, inv, a - p_motion_b + p_motion_a))) {
 				return;
-			if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, inv, b - p_motion_b + p_motion_a)))
+			}
+			if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, inv, b - p_motion_b + p_motion_a))) {
 				return;
+			}
 		}
 	}
 
@@ -505,26 +544,34 @@ static void _collision_segment_capsule(const Shape2DSW *p_a, const Transform2D &
 
 	SeparatorAxisTest2D<SegmentShape2DSW, CapsuleShape2DSW, castA, castB, withMargin> separator(segment_A, p_transform_a, capsule_B, p_transform_b, p_collector, p_motion_a, p_motion_b, p_margin_A, p_margin_B);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
-	if (!separator.test_cast())
+	if (!separator.test_cast()) {
 		return;
+	}
 
-	if (!separator.test_axis(segment_A->get_xformed_normal(p_transform_a)))
+	if (!separator.test_axis(segment_A->get_xformed_normal(p_transform_a))) {
 		return;
+	}
 
-	if (!separator.test_axis(p_transform_b.elements[0].normalized()))
+	if (!separator.test_axis(p_transform_b.elements[0].normalized())) {
 		return;
+	}
 
-	if (TEST_POINT(p_transform_a.xform(segment_A->get_a()), (p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * 0.5)))
+	if (TEST_POINT(p_transform_a.xform(segment_A->get_a()), (p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * 0.5))) {
 		return;
-	if (TEST_POINT(p_transform_a.xform(segment_A->get_a()), (p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * -0.5)))
+	}
+	if (TEST_POINT(p_transform_a.xform(segment_A->get_a()), (p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * -0.5))) {
 		return;
-	if (TEST_POINT(p_transform_a.xform(segment_A->get_b()), (p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * 0.5)))
+	}
+	if (TEST_POINT(p_transform_a.xform(segment_A->get_b()), (p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * 0.5))) {
 		return;
-	if (TEST_POINT(p_transform_a.xform(segment_A->get_b()), (p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * -0.5)))
+	}
+	if (TEST_POINT(p_transform_a.xform(segment_A->get_b()), (p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * -0.5))) {
 		return;
+	}
 
 	separator.generate_contacts();
 }
@@ -536,24 +583,30 @@ static void _collision_segment_convex_polygon(const Shape2DSW *p_a, const Transf
 
 	SeparatorAxisTest2D<SegmentShape2DSW, ConvexPolygonShape2DSW, castA, castB, withMargin> separator(segment_A, p_transform_a, convex_B, p_transform_b, p_collector, p_motion_a, p_motion_b, p_margin_A, p_margin_B);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
-	if (!separator.test_cast())
+	if (!separator.test_cast()) {
 		return;
+	}
 
-	if (!separator.test_axis(segment_A->get_xformed_normal(p_transform_a)))
+	if (!separator.test_axis(segment_A->get_xformed_normal(p_transform_a))) {
 		return;
+	}
 
 	for (int i = 0; i < convex_B->get_point_count(); i++) {
-		if (!separator.test_axis(convex_B->get_xformed_segment_normal(p_transform_b, i)))
+		if (!separator.test_axis(convex_B->get_xformed_segment_normal(p_transform_b, i))) {
 			return;
+		}
 
 		if (withMargin) {
-			if (TEST_POINT(p_transform_a.xform(segment_A->get_a()), p_transform_b.xform(convex_B->get_point(i))))
+			if (TEST_POINT(p_transform_a.xform(segment_A->get_a()), p_transform_b.xform(convex_B->get_point(i)))) {
 				return;
-			if (TEST_POINT(p_transform_a.xform(segment_A->get_b()), p_transform_b.xform(convex_B->get_point(i))))
+			}
+			if (TEST_POINT(p_transform_a.xform(segment_A->get_b()), p_transform_b.xform(convex_B->get_point(i)))) {
 				return;
+			}
 		}
 	}
 
@@ -569,14 +622,17 @@ static void _collision_circle_circle(const Shape2DSW *p_a, const Transform2D &p_
 
 	SeparatorAxisTest2D<CircleShape2DSW, CircleShape2DSW, castA, castB, withMargin> separator(circle_A, p_transform_a, circle_B, p_transform_b, p_collector, p_motion_a, p_motion_b, p_margin_A, p_margin_B);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
-	if (!separator.test_cast())
+	if (!separator.test_cast()) {
 		return;
+	}
 
-	if (TEST_POINT(p_transform_a.get_origin(), p_transform_b.get_origin()))
+	if (TEST_POINT(p_transform_a.get_origin(), p_transform_b.get_origin())) {
 		return;
+	}
 
 	separator.generate_contacts();
 }
@@ -588,44 +644,52 @@ static void _collision_circle_rectangle(const Shape2DSW *p_a, const Transform2D
 
 	SeparatorAxisTest2D<CircleShape2DSW, RectangleShape2DSW, castA, castB, withMargin> separator(circle_A, p_transform_a, rectangle_B, p_transform_b, p_collector, p_motion_a, p_motion_b, p_margin_A, p_margin_B);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
-	if (!separator.test_cast())
+	if (!separator.test_cast()) {
 		return;
+	}
 
 	const Vector2 &sphere = p_transform_a.elements[2];
 	const Vector2 *axis = &p_transform_b.elements[0];
 	//const Vector2& half_extents = rectangle_B->get_half_extents();
 
-	if (!separator.test_axis(axis[0].normalized()))
+	if (!separator.test_axis(axis[0].normalized())) {
 		return;
+	}
 
-	if (!separator.test_axis(axis[1].normalized()))
+	if (!separator.test_axis(axis[1].normalized())) {
 		return;
+	}
 
 	Transform2D binv = p_transform_b.affine_inverse();
 	{
-		if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, binv, sphere)))
+		if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, binv, sphere))) {
 			return;
+		}
 	}
 
 	if (castA) {
 		Vector2 sphereofs = sphere + p_motion_a;
-		if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, binv, sphereofs)))
+		if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, binv, sphereofs))) {
 			return;
+		}
 	}
 
 	if (castB) {
 		Vector2 sphereofs = sphere - p_motion_b;
-		if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, binv, sphereofs)))
+		if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, binv, sphereofs))) {
 			return;
+		}
 	}
 
 	if (castA && castB) {
 		Vector2 sphereofs = sphere - p_motion_b + p_motion_a;
-		if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, binv, sphereofs)))
+		if (!separator.test_axis(rectangle_B->get_circle_axis(p_transform_b, binv, sphereofs))) {
 			return;
+		}
 	}
 
 	separator.generate_contacts();
@@ -638,21 +702,26 @@ static void _collision_circle_capsule(const Shape2DSW *p_a, const Transform2D &p
 
 	SeparatorAxisTest2D<CircleShape2DSW, CapsuleShape2DSW, castA, castB, withMargin> separator(circle_A, p_transform_a, capsule_B, p_transform_b, p_collector, p_motion_a, p_motion_b, p_margin_A, p_margin_B);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
-	if (!separator.test_cast())
+	if (!separator.test_cast()) {
 		return;
+	}
 
 	//capsule axis
-	if (!separator.test_axis(p_transform_b.elements[0].normalized()))
+	if (!separator.test_axis(p_transform_b.elements[0].normalized())) {
 		return;
+	}
 
 	//capsule endpoints
-	if (TEST_POINT(p_transform_a.get_origin(), (p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * 0.5)))
+	if (TEST_POINT(p_transform_a.get_origin(), (p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * 0.5))) {
 		return;
-	if (TEST_POINT(p_transform_a.get_origin(), (p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * -0.5)))
+	}
+	if (TEST_POINT(p_transform_a.get_origin(), (p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * -0.5))) {
 		return;
+	}
 
 	separator.generate_contacts();
 }
@@ -664,19 +733,23 @@ static void _collision_circle_convex_polygon(const Shape2DSW *p_a, const Transfo
 
 	SeparatorAxisTest2D<CircleShape2DSW, ConvexPolygonShape2DSW, castA, castB, withMargin> separator(circle_A, p_transform_a, convex_B, p_transform_b, p_collector, p_motion_a, p_motion_b, p_margin_A, p_margin_B);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
-	if (!separator.test_cast())
+	if (!separator.test_cast()) {
 		return;
+	}
 
 	//poly faces and poly points vs circle
 	for (int i = 0; i < convex_B->get_point_count(); i++) {
-		if (TEST_POINT(p_transform_a.get_origin(), p_transform_b.xform(convex_B->get_point(i))))
+		if (TEST_POINT(p_transform_a.get_origin(), p_transform_b.xform(convex_B->get_point(i)))) {
 			return;
+		}
 
-		if (!separator.test_axis(convex_B->get_xformed_segment_normal(p_transform_b, i)))
+		if (!separator.test_axis(convex_B->get_xformed_segment_normal(p_transform_b, i))) {
 			return;
+		}
 	}
 
 	separator.generate_contacts();
@@ -691,32 +764,39 @@ static void _collision_rectangle_rectangle(const Shape2DSW *p_a, const Transform
 
 	SeparatorAxisTest2D<RectangleShape2DSW, RectangleShape2DSW, castA, castB, withMargin> separator(rectangle_A, p_transform_a, rectangle_B, p_transform_b, p_collector, p_motion_a, p_motion_b, p_margin_A, p_margin_B);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
-	if (!separator.test_cast())
+	if (!separator.test_cast()) {
 		return;
+	}
 
 	//box faces A
-	if (!separator.test_axis(p_transform_a.elements[0].normalized()))
+	if (!separator.test_axis(p_transform_a.elements[0].normalized())) {
 		return;
+	}
 
-	if (!separator.test_axis(p_transform_a.elements[1].normalized()))
+	if (!separator.test_axis(p_transform_a.elements[1].normalized())) {
 		return;
+	}
 
 	//box faces B
-	if (!separator.test_axis(p_transform_b.elements[0].normalized()))
+	if (!separator.test_axis(p_transform_b.elements[0].normalized())) {
 		return;
+	}
 
-	if (!separator.test_axis(p_transform_b.elements[1].normalized()))
+	if (!separator.test_axis(p_transform_b.elements[1].normalized())) {
 		return;
+	}
 
 	if (withMargin) {
 		Transform2D invA = p_transform_a.affine_inverse();
 		Transform2D invB = p_transform_b.affine_inverse();
 
-		if (!separator.test_axis(rectangle_A->get_box_axis(p_transform_a, invA, rectangle_B, p_transform_b, invB)))
+		if (!separator.test_axis(rectangle_A->get_box_axis(p_transform_a, invA, rectangle_B, p_transform_b, invB))) {
 			return;
+		}
 
 		if (castA || castB) {
 			Transform2D aofs = p_transform_a;
@@ -729,18 +809,21 @@ static void _collision_rectangle_rectangle(const Shape2DSW *p_a, const Transform
 			Transform2D bofsinv = bofs.affine_inverse();
 
 			if (castA) {
-				if (!separator.test_axis(rectangle_A->get_box_axis(aofs, aofsinv, rectangle_B, p_transform_b, invB)))
+				if (!separator.test_axis(rectangle_A->get_box_axis(aofs, aofsinv, rectangle_B, p_transform_b, invB))) {
 					return;
+				}
 			}
 
 			if (castB) {
-				if (!separator.test_axis(rectangle_A->get_box_axis(p_transform_a, invA, rectangle_B, bofs, bofsinv)))
+				if (!separator.test_axis(rectangle_A->get_box_axis(p_transform_a, invA, rectangle_B, bofs, bofsinv))) {
 					return;
+				}
 			}
 
 			if (castA && castB) {
-				if (!separator.test_axis(rectangle_A->get_box_axis(aofs, aofsinv, rectangle_B, bofs, bofsinv)))
+				if (!separator.test_axis(rectangle_A->get_box_axis(aofs, aofsinv, rectangle_B, bofs, bofsinv))) {
 					return;
+				}
 			}
 		}
 	}
@@ -755,22 +838,27 @@ static void _collision_rectangle_capsule(const Shape2DSW *p_a, const Transform2D
 
 	SeparatorAxisTest2D<RectangleShape2DSW, CapsuleShape2DSW, castA, castB, withMargin> separator(rectangle_A, p_transform_a, capsule_B, p_transform_b, p_collector, p_motion_a, p_motion_b, p_margin_A, p_margin_B);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
-	if (!separator.test_cast())
+	if (!separator.test_cast()) {
 		return;
+	}
 
 	//box faces
-	if (!separator.test_axis(p_transform_a.elements[0].normalized()))
+	if (!separator.test_axis(p_transform_a.elements[0].normalized())) {
 		return;
+	}
 
-	if (!separator.test_axis(p_transform_a.elements[1].normalized()))
+	if (!separator.test_axis(p_transform_a.elements[1].normalized())) {
 		return;
+	}
 
 	//capsule axis
-	if (!separator.test_axis(p_transform_b.elements[0].normalized()))
+	if (!separator.test_axis(p_transform_b.elements[0].normalized())) {
 		return;
+	}
 
 	//box endpoints to capsule circles
 
@@ -780,24 +868,27 @@ static void _collision_rectangle_capsule(const Shape2DSW *p_a, const Transform2D
 		{
 			Vector2 capsule_endpoint = p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * (i == 0 ? 0.5 : -0.5);
 
-			if (!separator.test_axis(rectangle_A->get_circle_axis(p_transform_a, boxinv, capsule_endpoint)))
+			if (!separator.test_axis(rectangle_A->get_circle_axis(p_transform_a, boxinv, capsule_endpoint))) {
 				return;
+			}
 		}
 
 		if (castA) {
 			Vector2 capsule_endpoint = p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * (i == 0 ? 0.5 : -0.5);
 			capsule_endpoint -= p_motion_a;
 
-			if (!separator.test_axis(rectangle_A->get_circle_axis(p_transform_a, boxinv, capsule_endpoint)))
+			if (!separator.test_axis(rectangle_A->get_circle_axis(p_transform_a, boxinv, capsule_endpoint))) {
 				return;
+			}
 		}
 
 		if (castB) {
 			Vector2 capsule_endpoint = p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * (i == 0 ? 0.5 : -0.5);
 			capsule_endpoint += p_motion_b;
 
-			if (!separator.test_axis(rectangle_A->get_circle_axis(p_transform_a, boxinv, capsule_endpoint)))
+			if (!separator.test_axis(rectangle_A->get_circle_axis(p_transform_a, boxinv, capsule_endpoint))) {
 				return;
+			}
 		}
 
 		if (castA && castB) {
@@ -805,8 +896,9 @@ static void _collision_rectangle_capsule(const Shape2DSW *p_a, const Transform2D
 			capsule_endpoint -= p_motion_a;
 			capsule_endpoint += p_motion_b;
 
-			if (!separator.test_axis(rectangle_A->get_circle_axis(p_transform_a, boxinv, capsule_endpoint)))
+			if (!separator.test_axis(rectangle_A->get_circle_axis(p_transform_a, boxinv, capsule_endpoint))) {
 				return;
+			}
 		}
 	}
 
@@ -820,18 +912,22 @@ static void _collision_rectangle_convex_polygon(const Shape2DSW *p_a, const Tran
 
 	SeparatorAxisTest2D<RectangleShape2DSW, ConvexPolygonShape2DSW, castA, castB, withMargin> separator(rectangle_A, p_transform_a, convex_B, p_transform_b, p_collector, p_motion_a, p_motion_b, p_margin_A, p_margin_B);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
-	if (!separator.test_cast())
+	if (!separator.test_cast()) {
 		return;
+	}
 
 	//box faces
-	if (!separator.test_axis(p_transform_a.elements[0].normalized()))
+	if (!separator.test_axis(p_transform_a.elements[0].normalized())) {
 		return;
+	}
 
-	if (!separator.test_axis(p_transform_a.elements[1].normalized()))
+	if (!separator.test_axis(p_transform_a.elements[1].normalized())) {
 		return;
+	}
 
 	//convex faces
 	Transform2D boxinv;
@@ -839,24 +935,29 @@ static void _collision_rectangle_convex_polygon(const Shape2DSW *p_a, const Tran
 		boxinv = p_transform_a.affine_inverse();
 	}
 	for (int i = 0; i < convex_B->get_point_count(); i++) {
-		if (!separator.test_axis(convex_B->get_xformed_segment_normal(p_transform_b, i)))
+		if (!separator.test_axis(convex_B->get_xformed_segment_normal(p_transform_b, i))) {
 			return;
+		}
 
 		if (withMargin) {
 			//all points vs all points need to be tested if margin exist
-			if (!separator.test_axis(rectangle_A->get_circle_axis(p_transform_a, boxinv, p_transform_b.xform(convex_B->get_point(i)))))
+			if (!separator.test_axis(rectangle_A->get_circle_axis(p_transform_a, boxinv, p_transform_b.xform(convex_B->get_point(i))))) {
 				return;
+			}
 			if (castA) {
-				if (!separator.test_axis(rectangle_A->get_circle_axis(p_transform_a, boxinv, p_transform_b.xform(convex_B->get_point(i)) - p_motion_a)))
+				if (!separator.test_axis(rectangle_A->get_circle_axis(p_transform_a, boxinv, p_transform_b.xform(convex_B->get_point(i)) - p_motion_a))) {
 					return;
+				}
 			}
 			if (castB) {
-				if (!separator.test_axis(rectangle_A->get_circle_axis(p_transform_a, boxinv, p_transform_b.xform(convex_B->get_point(i)) + p_motion_b)))
+				if (!separator.test_axis(rectangle_A->get_circle_axis(p_transform_a, boxinv, p_transform_b.xform(convex_B->get_point(i)) + p_motion_b))) {
 					return;
+				}
 			}
 			if (castA && castB) {
-				if (!separator.test_axis(rectangle_A->get_circle_axis(p_transform_a, boxinv, p_transform_b.xform(convex_B->get_point(i)) + p_motion_b - p_motion_a)))
+				if (!separator.test_axis(rectangle_A->get_circle_axis(p_transform_a, boxinv, p_transform_b.xform(convex_B->get_point(i)) + p_motion_b - p_motion_a))) {
 					return;
+				}
 			}
 		}
 	}
@@ -873,19 +974,23 @@ static void _collision_capsule_capsule(const Shape2DSW *p_a, const Transform2D &
 
 	SeparatorAxisTest2D<CapsuleShape2DSW, CapsuleShape2DSW, castA, castB, withMargin> separator(capsule_A, p_transform_a, capsule_B, p_transform_b, p_collector, p_motion_a, p_motion_b, p_margin_A, p_margin_B);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
-	if (!separator.test_cast())
+	if (!separator.test_cast()) {
 		return;
+	}
 
 	//capsule axis
 
-	if (!separator.test_axis(p_transform_b.elements[0].normalized()))
+	if (!separator.test_axis(p_transform_b.elements[0].normalized())) {
 		return;
+	}
 
-	if (!separator.test_axis(p_transform_a.elements[0].normalized()))
+	if (!separator.test_axis(p_transform_a.elements[0].normalized())) {
 		return;
+	}
 
 	//capsule endpoints
 
@@ -895,8 +1000,9 @@ static void _collision_capsule_capsule(const Shape2DSW *p_a, const Transform2D &
 		for (int j = 0; j < 2; j++) {
 			Vector2 capsule_endpoint_B = p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * (j == 0 ? 0.5 : -0.5);
 
-			if (TEST_POINT(capsule_endpoint_A, capsule_endpoint_B))
+			if (TEST_POINT(capsule_endpoint_A, capsule_endpoint_B)) {
 				return;
+			}
 		}
 	}
 
@@ -910,16 +1016,19 @@ static void _collision_capsule_convex_polygon(const Shape2DSW *p_a, const Transf
 
 	SeparatorAxisTest2D<CapsuleShape2DSW, ConvexPolygonShape2DSW, castA, castB, withMargin> separator(capsule_A, p_transform_a, convex_B, p_transform_b, p_collector, p_motion_a, p_motion_b, p_margin_A, p_margin_B);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
-	if (!separator.test_cast())
+	if (!separator.test_cast()) {
 		return;
+	}
 
 	//capsule axis
 
-	if (!separator.test_axis(p_transform_a.elements[0].normalized()))
+	if (!separator.test_axis(p_transform_a.elements[0].normalized())) {
 		return;
+	}
 
 	//poly vs capsule
 	for (int i = 0; i < convex_B->get_point_count(); i++) {
@@ -928,12 +1037,14 @@ static void _collision_capsule_convex_polygon(const Shape2DSW *p_a, const Transf
 		for (int j = 0; j < 2; j++) {
 			Vector2 capsule_endpoint_A = p_transform_a.get_origin() + p_transform_a.elements[1] * capsule_A->get_height() * (j == 0 ? 0.5 : -0.5);
 
-			if (TEST_POINT(capsule_endpoint_A, cpoint))
+			if (TEST_POINT(capsule_endpoint_A, cpoint)) {
 				return;
+			}
 		}
 
-		if (!separator.test_axis(convex_B->get_xformed_segment_normal(p_transform_b, i)))
+		if (!separator.test_axis(convex_B->get_xformed_segment_normal(p_transform_b, i))) {
 			return;
+		}
 	}
 
 	separator.generate_contacts();
@@ -948,27 +1059,32 @@ static void _collision_convex_polygon_convex_polygon(const Shape2DSW *p_a, const
 
 	SeparatorAxisTest2D<ConvexPolygonShape2DSW, ConvexPolygonShape2DSW, castA, castB, withMargin> separator(convex_A, p_transform_a, convex_B, p_transform_b, p_collector, p_motion_a, p_motion_b, p_margin_A, p_margin_B);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
-	if (!separator.test_cast())
+	if (!separator.test_cast()) {
 		return;
+	}
 
 	for (int i = 0; i < convex_A->get_point_count(); i++) {
-		if (!separator.test_axis(convex_A->get_xformed_segment_normal(p_transform_a, i)))
+		if (!separator.test_axis(convex_A->get_xformed_segment_normal(p_transform_a, i))) {
 			return;
+		}
 	}
 
 	for (int i = 0; i < convex_B->get_point_count(); i++) {
-		if (!separator.test_axis(convex_B->get_xformed_segment_normal(p_transform_b, i)))
+		if (!separator.test_axis(convex_B->get_xformed_segment_normal(p_transform_b, i))) {
 			return;
+		}
 	}
 
 	if (withMargin) {
 		for (int i = 0; i < convex_A->get_point_count(); i++) {
 			for (int j = 0; j < convex_B->get_point_count(); j++) {
-				if (TEST_POINT(p_transform_a.xform(convex_A->get_point(i)), p_transform_b.xform(convex_B->get_point(j))))
+				if (TEST_POINT(p_transform_a.xform(convex_A->get_point(i)), p_transform_b.xform(convex_B->get_point(j)))) {
 					return;
+				}
 			}
 		}
 	}

servers/physics_2d/collision_solver_2d_sw.cpp

@@ -36,8 +36,9 @@
 
 bool CollisionSolver2DSW::solve_static_line(const Shape2DSW *p_shape_A, const Transform2D &p_transform_A, const Shape2DSW *p_shape_B, const Transform2D &p_transform_B, CallbackResult p_result_callback, void *p_userdata, bool p_swap_result) {
 	const LineShape2DSW *line = static_cast<const LineShape2DSW *>(p_shape_A);
-	if (p_shape_B->get_type() == PhysicsServer2D::SHAPE_LINE)
+	if (p_shape_B->get_type() == PhysicsServer2D::SHAPE_LINE) {
 		return false;
+	}
 
 	Vector2 n = p_transform_A.basis_xform(line->get_normal()).normalized();
 	Vector2 p = p_transform_A.xform(line->get_normal() * line->get_d());
@@ -53,17 +54,19 @@ bool CollisionSolver2DSW::solve_static_line(const Shape2DSW *p_shape_A, const Tr
 	for (int i = 0; i < support_count; i++) {
 		supports[i] = p_transform_B.xform(supports[i]);
 		real_t pd = n.dot(supports[i]);
-		if (pd >= d)
+		if (pd >= d) {
 			continue;
+		}
 		found = true;
 
 		Vector2 support_A = supports[i] - n * (pd - d);
 
 		if (p_result_callback) {
-			if (p_swap_result)
+			if (p_swap_result) {
 				p_result_callback(supports[i], support_A, p_userdata);
-			else
+			} else {
 				p_result_callback(support_A, supports[i], p_userdata);
+			}
 		}
 	}
 
@@ -72,8 +75,9 @@ bool CollisionSolver2DSW::solve_static_line(const Shape2DSW *p_shape_A, const Tr
 
 bool CollisionSolver2DSW::solve_raycast(const Shape2DSW *p_shape_A, const Vector2 &p_motion_A, const Transform2D &p_transform_A, const Shape2DSW *p_shape_B, const Transform2D &p_transform_B, CallbackResult p_result_callback, void *p_userdata, bool p_swap_result, Vector2 *sep_axis) {
 	const RayShape2DSW *ray = static_cast<const RayShape2DSW *>(p_shape_A);
-	if (p_shape_B->get_type() == PhysicsServer2D::SHAPE_RAY)
+	if (p_shape_B->get_type() == PhysicsServer2D::SHAPE_RAY) {
 		return false;
+	}
 
 	Vector2 from = p_transform_A.get_origin();
 	Vector2 to = from + p_transform_A[1] * ray->get_length();
@@ -90,8 +94,9 @@ bool CollisionSolver2DSW::solve_raycast(const Shape2DSW *p_shape_A, const Vector
 
 	Vector2 p, n;
 	if (!p_shape_B->intersect_segment(from, to, p, n)) {
-		if (sep_axis)
+		if (sep_axis) {
 			*sep_axis = p_transform_A[1].normalized();
+		}
 		return false;
 	}
 
@@ -102,10 +107,11 @@ bool CollisionSolver2DSW::solve_raycast(const Shape2DSW *p_shape_A, const Vector
 	}
 
 	if (p_result_callback) {
-		if (p_swap_result)
+		if (p_swap_result) {
 			p_result_callback(support_B, support_A, p_userdata);
-		else
+		} else {
 			p_result_callback(support_A, support_B, p_userdata);
+		}
 	}
 	return true;
 }
@@ -130,12 +136,14 @@ struct _ConcaveCollisionInfo2D {
 void CollisionSolver2DSW::concave_callback(void *p_userdata, Shape2DSW *p_convex) {
 	_ConcaveCollisionInfo2D &cinfo = *(_ConcaveCollisionInfo2D *)(p_userdata);
 	cinfo.aabb_tests++;
-	if (!cinfo.result_callback && cinfo.collided)
+	if (!cinfo.result_callback && cinfo.collided) {
 		return; //already collided and no contacts requested, don't test anymore
+	}
 
 	bool collided = collision_solver(cinfo.shape_A, *cinfo.transform_A, cinfo.motion_A, p_convex, *cinfo.transform_B, cinfo.motion_B, cinfo.result_callback, cinfo.userdata, cinfo.swap_result, cinfo.sep_axis, cinfo.margin_A, cinfo.margin_B);
-	if (!collided)
+	if (!collided) {
 		return;
+	}
 
 	cinfo.collided = true;
 	cinfo.collisions++;
@@ -224,13 +232,15 @@ bool CollisionSolver2DSW::solve(const Shape2DSW *p_shape_A, const Transform2D &p
 		}
 
 	} else if (concave_B) {
-		if (concave_A)
+		if (concave_A) {
 			return false;
+		}
 
-		if (!swap)
+		if (!swap) {
 			return solve_concave(p_shape_A, p_transform_A, p_motion_A, p_shape_B, p_transform_B, p_motion_B, p_result_callback, p_userdata, false, sep_axis, margin_A, margin_B);
-		else
+		} else {
 			return solve_concave(p_shape_B, p_transform_B, p_motion_B, p_shape_A, p_transform_A, p_motion_A, p_result_callback, p_userdata, true, sep_axis, margin_A, margin_B);
+		}
 
 	} else {
 		return collision_solver(p_shape_A, p_transform_A, p_motion_A, p_shape_B, p_transform_B, p_motion_B, p_result_callback, p_userdata, false, sep_axis, margin_A, margin_B);

servers/physics_2d/joints_2d_sw.cpp

@@ -76,10 +76,11 @@ static inline real_t k_scalar(Body2DSW *a, Body2DSW *b, const Vector2 &rA, const
 static inline Vector2
 relative_velocity(Body2DSW *a, Body2DSW *b, Vector2 rA, Vector2 rB) {
 	Vector2 sum = a->get_linear_velocity() - rA.tangent() * a->get_angular_velocity();
-	if (b)
+	if (b) {
 		return (b->get_linear_velocity() - rB.tangent() * b->get_angular_velocity()) - sum;
-	else
+	} else {
 		return -sum;
+	}
 }
 
 static inline real_t
@@ -136,8 +137,9 @@ bool PinJoint2DSW::setup(real_t p_step) {
 
 	// apply accumulated impulse
 	A->apply_impulse(rA, -P);
-	if (B)
+	if (B) {
 		B->apply_impulse(rB, P);
+	}
 
 	return true;
 }
@@ -151,28 +153,32 @@ void PinJoint2DSW::solve(real_t p_step) {
 	Vector2 vA = A->get_linear_velocity() - custom_cross(rA, A->get_angular_velocity());
 
 	Vector2 rel_vel;
-	if (B)
+	if (B) {
 		rel_vel = B->get_linear_velocity() - custom_cross(rB, B->get_angular_velocity()) - vA;
-	else
+	} else {
 		rel_vel = -vA;
+	}
 
 	Vector2 impulse = M.basis_xform(bias - rel_vel - Vector2(softness, softness) * P);
 
 	A->apply_impulse(rA, -impulse);
-	if (B)
+	if (B) {
 		B->apply_impulse(rB, impulse);
+	}
 
 	P += impulse;
 }
 
 void PinJoint2DSW::set_param(PhysicsServer2D::PinJointParam p_param, real_t p_value) {
-	if (p_param == PhysicsServer2D::PIN_JOINT_SOFTNESS)
+	if (p_param == PhysicsServer2D::PIN_JOINT_SOFTNESS) {
 		softness = p_value;
+	}
 }
 
 real_t PinJoint2DSW::get_param(PhysicsServer2D::PinJointParam p_param) const {
-	if (p_param == PhysicsServer2D::PIN_JOINT_SOFTNESS)
+	if (p_param == PhysicsServer2D::PIN_JOINT_SOFTNESS) {
 		return softness;
+	}
 	ERR_FAIL_V(0);
 }
 
@@ -186,15 +192,18 @@ PinJoint2DSW::PinJoint2DSW(const Vector2 &p_pos, Body2DSW *p_body_a, Body2DSW *p
 	softness = 0;
 
 	p_body_a->add_constraint(this, 0);
-	if (p_body_b)
+	if (p_body_b) {
 		p_body_b->add_constraint(this, 1);
+	}
 }
 
 PinJoint2DSW::~PinJoint2DSW() {
-	if (A)
+	if (A) {
 		A->remove_constraint(this);
-	if (B)
+	}
+	if (B) {
 		B->remove_constraint(this);
+	}
 }
 
 //////////////////////////////////////////////
@@ -345,10 +354,11 @@ bool DampedSpringJoint2DSW::setup(real_t p_step) {
 	Vector2 delta = (B->get_transform().get_origin() + rB) - (A->get_transform().get_origin() + rA);
 	real_t dist = delta.length();
 
-	if (dist)
+	if (dist) {
 		n = delta / dist;
-	else
+	} else {
 		n = Vector2();
+	}
 
 	real_t k = k_scalar(A, B, rA, rB, n);
 	n_mass = 1.0f / k;

servers/physics_2d/physics_server_2d_sw.cpp

@@ -145,8 +145,9 @@ real_t PhysicsServer2DSW::shape_get_custom_solver_bias(RID p_shape) const {
 void PhysicsServer2DSW::_shape_col_cbk(const Vector2 &p_point_A, const Vector2 &p_point_B, void *p_userdata) {
 	CollCbkData *cbk = (CollCbkData *)p_userdata;
 
-	if (cbk->max == 0)
+	if (cbk->max == 0) {
 		return;
+	}
 
 	if (cbk->valid_dir != Vector2()) {
 		if (p_point_A.distance_squared_to(p_point_B) > cbk->valid_depth * cbk->valid_depth) {
@@ -182,8 +183,9 @@ void PhysicsServer2DSW::_shape_col_cbk(const Vector2 &p_point_A, const Vector2 &
 		}
 
 		real_t d = p_point_A.distance_squared_to(p_point_B);
-		if (d < min_depth)
+		if (d < min_depth) {
 			return;
+		}
 		cbk->ptr[min_depth_idx * 2 + 0] = p_point_A;
 		cbk->ptr[min_depth_idx * 2 + 1] = p_point_B;
 		cbk->passed++;
@@ -234,10 +236,11 @@ RID PhysicsServer2DSW::space_create() {
 void PhysicsServer2DSW::space_set_active(RID p_space, bool p_active) {
 	Space2DSW *space = space_owner.getornull(p_space);
 	ERR_FAIL_COND(!space);
-	if (p_active)
+	if (p_active) {
 		active_spaces.insert(space);
-	else
+	} else {
 		active_spaces.erase(space);
+	}
 }
 
 bool PhysicsServer2DSW::space_is_active(RID p_space) const {
@@ -303,8 +306,9 @@ void PhysicsServer2DSW::area_set_space(RID p_area, RID p_space) {
 		ERR_FAIL_COND(!space);
 	}
 
-	if (area->get_space() == space)
+	if (area->get_space() == space) {
 		return; //pointless
+	}
 
 	area->clear_constraints();
 	area->set_space(space);
@@ -315,8 +319,9 @@ RID PhysicsServer2DSW::area_get_space(RID p_area) const {
 	ERR_FAIL_COND_V(!area, RID());
 
 	Space2DSW *space = area->get_space();
-	if (!space)
+	if (!space) {
 		return RID();
+	}
 	return space->get_self();
 };
 
@@ -406,8 +411,9 @@ void PhysicsServer2DSW::area_clear_shapes(RID p_area) {
 	Area2DSW *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND(!area);
 
-	while (area->get_shape_count())
+	while (area->get_shape_count()) {
 		area->remove_shape(0);
+	}
 }
 
 void PhysicsServer2DSW::area_attach_object_instance_id(RID p_area, ObjectID p_id) {
@@ -544,8 +550,9 @@ void PhysicsServer2DSW::body_set_space(RID p_body, RID p_space) {
 		ERR_FAIL_COND(!space);
 	}
 
-	if (body->get_space() == space)
+	if (body->get_space() == space) {
 		return; //pointless
+	}
 
 	body->clear_constraint_map();
 	body->set_space(space);
@@ -556,8 +563,9 @@ RID PhysicsServer2DSW::body_get_space(RID p_body) const {
 	ERR_FAIL_COND_V(!body, RID());
 
 	Space2DSW *space = body->get_space();
-	if (!space)
+	if (!space) {
 		return RID();
+	}
 	return space->get_self();
 };
 
@@ -651,8 +659,9 @@ void PhysicsServer2DSW::body_clear_shapes(RID p_body) {
 	Body2DSW *body = body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
-	while (body->get_shape_count())
+	while (body->get_shape_count()) {
 		body->remove_shape(0);
+	}
 }
 
 void PhysicsServer2DSW::body_set_shape_disabled(RID p_body, int p_shape_idx, bool p_disabled) {
@@ -966,8 +975,9 @@ int PhysicsServer2DSW::body_test_ray_separation(RID p_body, const Transform2D &p
 PhysicsDirectBodyState2D *PhysicsServer2DSW::body_get_direct_state(RID p_body) {
 	ERR_FAIL_COND_V_MSG((using_threads && !doing_sync), nullptr, "Body state is inaccessible right now, wait for iteration or physics process notification.");
 
-	if (!body_owner.owns(p_body))
+	if (!body_owner.owns(p_body)) {
 		return nullptr;
+	}
 
 	Body2DSW *body = body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, nullptr);
@@ -1213,8 +1223,9 @@ void PhysicsServer2DSW::init() {
 };
 
 void PhysicsServer2DSW::step(real_t p_step) {
-	if (!active)
+	if (!active) {
 		return;
+	}
 
 	_update_shapes();
 
@@ -1238,8 +1249,9 @@ void PhysicsServer2DSW::sync() {
 };
 
 void PhysicsServer2DSW::flush_queries() {
-	if (!active)
+	if (!active) {
 		return;
+	}
 
 	flushing_queries = true;
 

servers/physics_2d/physics_server_2d_wrap_mt.cpp

@@ -77,10 +77,11 @@ void PhysicsServer2DWrapMT::step(real_t p_step) {
 
 void PhysicsServer2DWrapMT::sync() {
 	if (thread) {
-		if (first_frame)
+		if (first_frame) {
 			first_frame = false;
-		else
+		} else {
 			step_sem.wait(); //must not wait if a step was not issued
+		}
 	}
 	physics_2d_server->sync();
 }

servers/physics_2d/physics_server_2d_wrap_mt.h

@@ -318,12 +318,13 @@ public:
 	template <class T>
 	static PhysicsServer2D *init_server() {
 		int tm = GLOBAL_DEF("physics/2d/thread_model", 1);
-		if (tm == 0) // single unsafe
+		if (tm == 0) { // single unsafe
 			return memnew(T);
-		else if (tm == 1) // single safe
+		} else if (tm == 1) { // single safe
 			return memnew(PhysicsServer2DWrapMT(memnew(T), false));
-		else // multi threaded
+		} else { // multi threaded
 			return memnew(PhysicsServer2DWrapMT(memnew(T), true));
+		}
 	}
 
 #undef ServerNameWrapMT

servers/physics_2d/shape_2d_sw.cpp

@@ -146,10 +146,11 @@ Variant LineShape2DSW::get_data() const {
 void RayShape2DSW::get_supports(const Vector2 &p_normal, Vector2 *r_supports, int &r_amount) const {
 	r_amount = 1;
 
-	if (p_normal.y > 0)
+	if (p_normal.y > 0) {
 		*r_supports = Vector2(0, length);
-	else
+	} else {
 		*r_supports = Vector2();
+	}
 }
 
 bool RayShape2DSW::contains_point(const Vector2 &p_point) const {
@@ -191,10 +192,11 @@ void SegmentShape2DSW::get_supports(const Vector2 &p_normal, Vector2 *r_supports
 	}
 
 	real_t dp = p_normal.dot(b - a);
-	if (dp > 0)
+	if (dp > 0) {
 		*r_supports = b;
-	else
+	} else {
 		*r_supports = a;
+	}
 	r_amount = 1;
 }
 
@@ -203,8 +205,9 @@ bool SegmentShape2DSW::contains_point(const Vector2 &p_point) const {
 }
 
 bool SegmentShape2DSW::intersect_segment(const Vector2 &p_begin, const Vector2 &p_end, Vector2 &r_point, Vector2 &r_normal) const {
-	if (!Geometry::segment_intersects_segment_2d(p_begin, p_end, a, b, &r_point))
+	if (!Geometry::segment_intersects_segment_2d(p_begin, p_end, a, b, &r_point)) {
 		return false;
+	}
 
 	if (n.dot(p_begin) > n.dot(a)) {
 		r_normal = n;
@@ -230,10 +233,12 @@ void SegmentShape2DSW::set_data(const Variant &p_data) {
 	Rect2 aabb;
 	aabb.position = a;
 	aabb.expand_to(b);
-	if (aabb.size.x == 0)
+	if (aabb.size.x == 0) {
 		aabb.size.x = 0.001;
-	if (aabb.size.y == 0)
+	}
+	if (aabb.size.y == 0) {
 		aabb.size.y = 0.001;
+	}
 	configure(aabb);
 }
 
@@ -268,8 +273,9 @@ bool CircleShape2DSW::intersect_segment(const Vector2 &p_begin, const Vector2 &p
 
 	real_t sqrtterm = b * b - 4 * a * c;
 
-	if (sqrtterm < 0)
+	if (sqrtterm < 0) {
 		return false;
+	}
 	sqrtterm = Math::sqrt(sqrtterm);
 	real_t res = (-b - sqrtterm) / (2 * a);
 
@@ -307,8 +313,9 @@ void RectangleShape2DSW::get_supports(const Vector2 &p_normal, Vector2 *r_suppor
 		Vector2 ag;
 		ag[i] = 1.0;
 		real_t dp = ag.dot(p_normal);
-		if (Math::abs(dp) < _SEGMENT_IS_VALID_SUPPORT_THRESHOLD)
+		if (Math::abs(dp) < _SEGMENT_IS_VALID_SUPPORT_THRESHOLD) {
 			continue;
+		}
 
 		real_t sgn = dp > 0 ? 1.0 : -1.0;
 
@@ -394,8 +401,9 @@ bool CapsuleShape2DSW::contains_point(const Vector2 &p_point) const {
 	Vector2 p = p_point;
 	p.y = Math::abs(p.y);
 	p.y -= height * 0.5;
-	if (p.y < 0)
+	if (p.y < 0) {
 		p.y = 0;
+	}
 
 	return p.length_squared() < radius * radius;
 }
@@ -423,8 +431,9 @@ bool CapsuleShape2DSW::intersect_segment(const Vector2 &p_begin, const Vector2 &
 
 		real_t sqrtterm = b * b - 4 * a * c;
 
-		if (sqrtterm < 0)
+		if (sqrtterm < 0) {
 			continue;
+		}
 
 		sqrtterm = Math::sqrt(sqrtterm);
 		real_t res = (-b - sqrtterm) / (2 * a);
@@ -523,10 +532,11 @@ bool ConvexPolygonShape2DSW::contains_point(const Vector2 &p_point) const {
 
 	for (int i = 0; i < point_count; i++) {
 		real_t d = points[i].normal.dot(p_point) - points[i].normal.dot(points[i].pos);
-		if (d > 0)
+		if (d > 0) {
 			out = true;
-		else
+		} else {
 			in = true;
+		}
 	}
 
 	return in != out;
@@ -546,8 +556,9 @@ bool ConvexPolygonShape2DSW::intersect_segment(const Vector2 &p_begin, const Vec
 
 		Vector2 res;
 
-		if (!Geometry::segment_intersects_segment_2d(p_begin, p_end, points[i].pos, points[(i + 1) % point_count].pos, &res))
+		if (!Geometry::segment_intersects_segment_2d(p_begin, p_end, points[i].pos, points[(i + 1) % point_count].pos, &res)) {
 			continue;
+		}
 
 		real_t nd = n.dot(res);
 		if (nd < d) {
@@ -559,8 +570,9 @@ bool ConvexPolygonShape2DSW::intersect_segment(const Vector2 &p_begin, const Vec
 	}
 
 	if (inters) {
-		if (n.dot(r_normal) > 0)
+		if (n.dot(r_normal) > 0) {
 			r_normal = -r_normal;
+		}
 	}
 
 	//return get_aabb().intersects_segment(p_begin,p_end,&r_point,&r_normal);
@@ -580,8 +592,9 @@ real_t ConvexPolygonShape2DSW::get_moment_of_inertia(real_t p_mass, const Size2
 void ConvexPolygonShape2DSW::set_data(const Variant &p_data) {
 	ERR_FAIL_COND(p_data.get_type() != Variant::PACKED_VECTOR2_ARRAY && p_data.get_type() != Variant::PACKED_FLOAT32_ARRAY);
 
-	if (points)
+	if (points) {
 		memdelete_arr(points);
+	}
 	points = nullptr;
 	point_count = 0;
 
@@ -621,8 +634,9 @@ void ConvexPolygonShape2DSW::set_data(const Variant &p_data) {
 	ERR_FAIL_COND(point_count == 0);
 	Rect2 aabb;
 	aabb.position = points[0].pos;
-	for (int i = 1; i < point_count; i++)
+	for (int i = 1; i < point_count; i++) {
 		aabb.expand_to(points[i].pos);
+	}
 
 	configure(aabb);
 }
@@ -645,8 +659,9 @@ ConvexPolygonShape2DSW::ConvexPolygonShape2DSW() {
 }
 
 ConvexPolygonShape2DSW::~ConvexPolygonShape2DSW() {
-	if (points)
+	if (points) {
 		memdelete_arr(points);
+	}
 }
 
 //////////////////////////////////////////////////
@@ -754,19 +769,22 @@ bool ConcavePolygonShape2DSW::intersect_segment(const Vector2 &p_begin, const Ve
 				if (level == 0) {
 					done = true;
 					break;
-				} else
+				} else {
 					level--;
+				}
 			}
 				continue;
 		}
 
-		if (done)
+		if (done) {
 			break;
+		}
 	}
 
 	if (inters) {
-		if (n.dot(r_normal) > 0)
+		if (n.dot(r_normal) > 0) {
 			r_normal = -r_normal;
+		}
 	}
 
 	return inters;
@@ -966,10 +984,11 @@ void ConcavePolygonShape2DSW::cull(const Rect2 &p_local_aabb, Callback p_callbac
 			}
 				continue;
 			case VISIT_DONE_BIT: {
-				if (level == 0)
+				if (level == 0) {
 					return;
-				else
+				} else {
 					level--;
+				}
 			}
 				continue;
 		}

servers/physics_2d/shape_2d_sw.h

@@ -100,8 +100,9 @@ public:
 
 	_FORCE_INLINE_ void get_supports_transformed_cast(const Vector2 &p_cast, const Vector2 &p_normal, const Transform2D &p_xform, Vector2 *r_supports, int &r_amount) const {
 		get_supports(p_xform.basis_xform_inv(p_normal).normalized(), r_supports, r_amount);
-		for (int i = 0; i < r_amount; i++)
+		for (int i = 0; i < r_amount; i++) {
 			r_supports[i] = p_xform.xform(r_supports[i]);
+		}
 
 		if (r_amount == 1) {
 			if (Math::abs(p_normal.dot(p_cast.normalized())) < (1.0 - _SEGMENT_IS_VALID_SUPPORT_THRESHOLD)) {
@@ -325,10 +326,12 @@ public:
 		for (int i = 0; i < 4; i++) {
 			real_t d = p_normal.dot(p_transform.xform(Vector2(((i & 1) * 2 - 1) * half_extents.x, ((i >> 1) * 2 - 1) * half_extents.y)));
 
-			if (d > r_max)
+			if (d > r_max) {
 				r_max = d;
-			if (d < r_min)
+			}
+			if (d < r_min) {
 				r_min = d;
+			}
 		}
 	}
 
@@ -452,10 +455,12 @@ public:
 		r_min = r_max = p_normal.dot(p_transform.xform(points[0].pos));
 		for (int i = 1; i < point_count; i++) {
 			real_t d = p_normal.dot(p_transform.xform(points[i].pos));
-			if (d > r_max)
+			if (d > r_max) {
 				r_max = d;
-			if (d < r_min)
+			}
+			if (d < r_min) {
 				r_min = d;
+			}
 		}
 	}
 

servers/physics_2d/space_2d_sw.cpp

@@ -39,18 +39,21 @@ _FORCE_INLINE_ static bool _can_collide_with(CollisionObject2DSW *p_object, uint
 		return false;
 	}
 
-	if (p_object->get_type() == CollisionObject2DSW::TYPE_AREA && !p_collide_with_areas)
+	if (p_object->get_type() == CollisionObject2DSW::TYPE_AREA && !p_collide_with_areas) {
 		return false;
+	}
 
-	if (p_object->get_type() == CollisionObject2DSW::TYPE_BODY && !p_collide_with_bodies)
+	if (p_object->get_type() == CollisionObject2DSW::TYPE_BODY && !p_collide_with_bodies) {
 		return false;
+	}
 
 	return true;
 }
 
 int PhysicsDirectSpaceState2DSW::_intersect_point_impl(const Vector2 &p_point, ShapeResult *r_results, int p_result_max, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas, bool p_pick_point, bool p_filter_by_canvas, ObjectID p_canvas_instance_id) {
-	if (p_result_max <= 0)
+	if (p_result_max <= 0) {
 		return 0;
+	}
 
 	Rect2 aabb;
 	aabb.position = p_point - Vector2(0.00001, 0.00001);
@@ -61,19 +64,23 @@ int PhysicsDirectSpaceState2DSW::_intersect_point_impl(const Vector2 &p_point, S
 	int cc = 0;
 
 	for (int i = 0; i < amount; i++) {
-		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas))
+		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas)) {
 			continue;
+		}
 
-		if (p_exclude.has(space->intersection_query_results[i]->get_self()))
+		if (p_exclude.has(space->intersection_query_results[i]->get_self())) {
 			continue;
+		}
 
 		const CollisionObject2DSW *col_obj = space->intersection_query_results[i];
 
-		if (p_pick_point && !col_obj->is_pickable())
+		if (p_pick_point && !col_obj->is_pickable()) {
 			continue;
+		}
 
-		if (p_filter_by_canvas && col_obj->get_canvas_instance_id() != p_canvas_instance_id)
+		if (p_filter_by_canvas && col_obj->get_canvas_instance_id() != p_canvas_instance_id) {
 			continue;
+		}
 
 		int shape_idx = space->intersection_query_subindex_results[i];
 
@@ -81,15 +88,18 @@ int PhysicsDirectSpaceState2DSW::_intersect_point_impl(const Vector2 &p_point, S
 
 		Vector2 local_point = (col_obj->get_transform() * col_obj->get_shape_transform(shape_idx)).affine_inverse().xform(p_point);
 
-		if (!shape->contains_point(local_point))
+		if (!shape->contains_point(local_point)) {
 			continue;
+		}
 
-		if (cc >= p_result_max)
+		if (cc >= p_result_max) {
 			continue;
+		}
 
 		r_results[cc].collider_id = col_obj->get_instance_id();
-		if (r_results[cc].collider_id.is_valid())
+		if (r_results[cc].collider_id.is_valid()) {
 			r_results[cc].collider = ObjectDB::get_instance(r_results[cc].collider_id);
+		}
 		r_results[cc].rid = col_obj->get_self();
 		r_results[cc].shape = shape_idx;
 		r_results[cc].metadata = col_obj->get_shape_metadata(shape_idx);
@@ -128,11 +138,13 @@ bool PhysicsDirectSpaceState2DSW::intersect_ray(const Vector2 &p_from, const Vec
 	real_t min_d = 1e10;
 
 	for (int i = 0; i < amount; i++) {
-		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas))
+		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas)) {
 			continue;
+		}
 
-		if (p_exclude.has(space->intersection_query_results[i]->get_self()))
+		if (p_exclude.has(space->intersection_query_results[i]->get_self())) {
 			continue;
+		}
 
 		const CollisionObject2DSW *col_obj = space->intersection_query_results[i];
 
@@ -169,12 +181,14 @@ bool PhysicsDirectSpaceState2DSW::intersect_ray(const Vector2 &p_from, const Vec
 		}
 	}
 
-	if (!collided)
+	if (!collided) {
 		return false;
+	}
 
 	r_result.collider_id = res_obj->get_instance_id();
-	if (r_result.collider_id.is_valid())
+	if (r_result.collider_id.is_valid()) {
 		r_result.collider = ObjectDB::get_instance(r_result.collider_id);
+	}
 	r_result.normal = res_normal;
 	r_result.metadata = res_obj->get_shape_metadata(res_shape);
 	r_result.position = res_point;
@@ -185,8 +199,9 @@ bool PhysicsDirectSpaceState2DSW::intersect_ray(const Vector2 &p_from, const Vec
 }
 
 int PhysicsDirectSpaceState2DSW::intersect_shape(const RID &p_shape, const Transform2D &p_xform, const Vector2 &p_motion, real_t p_margin, ShapeResult *r_results, int p_result_max, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas) {
-	if (p_result_max <= 0)
+	if (p_result_max <= 0) {
 		return 0;
+	}
 
 	Shape2DSW *shape = PhysicsServer2DSW::singletonsw->shape_owner.getornull(p_shape);
 	ERR_FAIL_COND_V(!shape, 0);
@@ -199,24 +214,29 @@ int PhysicsDirectSpaceState2DSW::intersect_shape(const RID &p_shape, const Trans
 	int cc = 0;
 
 	for (int i = 0; i < amount; i++) {
-		if (cc >= p_result_max)
+		if (cc >= p_result_max) {
 			break;
+		}
 
-		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas))
+		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas)) {
 			continue;
+		}
 
-		if (p_exclude.has(space->intersection_query_results[i]->get_self()))
+		if (p_exclude.has(space->intersection_query_results[i]->get_self())) {
 			continue;
+		}
 
 		const CollisionObject2DSW *col_obj = space->intersection_query_results[i];
 		int shape_idx = space->intersection_query_subindex_results[i];
 
-		if (!CollisionSolver2DSW::solve(shape, p_xform, p_motion, col_obj->get_shape(shape_idx), col_obj->get_transform() * col_obj->get_shape_transform(shape_idx), Vector2(), nullptr, nullptr, nullptr, p_margin))
+		if (!CollisionSolver2DSW::solve(shape, p_xform, p_motion, col_obj->get_shape(shape_idx), col_obj->get_transform() * col_obj->get_shape_transform(shape_idx), Vector2(), nullptr, nullptr, nullptr, p_margin)) {
 			continue;
+		}
 
 		r_results[cc].collider_id = col_obj->get_instance_id();
-		if (r_results[cc].collider_id.is_valid())
+		if (r_results[cc].collider_id.is_valid()) {
 			r_results[cc].collider = ObjectDB::get_instance(r_results[cc].collider_id);
+		}
 		r_results[cc].rid = col_obj->get_self();
 		r_results[cc].shape = shape_idx;
 		r_results[cc].metadata = col_obj->get_shape_metadata(shape_idx);
@@ -241,11 +261,13 @@ bool PhysicsDirectSpaceState2DSW::cast_motion(const RID &p_shape, const Transfor
 	real_t best_unsafe = 1;
 
 	for (int i = 0; i < amount; i++) {
-		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas))
+		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas)) {
 			continue;
+		}
 
-		if (p_exclude.has(space->intersection_query_results[i]->get_self()))
+		if (p_exclude.has(space->intersection_query_results[i]->get_self())) {
 			continue; //ignore excluded
+		}
 
 		const CollisionObject2DSW *col_obj = space->intersection_query_results[i];
 		int shape_idx = space->intersection_query_subindex_results[i];
@@ -293,8 +315,9 @@ bool PhysicsDirectSpaceState2DSW::cast_motion(const RID &p_shape, const Transfor
 }
 
 bool PhysicsDirectSpaceState2DSW::collide_shape(RID p_shape, const Transform2D &p_shape_xform, const Vector2 &p_motion, real_t p_margin, Vector2 *r_results, int p_result_max, int &r_result_count, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas) {
-	if (p_result_max <= 0)
+	if (p_result_max <= 0) {
 		return false;
+	}
 
 	Shape2DSW *shape = PhysicsServer2DSW::singletonsw->shape_owner.getornull(p_shape);
 	ERR_FAIL_COND_V(!shape, 0);
@@ -318,14 +341,16 @@ bool PhysicsDirectSpaceState2DSW::collide_shape(RID p_shape, const Transform2D &
 	PhysicsServer2DSW::CollCbkData *cbkptr = &cbk;
 
 	for (int i = 0; i < amount; i++) {
-		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas))
+		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas)) {
 			continue;
+		}
 
 		const CollisionObject2DSW *col_obj = space->intersection_query_results[i];
 		int shape_idx = space->intersection_query_subindex_results[i];
 
-		if (p_exclude.has(col_obj->get_self()))
+		if (p_exclude.has(col_obj->get_self())) {
 			continue;
+		}
 
 		cbk.valid_dir = Vector2();
 		cbk.valid_depth = 0;
@@ -359,20 +384,24 @@ static void _rest_cbk_result(const Vector2 &p_point_A, const Vector2 &p_point_B,
 	_RestCallbackData2D *rd = (_RestCallbackData2D *)p_userdata;
 
 	if (rd->valid_dir != Vector2()) {
-		if (p_point_A.distance_squared_to(p_point_B) > rd->valid_depth * rd->valid_depth)
+		if (p_point_A.distance_squared_to(p_point_B) > rd->valid_depth * rd->valid_depth) {
 			return;
-		if (rd->valid_dir.dot((p_point_A - p_point_B).normalized()) < Math_PI * 0.25)
+		}
+		if (rd->valid_dir.dot((p_point_A - p_point_B).normalized()) < Math_PI * 0.25) {
 			return;
+		}
 	}
 
 	Vector2 contact_rel = p_point_B - p_point_A;
 	real_t len = contact_rel.length();
 
-	if (len < rd->min_allowed_depth)
+	if (len < rd->min_allowed_depth) {
 		return;
+	}
 
-	if (len <= rd->best_len)
+	if (len <= rd->best_len) {
 		return;
+	}
 
 	rd->best_len = len;
 	rd->best_contact = p_point_B;
@@ -399,14 +428,16 @@ bool PhysicsDirectSpaceState2DSW::rest_info(RID p_shape, const Transform2D &p_sh
 	rcd.min_allowed_depth = space->test_motion_min_contact_depth;
 
 	for (int i = 0; i < amount; i++) {
-		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas))
+		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas)) {
 			continue;
+		}
 
 		const CollisionObject2DSW *col_obj = space->intersection_query_results[i];
 		int shape_idx = space->intersection_query_subindex_results[i];
 
-		if (p_exclude.has(col_obj->get_self()))
+		if (p_exclude.has(col_obj->get_self())) {
 			continue;
+		}
 
 		rcd.valid_dir = Vector2();
 		rcd.valid_depth = 0;
@@ -414,12 +445,14 @@ bool PhysicsDirectSpaceState2DSW::rest_info(RID p_shape, const Transform2D &p_sh
 		rcd.shape = shape_idx;
 		rcd.local_shape = 0;
 		bool sc = CollisionSolver2DSW::solve(shape, p_shape_xform, p_motion, col_obj->get_shape(shape_idx), col_obj->get_transform() * col_obj->get_shape_transform(shape_idx), Vector2(), _rest_cbk_result, &rcd, nullptr, p_margin);
-		if (!sc)
+		if (!sc) {
 			continue;
+		}
 	}
 
-	if (rcd.best_len == 0 || !rcd.best_object)
+	if (rcd.best_len == 0 || !rcd.best_object) {
 		return false;
+	}
 
 	r_info->collider_id = rcd.best_object->get_instance_id();
 	r_info->shape = rcd.best_shape;
@@ -451,16 +484,17 @@ int Space2DSW::_cull_aabb_for_body(Body2DSW *p_body, const Rect2 &p_aabb) {
 	for (int i = 0; i < amount; i++) {
 		bool keep = true;
 
-		if (intersection_query_results[i] == p_body)
+		if (intersection_query_results[i] == p_body) {
 			keep = false;
-		else if (intersection_query_results[i]->get_type() == CollisionObject2DSW::TYPE_AREA)
+		} else if (intersection_query_results[i]->get_type() == CollisionObject2DSW::TYPE_AREA) {
 			keep = false;
-		else if ((static_cast<Body2DSW *>(intersection_query_results[i])->test_collision_mask(p_body)) == 0)
+		} else if ((static_cast<Body2DSW *>(intersection_query_results[i])->test_collision_mask(p_body)) == 0) {
 			keep = false;
-		else if (static_cast<Body2DSW *>(intersection_query_results[i])->has_exception(p_body->get_self()) || p_body->has_exception(intersection_query_results[i]->get_self()))
+		} else if (static_cast<Body2DSW *>(intersection_query_results[i])->has_exception(p_body->get_self()) || p_body->has_exception(intersection_query_results[i]->get_self())) {
 			keep = false;
-		else if (static_cast<Body2DSW *>(intersection_query_results[i])->is_shape_set_as_disabled(intersection_query_subindex_results[i]))
+		} else if (static_cast<Body2DSW *>(intersection_query_results[i])->is_shape_set_as_disabled(intersection_query_subindex_results[i])) {
 			keep = false;
+		}
 
 		if (!keep) {
 			if (i < amount - 1) {
@@ -482,11 +516,13 @@ int Space2DSW::test_body_ray_separation(Body2DSW *p_body, const Transform2D &p_t
 	bool shapes_found = false;
 
 	for (int i = 0; i < p_body->get_shape_count(); i++) {
-		if (p_body->is_shape_set_as_disabled(i))
+		if (p_body->is_shape_set_as_disabled(i)) {
 			continue;
+		}
 
-		if (p_body->get_shape(i)->get_type() != PhysicsServer2D::SHAPE_RAY)
+		if (p_body->get_shape(i)->get_type() != PhysicsServer2D::SHAPE_RAY) {
 			continue;
+		}
 
 		if (!shapes_found) {
 			body_aabb = p_body->get_shape_aabb(i);
@@ -532,13 +568,15 @@ int Space2DSW::test_body_ray_separation(Body2DSW *p_body, const Transform2D &p_t
 			int amount = _cull_aabb_for_body(p_body, body_aabb);
 
 			for (int j = 0; j < p_body->get_shape_count(); j++) {
-				if (p_body->is_shape_set_as_disabled(j))
+				if (p_body->is_shape_set_as_disabled(j)) {
 					continue;
+				}
 
 				Shape2DSW *body_shape = p_body->get_shape(j);
 
-				if (body_shape->get_type() != PhysicsServer2D::SHAPE_RAY)
+				if (body_shape->get_type() != PhysicsServer2D::SHAPE_RAY) {
 					continue;
+				}
 
 				Transform2D body_shape_xform = body_transform * p_body->get_shape_transform(j);
 
@@ -671,11 +709,13 @@ bool Space2DSW::test_body_motion(Body2DSW *p_body, const Transform2D &p_from, co
 	bool shapes_found = false;
 
 	for (int i = 0; i < p_body->get_shape_count(); i++) {
-		if (p_body->is_shape_set_as_disabled(i))
+		if (p_body->is_shape_set_as_disabled(i)) {
 			continue;
+		}
 
-		if (p_exclude_raycast_shapes && p_body->get_shape(i)->get_type() == PhysicsServer2D::SHAPE_RAY)
+		if (p_exclude_raycast_shapes && p_body->get_shape(i)->get_type() == PhysicsServer2D::SHAPE_RAY) {
 			continue;
+		}
 
 		if (!shapes_found) {
 			body_aabb = p_body->get_shape_aabb(i);
@@ -729,8 +769,9 @@ bool Space2DSW::test_body_motion(Body2DSW *p_body, const Transform2D &p_from, co
 			int amount = _cull_aabb_for_body(p_body, body_aabb);
 
 			for (int j = 0; j < p_body->get_shape_count(); j++) {
-				if (p_body->is_shape_set_as_disabled(j))
+				if (p_body->is_shape_set_as_disabled(j)) {
 					continue;
+				}
 
 				Shape2DSW *body_shape = p_body->get_shape(j);
 				if (p_exclude_raycast_shapes && body_shape->get_type() == PhysicsServer2D::SHAPE_RAY) {
@@ -840,8 +881,9 @@ bool Space2DSW::test_body_motion(Body2DSW *p_body, const Transform2D &p_from, co
 		int amount = _cull_aabb_for_body(p_body, motion_aabb);
 
 		for (int body_shape_idx = 0; body_shape_idx < p_body->get_shape_count(); body_shape_idx++) {
-			if (p_body->is_shape_set_as_disabled(body_shape_idx))
+			if (p_body->is_shape_set_as_disabled(body_shape_idx)) {
 				continue;
+			}
 
 			Shape2DSW *body_shape = p_body->get_shape(body_shape_idx);
 			if (p_exclude_raycast_shapes && body_shape->get_type() == PhysicsServer2D::SHAPE_RAY) {
@@ -977,8 +1019,9 @@ bool Space2DSW::test_body_motion(Body2DSW *p_body, const Transform2D &p_from, co
 		int to_shape = best_shape != -1 ? best_shape + 1 : p_body->get_shape_count();
 
 		for (int j = from_shape; j < to_shape; j++) {
-			if (p_body->is_shape_set_as_disabled(j))
+			if (p_body->is_shape_set_as_disabled(j)) {
 				continue;
+			}
 
 			Transform2D body_shape_xform = ugt * p_body->get_shape_transform(j);
 			Shape2DSW *body_shape = p_body->get_shape(j);
@@ -1011,8 +1054,9 @@ bool Space2DSW::test_body_motion(Body2DSW *p_body, const Transform2D &p_from, co
 						break;
 					}
 				}
-				if (excluded)
+				if (excluded) {
 					continue;
+				}
 
 				Transform2D col_obj_shape_xform = col_obj->get_transform() * col_obj->get_shape_transform(shape_idx);
 
@@ -1028,8 +1072,9 @@ bool Space2DSW::test_body_motion(Body2DSW *p_body, const Transform2D &p_from, co
 				rcd.shape = shape_idx;
 				rcd.local_shape = j;
 				bool sc = CollisionSolver2DSW::solve(body_shape, body_shape_xform, Vector2(), against_shape, col_obj_shape_xform, Vector2(), _rest_cbk_result, &rcd, nullptr, p_margin);
-				if (!sc)
+				if (!sc) {
 					continue;
+				}
 			}
 		}
 
@@ -1291,8 +1336,9 @@ Space2DSW::Space2DSW() {
 	direct_access = memnew(PhysicsDirectSpaceState2DSW);
 	direct_access->space = this;
 
-	for (int i = 0; i < ELAPSED_TIME_MAX; i++)
+	for (int i = 0; i < ELAPSED_TIME_MAX; i++) {
 		elapsed_time[i] = 0;
+	}
 }
 
 Space2DSW::~Space2DSW() {

servers/physics_2d/space_2d_sw.h

@@ -190,8 +190,9 @@ public:
 	void set_debug_contacts(int p_amount) { contact_debug.resize(p_amount); }
 	_FORCE_INLINE_ bool is_debugging_contacts() const { return !contact_debug.empty(); }
 	_FORCE_INLINE_ void add_debug_contact(const Vector2 &p_contact) {
-		if (contact_debug_count < contact_debug.size())
+		if (contact_debug_count < contact_debug.size()) {
 			contact_debug.write[contact_debug_count++] = p_contact;
+		}
 	}
 	_FORCE_INLINE_ Vector<Vector2> get_debug_contacts() { return contact_debug; }
 	_FORCE_INLINE_ int get_debug_contact_count() { return contact_debug_count; }

servers/physics_2d/step_2d_sw.cpp

@@ -38,18 +38,21 @@ void Step2DSW::_populate_island(Body2DSW *p_body, Body2DSW **p_island, Constrain
 
 	for (Map<Constraint2DSW *, int>::Element *E = p_body->get_constraint_map().front(); E; E = E->next()) {
 		Constraint2DSW *c = (Constraint2DSW *)E->key();
-		if (c->get_island_step() == _step)
+		if (c->get_island_step() == _step) {
 			continue; //already processed
+		}
 		c->set_island_step(_step);
 		c->set_island_next(*p_constraint_island);
 		*p_constraint_island = c;
 
 		for (int i = 0; i < c->get_body_count(); i++) {
-			if (i == E->get())
+			if (i == E->get()) {
 				continue;
+			}
 			Body2DSW *b = c->get_body_ptr()[i];
-			if (b->get_island_step() == _step || b->get_mode() == PhysicsServer2D::BODY_MODE_STATIC || b->get_mode() == PhysicsServer2D::BODY_MODE_KINEMATIC)
+			if (b->get_island_step() == _step || b->get_mode() == PhysicsServer2D::BODY_MODE_STATIC || b->get_mode() == PhysicsServer2D::BODY_MODE_KINEMATIC) {
 				continue; //no go
+			}
 			_populate_island(c->get_body_ptr()[i], p_island, p_constraint_island);
 		}
 	}
@@ -99,8 +102,9 @@ void Step2DSW::_check_suspend(Body2DSW *p_island, real_t p_delta) {
 			continue; //ignore for static
 		}
 
-		if (!b->sleep_test(p_delta))
+		if (!b->sleep_test(p_delta)) {
 			can_sleep = false;
+		}
 
 		b = b->get_island_next();
 	}
@@ -116,8 +120,9 @@ void Step2DSW::_check_suspend(Body2DSW *p_island, real_t p_delta) {
 
 		bool active = b->is_active();
 
-		if (active == can_sleep)
+		if (active == can_sleep) {
 			b->set_active(!can_sleep);
+		}
 
 		b = b->get_island_next();
 	}
@@ -187,8 +192,9 @@ void Step2DSW::step(Space2DSW *p_space, real_t p_delta, int p_iterations) {
 	while (aml.first()) {
 		for (const Set<Constraint2DSW *>::Element *E = aml.first()->self()->get_constraints().front(); E; E = E->next()) {
 			Constraint2DSW *c = E->get();
-			if (c->get_island_step() == _step)
+			if (c->get_island_step() == _step) {
 				continue;
+			}
 			c->set_island_step(_step);
 			c->set_island_next(nullptr);
 			c->set_island_list_next(constraint_island_list);

servers/physics_3d/area_3d_sw.cpp

@@ -47,13 +47,15 @@ Area3DSW::BodyKey::BodyKey(Area3DSW *p_body, uint32_t p_body_shape, uint32_t p_a
 }
 
 void Area3DSW::_shapes_changed() {
-	if (!moved_list.in_list() && get_space())
+	if (!moved_list.in_list() && get_space()) {
 		get_space()->area_add_to_moved_list(&moved_list);
+	}
 }
 
 void Area3DSW::set_transform(const Transform &p_transform) {
-	if (!moved_list.in_list() && get_space())
+	if (!moved_list.in_list() && get_space()) {
 		get_space()->area_add_to_moved_list(&moved_list);
+	}
 
 	_set_transform(p_transform);
 	_set_inv_transform(p_transform.affine_inverse());
@@ -61,10 +63,12 @@ void Area3DSW::set_transform(const Transform &p_transform) {
 
 void Area3DSW::set_space(Space3DSW *p_space) {
 	if (get_space()) {
-		if (monitor_query_list.in_list())
+		if (monitor_query_list.in_list()) {
 			get_space()->area_remove_from_monitor_query_list(&monitor_query_list);
-		if (moved_list.in_list())
+		}
+		if (moved_list.in_list()) {
 			get_space()->area_remove_from_moved_list(&moved_list);
+		}
 	}
 
 	monitored_bodies.clear();
@@ -89,8 +93,9 @@ void Area3DSW::set_monitor_callback(ObjectID p_id, const StringName &p_method) {
 
 	_shape_changed();
 
-	if (!moved_list.in_list() && get_space())
+	if (!moved_list.in_list() && get_space()) {
 		get_space()->area_add_to_moved_list(&moved_list);
+	}
 }
 
 void Area3DSW::set_area_monitor_callback(ObjectID p_id, const StringName &p_method) {
@@ -109,14 +114,16 @@ void Area3DSW::set_area_monitor_callback(ObjectID p_id, const StringName &p_meth
 
 	_shape_changed();
 
-	if (!moved_list.in_list() && get_space())
+	if (!moved_list.in_list() && get_space()) {
 		get_space()->area_add_to_moved_list(&moved_list);
+	}
 }
 
 void Area3DSW::set_space_override_mode(PhysicsServer3D::AreaSpaceOverrideMode p_mode) {
 	bool do_override = p_mode != PhysicsServer3D::AREA_SPACE_OVERRIDE_DISABLED;
-	if (do_override == (space_override_mode != PhysicsServer3D::AREA_SPACE_OVERRIDE_DISABLED))
+	if (do_override == (space_override_mode != PhysicsServer3D::AREA_SPACE_OVERRIDE_DISABLED)) {
 		return;
+	}
 	_unregister_shapes();
 	space_override_mode = p_mode;
 	_shape_changed();
@@ -177,13 +184,15 @@ Variant Area3DSW::get_param(PhysicsServer3D::AreaParameter p_param) const {
 void Area3DSW::_queue_monitor_update() {
 	ERR_FAIL_COND(!get_space());
 
-	if (!monitor_query_list.in_list())
+	if (!monitor_query_list.in_list()) {
 		get_space()->area_add_to_monitor_query_list(&monitor_query_list);
+	}
 }
 
 void Area3DSW::set_monitorable(bool p_monitorable) {
-	if (monitorable == p_monitorable)
+	if (monitorable == p_monitorable) {
 		return;
+	}
 
 	monitorable = p_monitorable;
 	_set_static(!monitorable);
@@ -193,8 +202,9 @@ void Area3DSW::call_queries() {
 	if (monitor_callback_id.is_valid() && !monitored_bodies.empty()) {
 		Variant res[5];
 		Variant *resptr[5];
-		for (int i = 0; i < 5; i++)
+		for (int i = 0; i < 5; i++) {
 			resptr[i] = &res[i];
+		}
 
 		Object *obj = ObjectDB::get_instance(monitor_callback_id);
 		if (!obj) {
@@ -204,8 +214,9 @@ void Area3DSW::call_queries() {
 		}
 
 		for (Map<BodyKey, BodyState>::Element *E = monitored_bodies.front(); E; E = E->next()) {
-			if (E->get().state == 0)
+			if (E->get().state == 0) {
 				continue; //nothing happened
+			}
 
 			res[0] = E->get().state > 0 ? PhysicsServer3D::AREA_BODY_ADDED : PhysicsServer3D::AREA_BODY_REMOVED;
 			res[1] = E->key().rid;
@@ -223,8 +234,9 @@ void Area3DSW::call_queries() {
 	if (area_monitor_callback_id.is_valid() && !monitored_areas.empty()) {
 		Variant res[5];
 		Variant *resptr[5];
-		for (int i = 0; i < 5; i++)
+		for (int i = 0; i < 5; i++) {
 			resptr[i] = &res[i];
+		}
 
 		Object *obj = ObjectDB::get_instance(area_monitor_callback_id);
 		if (!obj) {
@@ -234,8 +246,9 @@ void Area3DSW::call_queries() {
 		}
 
 		for (Map<BodyKey, BodyState>::Element *E = monitored_areas.front(); E; E = E->next()) {
-			if (E->get().state == 0)
+			if (E->get().state == 0) {
 				continue; //nothing happened
+			}
 
 			res[0] = E->get().state > 0 ? PhysicsServer3D::AREA_BODY_ADDED : PhysicsServer3D::AREA_BODY_REMOVED;
 			res[1] = E->key().rid;

servers/physics_3d/area_3d_sw.h

@@ -71,10 +71,12 @@ class Area3DSW : public CollisionObject3DSW {
 			if (rid == p_key.rid) {
 				if (body_shape == p_key.body_shape) {
 					return area_shape < p_key.area_shape;
-				} else
+				} else {
 					return body_shape < p_key.body_shape;
-			} else
+				}
+			} else {
 				return rid < p_key.rid;
+			}
 		}
 
 		_FORCE_INLINE_ BodyKey() {}
@@ -167,29 +169,33 @@ public:
 void Area3DSW::add_body_to_query(Body3DSW *p_body, uint32_t p_body_shape, uint32_t p_area_shape) {
 	BodyKey bk(p_body, p_body_shape, p_area_shape);
 	monitored_bodies[bk].inc();
-	if (!monitor_query_list.in_list())
+	if (!monitor_query_list.in_list()) {
 		_queue_monitor_update();
+	}
 }
 
 void Area3DSW::remove_body_from_query(Body3DSW *p_body, uint32_t p_body_shape, uint32_t p_area_shape) {
 	BodyKey bk(p_body, p_body_shape, p_area_shape);
 	monitored_bodies[bk].dec();
-	if (!monitor_query_list.in_list())
+	if (!monitor_query_list.in_list()) {
 		_queue_monitor_update();
+	}
 }
 
 void Area3DSW::add_area_to_query(Area3DSW *p_area, uint32_t p_area_shape, uint32_t p_self_shape) {
 	BodyKey bk(p_area, p_area_shape, p_self_shape);
 	monitored_areas[bk].inc();
-	if (!monitor_query_list.in_list())
+	if (!monitor_query_list.in_list()) {
 		_queue_monitor_update();
+	}
 }
 
 void Area3DSW::remove_area_from_query(Area3DSW *p_area, uint32_t p_area_shape, uint32_t p_self_shape) {
 	BodyKey bk(p_area, p_area_shape, p_self_shape);
 	monitored_areas[bk].dec();
-	if (!monitor_query_list.in_list())
+	if (!monitor_query_list.in_list()) {
 		_queue_monitor_update();
+	}
 }
 
 #endif // AREA__SW_H

servers/physics_3d/area_pair_3d_sw.cpp

@@ -42,16 +42,20 @@ bool AreaPair3DSW::setup(real_t p_step) {
 
 	if (result != colliding) {
 		if (result) {
-			if (area->get_space_override_mode() != PhysicsServer3D::AREA_SPACE_OVERRIDE_DISABLED)
+			if (area->get_space_override_mode() != PhysicsServer3D::AREA_SPACE_OVERRIDE_DISABLED) {
 				body->add_area(area);
-			if (area->has_monitor_callback())
+			}
+			if (area->has_monitor_callback()) {
 				area->add_body_to_query(body, body_shape, area_shape);
+			}
 
 		} else {
-			if (area->get_space_override_mode() != PhysicsServer3D::AREA_SPACE_OVERRIDE_DISABLED)
+			if (area->get_space_override_mode() != PhysicsServer3D::AREA_SPACE_OVERRIDE_DISABLED) {
 				body->remove_area(area);
-			if (area->has_monitor_callback())
+			}
+			if (area->has_monitor_callback()) {
 				area->remove_body_from_query(body, body_shape, area_shape);
+			}
 		}
 
 		colliding = result;
@@ -71,16 +75,19 @@ AreaPair3DSW::AreaPair3DSW(Body3DSW *p_body, int p_body_shape, Area3DSW *p_area,
 	colliding = false;
 	body->add_constraint(this, 0);
 	area->add_constraint(this);
-	if (p_body->get_mode() == PhysicsServer3D::BODY_MODE_KINEMATIC)
+	if (p_body->get_mode() == PhysicsServer3D::BODY_MODE_KINEMATIC) {
 		p_body->set_active(true);
+	}
 }
 
 AreaPair3DSW::~AreaPair3DSW() {
 	if (colliding) {
-		if (area->get_space_override_mode() != PhysicsServer3D::AREA_SPACE_OVERRIDE_DISABLED)
+		if (area->get_space_override_mode() != PhysicsServer3D::AREA_SPACE_OVERRIDE_DISABLED) {
 			body->remove_area(area);
-		if (area->has_monitor_callback())
+		}
+		if (area->has_monitor_callback()) {
 			area->remove_body_from_query(body, body_shape, area_shape);
+		}
 	}
 	body->remove_constraint(this);
 	area->remove_constraint(this);
@@ -98,18 +105,22 @@ bool Area2Pair3DSW::setup(real_t p_step) {
 
 	if (result != colliding) {
 		if (result) {
-			if (area_b->has_area_monitor_callback() && area_a->is_monitorable())
+			if (area_b->has_area_monitor_callback() && area_a->is_monitorable()) {
 				area_b->add_area_to_query(area_a, shape_a, shape_b);
+			}
 
-			if (area_a->has_area_monitor_callback() && area_b->is_monitorable())
+			if (area_a->has_area_monitor_callback() && area_b->is_monitorable()) {
 				area_a->add_area_to_query(area_b, shape_b, shape_a);
+			}
 
 		} else {
-			if (area_b->has_area_monitor_callback() && area_a->is_monitorable())
+			if (area_b->has_area_monitor_callback() && area_a->is_monitorable()) {
 				area_b->remove_area_from_query(area_a, shape_a, shape_b);
+			}
 
-			if (area_a->has_area_monitor_callback() && area_b->is_monitorable())
+			if (area_a->has_area_monitor_callback() && area_b->is_monitorable()) {
 				area_a->remove_area_from_query(area_b, shape_b, shape_a);
+			}
 		}
 
 		colliding = result;
@@ -133,11 +144,13 @@ Area2Pair3DSW::Area2Pair3DSW(Area3DSW *p_area_a, int p_shape_a, Area3DSW *p_area
 
 Area2Pair3DSW::~Area2Pair3DSW() {
 	if (colliding) {
-		if (area_b->has_area_monitor_callback())
+		if (area_b->has_area_monitor_callback()) {
 			area_b->remove_area_from_query(area_a, shape_a, shape_b);
+		}
 
-		if (area_a->has_area_monitor_callback())
+		if (area_a->has_area_monitor_callback()) {
 			area_a->remove_area_from_query(area_b, shape_b, shape_a);
+		}
 	}
 
 	area_a->remove_constraint(this);

servers/physics_3d/body_3d_sw.cpp

@@ -33,8 +33,9 @@
 #include "space_3d_sw.h"
 
 void Body3DSW::_update_inertia() {
-	if (get_space() && !inertia_update_list.in_list())
+	if (get_space() && !inertia_update_list.in_list()) {
 		get_space()->body_add_to_inertia_update_list(&inertia_update_list);
+	}
 }
 
 void Body3DSW::_update_transform_dependant() {
@@ -105,10 +106,11 @@ void Body3DSW::update_inertias() {
 			principal_inertia_axes_local = inertia_tensor.diagonalize().transposed();
 			_inv_inertia = inertia_tensor.get_main_diagonal().inverse();
 
-			if (mass)
+			if (mass) {
 				_inv_mass = 1.0 / mass;
-			else
+			} else {
 				_inv_mass = 0;
+			}
 
 		} break;
 
@@ -130,18 +132,22 @@ void Body3DSW::update_inertias() {
 }
 
 void Body3DSW::set_active(bool p_active) {
-	if (active == p_active)
+	if (active == p_active) {
 		return;
+	}
 
 	active = p_active;
 	if (!p_active) {
-		if (get_space())
+		if (get_space()) {
 			get_space()->body_remove_from_active_list(&active_list);
+		}
 	} else {
-		if (mode == PhysicsServer3D::BODY_MODE_STATIC)
+		if (mode == PhysicsServer3D::BODY_MODE_STATIC) {
 			return; //static bodies can't become active
-		if (get_space())
+		}
+		if (get_space()) {
 			get_space()->body_add_to_active_list(&active_list);
+		}
 
 		//still_time=0;
 	}
@@ -284,8 +290,9 @@ void Body3DSW::set_state(PhysicsServer3D::BodyState p_state, const Variant &p_va
 				Transform t = p_variant;
 				t.orthonormalize();
 				new_transform = get_transform(); //used as old to compute motion
-				if (new_transform == t)
+				if (new_transform == t) {
 					break;
+				}
 				_set_transform(t);
 				_set_inv_transform(get_transform().inverse());
 			}
@@ -311,8 +318,9 @@ void Body3DSW::set_state(PhysicsServer3D::BodyState p_state, const Variant &p_va
 		} break;
 		case PhysicsServer3D::BODY_STATE_SLEEPING: {
 			//?
-			if (mode == PhysicsServer3D::BODY_MODE_STATIC || mode == PhysicsServer3D::BODY_MODE_KINEMATIC)
+			if (mode == PhysicsServer3D::BODY_MODE_STATIC || mode == PhysicsServer3D::BODY_MODE_KINEMATIC) {
 				break;
+			}
 			bool do_sleep = p_variant;
 			if (do_sleep) {
 				linear_velocity = Vector3();
@@ -326,8 +334,9 @@ void Body3DSW::set_state(PhysicsServer3D::BodyState p_state, const Variant &p_va
 		} break;
 		case PhysicsServer3D::BODY_STATE_CAN_SLEEP: {
 			can_sleep = p_variant;
-			if (mode == PhysicsServer3D::BODY_MODE_RIGID && !active && !can_sleep)
+			if (mode == PhysicsServer3D::BODY_MODE_RIGID && !active && !can_sleep) {
 				set_active(true);
+			}
 
 		} break;
 	}
@@ -357,20 +366,24 @@ Variant Body3DSW::get_state(PhysicsServer3D::BodyState p_state) const {
 
 void Body3DSW::set_space(Space3DSW *p_space) {
 	if (get_space()) {
-		if (inertia_update_list.in_list())
+		if (inertia_update_list.in_list()) {
 			get_space()->body_remove_from_inertia_update_list(&inertia_update_list);
-		if (active_list.in_list())
+		}
+		if (active_list.in_list()) {
 			get_space()->body_remove_from_active_list(&active_list);
-		if (direct_state_query_list.in_list())
+		}
+		if (direct_state_query_list.in_list()) {
 			get_space()->body_remove_from_state_query_list(&direct_state_query_list);
+		}
 	}
 
 	_set_space(p_space);
 
 	if (get_space()) {
 		_update_inertia();
-		if (active)
+		if (active) {
 			get_space()->body_add_to_active_list(&active_list);
+		}
 		/*
 		_update_queries();
 		if (is_active()) {
@@ -412,8 +425,9 @@ bool Body3DSW::is_axis_locked(PhysicsServer3D::BodyAxis p_axis) const {
 }
 
 void Body3DSW::integrate_forces(real_t p_step) {
-	if (mode == PhysicsServer3D::BODY_MODE_STATIC)
+	if (mode == PhysicsServer3D::BODY_MODE_STATIC) {
 		return;
+	}
 
 	Area3DSW *def_area = get_space()->get_default_area();
 	// AreaSW *damp_area = def_area;
@@ -458,15 +472,17 @@ void Body3DSW::integrate_forces(real_t p_step) {
 	gravity *= gravity_scale;
 
 	// If less than 0, override dampenings with that of the Body
-	if (angular_damp >= 0)
+	if (angular_damp >= 0) {
 		area_angular_damp = angular_damp;
+	}
 	/*
 	else
 		area_angular_damp=damp_area->get_angular_damp();
 	*/
 
-	if (linear_damp >= 0)
+	if (linear_damp >= 0) {
 		area_linear_damp = linear_damp;
+	}
 	/*
 	else
 		area_linear_damp=damp_area->get_linear_damp();
@@ -501,13 +517,15 @@ void Body3DSW::integrate_forces(real_t p_step) {
 
 			real_t damp = 1.0 - p_step * area_linear_damp;
 
-			if (damp < 0) // reached zero in the given time
+			if (damp < 0) { // reached zero in the given time
 				damp = 0;
+			}
 
 			real_t angular_damp = 1.0 - p_step * area_angular_damp;
 
-			if (angular_damp < 0) // reached zero in the given time
+			if (angular_damp < 0) { // reached zero in the given time
 				angular_damp = 0;
+			}
 
 			linear_velocity *= damp;
 			angular_velocity *= angular_damp;
@@ -540,11 +558,13 @@ void Body3DSW::integrate_forces(real_t p_step) {
 }
 
 void Body3DSW::integrate_velocities(real_t p_step) {
-	if (mode == PhysicsServer3D::BODY_MODE_STATIC)
+	if (mode == PhysicsServer3D::BODY_MODE_STATIC) {
 		return;
+	}
 
-	if (fi_callback)
+	if (fi_callback) {
 		get_space()->body_add_to_state_query_list(&direct_state_query_list);
+	}
 
 	//apply axis lock linear
 	for (int i = 0; i < 3; i++) {
@@ -565,8 +585,9 @@ void Body3DSW::integrate_velocities(real_t p_step) {
 	if (mode == PhysicsServer3D::BODY_MODE_KINEMATIC) {
 		_set_transform(new_transform, false);
 		_set_inv_transform(new_transform.affine_inverse());
-		if (contacts.size() == 0 && linear_velocity == Vector3() && angular_velocity == Vector3())
+		if (contacts.size() == 0 && linear_velocity == Vector3() && angular_velocity == Vector3()) {
 			set_active(false); //stopped moving, deactivate
+		}
 
 		return;
 	}
@@ -647,14 +668,17 @@ void Body3DSW::wakeup_neighbours() {
 		int bc = c->get_body_count();
 
 		for (int i = 0; i < bc; i++) {
-			if (i == E->get())
+			if (i == E->get()) {
 				continue;
+			}
 			Body3DSW *b = n[i];
-			if (b->mode != PhysicsServer3D::BODY_MODE_RIGID)
+			if (b->mode != PhysicsServer3D::BODY_MODE_RIGID) {
 				continue;
+			}
 
-			if (!b->is_active())
+			if (!b->is_active()) {
 				b->set_active(true);
+			}
 		}
 	}
 }
@@ -680,12 +704,13 @@ void Body3DSW::call_queries() {
 }
 
 bool Body3DSW::sleep_test(real_t p_step) {
-	if (mode == PhysicsServer3D::BODY_MODE_STATIC || mode == PhysicsServer3D::BODY_MODE_KINEMATIC)
+	if (mode == PhysicsServer3D::BODY_MODE_STATIC || mode == PhysicsServer3D::BODY_MODE_KINEMATIC) {
 		return true; //
-	else if (mode == PhysicsServer3D::BODY_MODE_CHARACTER)
+	} else if (mode == PhysicsServer3D::BODY_MODE_CHARACTER) {
 		return !active; // characters don't sleep unless asked to sleep
-	else if (!can_sleep)
+	} else if (!can_sleep) {
 		return false;
+	}
 
 	if (Math::abs(angular_velocity.length()) < get_space()->get_body_angular_velocity_sleep_threshold() && Math::abs(linear_velocity.length_squared()) < get_space()->get_body_linear_velocity_sleep_threshold() * get_space()->get_body_linear_velocity_sleep_threshold()) {
 		still_time += p_step;
@@ -753,8 +778,9 @@ Body3DSW::Body3DSW() :
 }
 
 Body3DSW::~Body3DSW() {
-	if (fi_callback)
+	if (fi_callback) {
 		memdelete(fi_callback);
+	}
 }
 
 PhysicsDirectBodyState3DSW *PhysicsDirectBodyState3DSW::singleton = nullptr;

servers/physics_3d/body_3d_sw.h

@@ -163,16 +163,18 @@ public:
 		int index = areas.find(AreaCMP(p_area));
 		if (index > -1) {
 			areas.write[index].refCount -= 1;
-			if (areas[index].refCount < 1)
+			if (areas[index].refCount < 1) {
 				areas.remove(index);
+			}
 		}
 	}
 
 	_FORCE_INLINE_ void set_max_contacts_reported(int p_size) {
 		contacts.resize(p_size);
 		contact_count = 0;
-		if (mode == PhysicsServer3D::BODY_MODE_KINEMATIC && p_size)
+		if (mode == PhysicsServer3D::BODY_MODE_KINEMATIC && p_size) {
 			set_active(true);
+		}
 	}
 	_FORCE_INLINE_ int get_max_contacts_reported() const { return contacts.size(); }
 
@@ -259,8 +261,9 @@ public:
 	_FORCE_INLINE_ bool is_active() const { return active; }
 
 	_FORCE_INLINE_ void wakeup() {
-		if ((!get_space()) || mode == PhysicsServer3D::BODY_MODE_STATIC || mode == PhysicsServer3D::BODY_MODE_KINEMATIC)
+		if ((!get_space()) || mode == PhysicsServer3D::BODY_MODE_STATIC || mode == PhysicsServer3D::BODY_MODE_KINEMATIC) {
 			return;
+		}
 		set_active(true);
 	}
 
@@ -332,8 +335,9 @@ public:
 void Body3DSW::add_contact(const Vector3 &p_local_pos, const Vector3 &p_local_normal, real_t p_depth, int p_local_shape, const Vector3 &p_collider_pos, int p_collider_shape, ObjectID p_collider_instance_id, const RID &p_collider, const Vector3 &p_collider_velocity_at_pos) {
 	int c_max = contacts.size();
 
-	if (c_max == 0)
+	if (c_max == 0) {
 		return;
+	}
 
 	Contact *c = contacts.ptrw();
 
@@ -354,8 +358,9 @@ void Body3DSW::add_contact(const Vector3 &p_local_pos, const Vector3 &p_local_no
 		if (least_deep >= 0 && least_depth < p_depth) {
 			idx = least_deep;
 		}
-		if (idx == -1)
+		if (idx == -1) {
 			return; //none least deepe than this
+		}
 	}
 
 	c[idx].local_pos = p_local_pos;

servers/physics_3d/body_pair_3d_sw.cpp

@@ -162,8 +162,9 @@ void BodyPair3DSW::validate_contacts() {
 bool BodyPair3DSW::_test_ccd(real_t p_step, Body3DSW *p_A, int p_shape_A, const Transform &p_xform_A, Body3DSW *p_B, int p_shape_B, const Transform &p_xform_B) {
 	Vector3 motion = p_A->get_linear_velocity() * p_step;
 	real_t mlen = motion.length();
-	if (mlen < CMP_EPSILON)
+	if (mlen < CMP_EPSILON) {
 		return false;
+	}
 
 	Vector3 mnormal = motion / mlen;
 
@@ -257,12 +258,13 @@ bool BodyPair3DSW::setup(real_t p_step) {
 	real_t bias = (real_t)0.3;
 
 	if (shape_A_ptr->get_custom_bias() || shape_B_ptr->get_custom_bias()) {
-		if (shape_A_ptr->get_custom_bias() == 0)
+		if (shape_A_ptr->get_custom_bias() == 0) {
 			bias = shape_B_ptr->get_custom_bias();
-		else if (shape_B_ptr->get_custom_bias() == 0)
+		} else if (shape_B_ptr->get_custom_bias() == 0) {
 			bias = shape_A_ptr->get_custom_bias();
-		else
+		} else {
 			bias = (shape_B_ptr->get_custom_bias() + shape_A_ptr->get_custom_bias()) * 0.5;
+		}
 	}
 
 	real_t inv_dt = 1.0 / p_step;
@@ -338,13 +340,15 @@ bool BodyPair3DSW::setup(real_t p_step) {
 }
 
 void BodyPair3DSW::solve(real_t p_step) {
-	if (!collided)
+	if (!collided) {
 		return;
+	}
 
 	for (int i = 0; i < contact_count; i++) {
 		Contact &c = contacts[i];
-		if (!c.active)
+		if (!c.active) {
 			continue;
+		}
 
 		c.active = false; //try to deactivate, will activate itself if still needed
 

servers/physics_3d/broad_phase_3d_basic.cpp

@@ -107,8 +107,9 @@ int BroadPhase3DBasic::cull_point(const Vector3 &p_point, CollisionObject3DSW **
 			p_results[rc] = E->get().owner;
 			p_result_indices[rc] = E->get().subindex;
 			rc++;
-			if (rc >= p_max_results)
+			if (rc >= p_max_results) {
 				break;
+			}
 		}
 	}
 
@@ -124,8 +125,9 @@ int BroadPhase3DBasic::cull_segment(const Vector3 &p_from, const Vector3 &p_to,
 			p_results[rc] = E->get().owner;
 			p_result_indices[rc] = E->get().subindex;
 			rc++;
-			if (rc >= p_max_results)
+			if (rc >= p_max_results) {
 				break;
+			}
 		}
 	}
 
@@ -141,8 +143,9 @@ int BroadPhase3DBasic::cull_aabb(const AABB &p_aabb, CollisionObject3DSW **p_res
 			p_results[rc] = E->get().owner;
 			p_result_indices[rc] = E->get().subindex;
 			rc++;
-			if (rc >= p_max_results)
+			if (rc >= p_max_results) {
 				break;
+			}
 		}
 	}
 
@@ -166,8 +169,9 @@ void BroadPhase3DBasic::update() {
 			Element *elem_A = &I->get();
 			Element *elem_B = &J->get();
 
-			if (elem_A->owner == elem_B->owner)
+			if (elem_A->owner == elem_B->owner) {
 				continue;
+			}
 
 			bool pair_ok = elem_A->aabb.intersects(elem_B->aabb) && (!elem_A->_static || !elem_B->_static);
 
@@ -176,15 +180,17 @@ void BroadPhase3DBasic::update() {
 			Map<PairKey, void *>::Element *E = pair_map.find(key);
 
 			if (!pair_ok && E) {
-				if (unpair_callback)
+				if (unpair_callback) {
 					unpair_callback(elem_A->owner, elem_A->subindex, elem_B->owner, elem_B->subindex, E->get(), unpair_userdata);
+				}
 				pair_map.erase(key);
 			}
 
 			if (pair_ok && !E) {
 				void *data = nullptr;
-				if (pair_callback)
+				if (pair_callback) {
 					data = pair_callback(elem_A->owner, elem_A->subindex, elem_B->owner, elem_B->subindex, unpair_userdata);
+				}
 				pair_map.insert(key, data);
 			}
 		}

servers/physics_3d/broad_phase_octree.cpp

@@ -77,16 +77,18 @@ int BroadPhaseOctree::cull_aabb(const AABB &p_aabb, CollisionObject3DSW **p_resu
 
 void *BroadPhaseOctree::_pair_callback(void *self, OctreeElementID p_A, CollisionObject3DSW *p_object_A, int subindex_A, OctreeElementID p_B, CollisionObject3DSW *p_object_B, int subindex_B) {
 	BroadPhaseOctree *bpo = (BroadPhaseOctree *)(self);
-	if (!bpo->pair_callback)
+	if (!bpo->pair_callback) {
 		return nullptr;
+	}
 
 	return bpo->pair_callback(p_object_A, subindex_A, p_object_B, subindex_B, bpo->pair_userdata);
 }
 
 void BroadPhaseOctree::_unpair_callback(void *self, OctreeElementID p_A, CollisionObject3DSW *p_object_A, int subindex_A, OctreeElementID p_B, CollisionObject3DSW *p_object_B, int subindex_B, void *pairdata) {
 	BroadPhaseOctree *bpo = (BroadPhaseOctree *)(self);
-	if (!bpo->unpair_callback)
+	if (!bpo->unpair_callback) {
 		return;
+	}
 
 	bpo->unpair_callback(p_object_A, subindex_A, p_object_B, subindex_B, pairdata, bpo->unpair_userdata);
 }

servers/physics_3d/collision_object_3d_sw.cpp

@@ -95,8 +95,9 @@ void CollisionObject3DSW::remove_shape(int p_index) {
 	//remove anything from shape to be erased to end, so subindices don't change
 	ERR_FAIL_INDEX(p_index, shapes.size());
 	for (int i = p_index; i < shapes.size(); i++) {
-		if (shapes[i].bpid == 0)
+		if (shapes[i].bpid == 0) {
 			continue;
+		}
 		//should never get here with a null owner
 		space->get_broadphase()->remove(shapes[i].bpid);
 		shapes.write[i].bpid = 0;
@@ -112,12 +113,14 @@ void CollisionObject3DSW::remove_shape(int p_index) {
 }
 
 void CollisionObject3DSW::_set_static(bool p_static) {
-	if (_static == p_static)
+	if (_static == p_static) {
 		return;
+	}
 	_static = p_static;
 
-	if (!space)
+	if (!space) {
 		return;
+	}
 	for (int i = 0; i < get_shape_count(); i++) {
 		const Shape &s = shapes[i];
 		if (s.bpid > 0) {
@@ -137,8 +140,9 @@ void CollisionObject3DSW::_unregister_shapes() {
 }
 
 void CollisionObject3DSW::_update_shapes() {
-	if (!space)
+	if (!space) {
 		return;
+	}
 
 	for (int i = 0; i < shapes.size(); i++) {
 		Shape &s = shapes.write[i];
@@ -162,8 +166,9 @@ void CollisionObject3DSW::_update_shapes() {
 }
 
 void CollisionObject3DSW::_update_shapes_with_motion(const Vector3 &p_motion) {
-	if (!space)
+	if (!space) {
 		return;
+	}
 
 	for (int i = 0; i < shapes.size(); i++) {
 		Shape &s = shapes.write[i];

servers/physics_3d/collision_object_3d_sw.h

@@ -91,8 +91,9 @@ protected:
 #endif
 
 		transform = p_transform;
-		if (p_update_shapes)
+		if (p_update_shapes) {
 			_update_shapes();
+		}
 	}
 	_FORCE_INLINE_ void _set_inv_transform(const Transform &p_transform) { inv_transform = p_transform; }
 	void _set_static(bool p_static);

servers/physics_3d/collision_solver_3d_sat.cpp

@@ -42,10 +42,11 @@ struct _CollectorCallback {
 	Vector3 *prev_axis;
 
 	_FORCE_INLINE_ void call(const Vector3 &p_point_A, const Vector3 &p_point_B) {
-		if (swap)
+		if (swap) {
 			callback(p_point_B, p_point_A, userdata);
-		else
+		} else {
 			callback(p_point_A, p_point_B, userdata);
+		}
 	}
 };
 
@@ -116,10 +117,11 @@ static void _generate_contacts_edge_edge(const Vector3 *p_points_A, int p_point_
 
 	real_t d = (c.dot(p_points_B[0]) - p_points_A[0].dot(c)) / rel_A.dot(c);
 
-	if (d < 0.0)
+	if (d < 0.0) {
 		d = 0.0;
-	else if (d > 1.0)
+	} else if (d > 1.0) {
 		d = 1.0;
+	}
 
 	Vector3 closest_A = p_points_A[0] + rel_A * d;
 	Vector3 closest_B = Geometry::get_closest_point_to_segment_uncapped(closest_A, p_points_B);
@@ -207,8 +209,9 @@ static void _generate_contacts_face_face(const Vector3 *p_points_A, int p_point_
 
 		Vector3 closest_B = clipbuf_src[i] - plane_B.normal * d;
 
-		if (p_callback->normal.dot(clipbuf_src[i]) >= p_callback->normal.dot(closest_B))
+		if (p_callback->normal.dot(clipbuf_src[i]) >= p_callback->normal.dot(closest_B)) {
 			continue;
+		}
 
 		p_callback->call(clipbuf_src[i], closest_B);
 	}
@@ -282,10 +285,11 @@ class SeparatorAxisTest {
 
 public:
 	_FORCE_INLINE_ bool test_previous_axis() {
-		if (callback && callback->prev_axis && *callback->prev_axis != Vector3())
+		if (callback && callback->prev_axis && *callback->prev_axis != Vector3()) {
 			return test_axis(*callback->prev_axis);
-		else
+		} else {
 			return true;
+		}
 	}
 
 	_FORCE_INLINE_ bool test_axis(const Vector3 &p_axis) {
@@ -344,14 +348,16 @@ public:
 
 	_FORCE_INLINE_ void generate_contacts() {
 		// nothing to do, don't generate
-		if (best_axis == Vector3(0.0, 0.0, 0.0))
+		if (best_axis == Vector3(0.0, 0.0, 0.0)) {
 			return;
+		}
 
 		if (!callback->callback) {
 			//just was checking intersection?
 			callback->collided = true;
-			if (callback->prev_axis)
+			if (callback->prev_axis) {
 				*callback->prev_axis = best_axis;
+			}
 			return;
 		}
 
@@ -384,8 +390,9 @@ public:
 		}
 
 		callback->normal = best_axis;
-		if (callback->prev_axis)
+		if (callback->prev_axis) {
 			*callback->prev_axis = best_axis;
+		}
 		_generate_contacts_from_supports(supports_A, support_count_A, supports_B, support_count_B, callback);
 
 		callback->collided = true;
@@ -416,11 +423,13 @@ static void _collision_sphere_sphere(const Shape3DSW *p_a, const Transform &p_tr
 
 	// previous axis
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
-	if (!separator.test_axis((p_transform_a.origin - p_transform_b.origin).normalized()))
+	if (!separator.test_axis((p_transform_a.origin - p_transform_b.origin).normalized())) {
 		return;
+	}
 
 	separator.generate_contacts();
 }
@@ -432,16 +441,18 @@ static void _collision_sphere_box(const Shape3DSW *p_a, const Transform &p_trans
 
 	SeparatorAxisTest<SphereShape3DSW, BoxShape3DSW, withMargin> separator(sphere_A, p_transform_a, box_B, p_transform_b, p_collector, p_margin_a, p_margin_b);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
 	// test faces
 
 	for (int i = 0; i < 3; i++) {
 		Vector3 axis = p_transform_b.basis.get_axis(i).normalized();
 
-		if (!separator.test_axis(axis))
+		if (!separator.test_axis(axis)) {
 			return;
+		}
 	}
 
 	// calculate closest point to sphere
@@ -457,16 +468,18 @@ static void _collision_sphere_box(const Shape3DSW *p_a, const Transform &p_trans
 	// use point to test axis
 	Vector3 point_axis = (p_transform_a.origin - cpoint).normalized();
 
-	if (!separator.test_axis(point_axis))
+	if (!separator.test_axis(point_axis)) {
 		return;
+	}
 
 	// test edges
 
 	for (int i = 0; i < 3; i++) {
 		Vector3 axis = point_axis.cross(p_transform_b.basis.get_axis(i)).cross(p_transform_b.basis.get_axis(i)).normalized();
 
-		if (!separator.test_axis(axis))
+		if (!separator.test_axis(axis)) {
 			return;
+		}
 	}
 
 	separator.generate_contacts();
@@ -479,8 +492,9 @@ static void _collision_sphere_capsule(const Shape3DSW *p_a, const Transform &p_t
 
 	SeparatorAxisTest<SphereShape3DSW, CapsuleShape3DSW, withMargin> separator(sphere_A, p_transform_a, capsule_B, p_transform_b, p_collector, p_margin_a, p_margin_b);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
 	//capsule sphere 1, sphere
 
@@ -488,15 +502,17 @@ static void _collision_sphere_capsule(const Shape3DSW *p_a, const Transform &p_t
 
 	Vector3 capsule_ball_1 = p_transform_b.origin + capsule_axis;
 
-	if (!separator.test_axis((capsule_ball_1 - p_transform_a.origin).normalized()))
+	if (!separator.test_axis((capsule_ball_1 - p_transform_a.origin).normalized())) {
 		return;
+	}
 
 	//capsule sphere 2, sphere
 
 	Vector3 capsule_ball_2 = p_transform_b.origin - capsule_axis;
 
-	if (!separator.test_axis((capsule_ball_2 - p_transform_a.origin).normalized()))
+	if (!separator.test_axis((capsule_ball_2 - p_transform_a.origin).normalized())) {
 		return;
+	}
 
 	//capsule edge, sphere
 
@@ -504,8 +520,9 @@ static void _collision_sphere_capsule(const Shape3DSW *p_a, const Transform &p_t
 
 	Vector3 axis = b2a.cross(capsule_axis).cross(capsule_axis).normalized();
 
-	if (!separator.test_axis(axis))
+	if (!separator.test_axis(axis)) {
 		return;
+	}
 
 	separator.generate_contacts();
 }
@@ -521,8 +538,9 @@ static void _collision_sphere_convex_polygon(const Shape3DSW *p_a, const Transfo
 
 	SeparatorAxisTest<SphereShape3DSW, ConvexPolygonShape3DSW, withMargin> separator(sphere_A, p_transform_a, convex_polygon_B, p_transform_b, p_collector, p_margin_a, p_margin_b);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
 	const Geometry::MeshData &mesh = convex_polygon_B->get_mesh();
 
@@ -537,8 +555,9 @@ static void _collision_sphere_convex_polygon(const Shape3DSW *p_a, const Transfo
 	for (int i = 0; i < face_count; i++) {
 		Vector3 axis = p_transform_b.xform(faces[i].plane).normal;
 
-		if (!separator.test_axis(axis))
+		if (!separator.test_axis(axis)) {
 			return;
+		}
 	}
 
 	// edges of B
@@ -552,8 +571,9 @@ static void _collision_sphere_convex_polygon(const Shape3DSW *p_a, const Transfo
 
 		Vector3 axis = n1.cross(n2).cross(n1).normalized();
 
-		if (!separator.test_axis(axis))
+		if (!separator.test_axis(axis)) {
 			return;
+		}
 	}
 
 	// vertices of B
@@ -563,8 +583,9 @@ static void _collision_sphere_convex_polygon(const Shape3DSW *p_a, const Transfo
 
 		Vector3 axis = (v2 - v1).normalized();
 
-		if (!separator.test_axis(axis))
+		if (!separator.test_axis(axis)) {
 			return;
+		}
 	}
 
 	separator.generate_contacts();
@@ -583,8 +604,9 @@ static void _collision_sphere_face(const Shape3DSW *p_a, const Transform &p_tran
 		p_transform_b.xform(face_B->vertex[2]),
 	};
 
-	if (!separator.test_axis((vertex[0] - vertex[2]).cross(vertex[0] - vertex[1]).normalized()))
+	if (!separator.test_axis((vertex[0] - vertex[2]).cross(vertex[0] - vertex[1]).normalized())) {
 		return;
+	}
 
 	// edges and points of B
 	for (int i = 0; i < 3; i++) {
@@ -613,16 +635,18 @@ static void _collision_box_box(const Shape3DSW *p_a, const Transform &p_transfor
 
 	SeparatorAxisTest<BoxShape3DSW, BoxShape3DSW, withMargin> separator(box_A, p_transform_a, box_B, p_transform_b, p_collector, p_margin_a, p_margin_b);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
 	// test faces of A
 
 	for (int i = 0; i < 3; i++) {
 		Vector3 axis = p_transform_a.basis.get_axis(i).normalized();
 
-		if (!separator.test_axis(axis))
+		if (!separator.test_axis(axis)) {
 			return;
+		}
 	}
 
 	// test faces of B
@@ -630,8 +654,9 @@ static void _collision_box_box(const Shape3DSW *p_a, const Transform &p_transfor
 	for (int i = 0; i < 3; i++) {
 		Vector3 axis = p_transform_b.basis.get_axis(i).normalized();
 
-		if (!separator.test_axis(axis))
+		if (!separator.test_axis(axis)) {
 			return;
+		}
 	}
 
 	// test combined edges
@@ -639,8 +664,9 @@ static void _collision_box_box(const Shape3DSW *p_a, const Transform &p_transfor
 		for (int j = 0; j < 3; j++) {
 			Vector3 axis = p_transform_a.basis.get_axis(i).cross(p_transform_b.basis.get_axis(j));
 
-			if (Math::is_zero_approx(axis.length_squared()))
+			if (Math::is_zero_approx(axis.length_squared())) {
 				continue;
+			}
 			axis.normalize();
 
 			if (!separator.test_axis(axis)) {
@@ -684,14 +710,16 @@ static void _collision_box_box(const Shape3DSW *p_a, const Transform &p_transfor
 			//a ->b
 			Vector3 axis_a = p_transform_a.basis.get_axis(i);
 
-			if (!separator.test_axis(axis_ab.cross(axis_a).cross(axis_a).normalized()))
+			if (!separator.test_axis(axis_ab.cross(axis_a).cross(axis_a).normalized())) {
 				return;
+			}
 
 			//b ->a
 			Vector3 axis_b = p_transform_b.basis.get_axis(i);
 
-			if (!separator.test_axis(axis_ab.cross(axis_b).cross(axis_b).normalized()))
+			if (!separator.test_axis(axis_ab.cross(axis_b).cross(axis_b).normalized())) {
 				return;
+			}
 		}
 	}
 
@@ -705,15 +733,17 @@ static void _collision_box_capsule(const Shape3DSW *p_a, const Transform &p_tran
 
 	SeparatorAxisTest<BoxShape3DSW, CapsuleShape3DSW, withMargin> separator(box_A, p_transform_a, capsule_B, p_transform_b, p_collector, p_margin_a, p_margin_b);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
 	// faces of A
 	for (int i = 0; i < 3; i++) {
 		Vector3 axis = p_transform_a.basis.get_axis(i);
 
-		if (!separator.test_axis(axis))
+		if (!separator.test_axis(axis)) {
 			return;
+		}
 	}
 
 	Vector3 cyl_axis = p_transform_b.basis.get_axis(2).normalized();
@@ -724,11 +754,13 @@ static void _collision_box_capsule(const Shape3DSW *p_a, const Transform &p_tran
 		// cylinder
 		Vector3 box_axis = p_transform_a.basis.get_axis(i);
 		Vector3 axis = box_axis.cross(cyl_axis);
-		if (Math::is_zero_approx(axis.length_squared()))
+		if (Math::is_zero_approx(axis.length_squared())) {
 			continue;
+		}
 
-		if (!separator.test_axis(axis.normalized()))
+		if (!separator.test_axis(axis.normalized())) {
 			return;
+		}
 	}
 
 	// points of A, capsule cylinder
@@ -742,14 +774,16 @@ static void _collision_box_capsule(const Shape3DSW *p_a, const Transform &p_tran
 				he.y *= (j * 2 - 1);
 				he.z *= (k * 2 - 1);
 				Vector3 point = p_transform_a.origin;
-				for (int l = 0; l < 3; l++)
+				for (int l = 0; l < 3; l++) {
 					point += p_transform_a.basis.get_axis(l) * he[l];
+				}
 
 				//Vector3 axis = (point - cyl_axis * cyl_axis.dot(point)).normalized();
 				Vector3 axis = Plane(cyl_axis, 0).project(point).normalized();
 
-				if (!separator.test_axis(axis))
+				if (!separator.test_axis(axis)) {
 					return;
+				}
 			}
 		}
 	}
@@ -772,16 +806,18 @@ static void _collision_box_capsule(const Shape3DSW *p_a, const Transform &p_tran
 		// use point to test axis
 		Vector3 point_axis = (sphere_pos - cpoint).normalized();
 
-		if (!separator.test_axis(point_axis))
+		if (!separator.test_axis(point_axis)) {
 			return;
+		}
 
 		// test edges of A
 
 		for (int j = 0; j < 3; j++) {
 			Vector3 axis = point_axis.cross(p_transform_a.basis.get_axis(j)).cross(p_transform_a.basis.get_axis(j)).normalized();
 
-			if (!separator.test_axis(axis))
+			if (!separator.test_axis(axis)) {
 				return;
+			}
 		}
 	}
 
@@ -799,8 +835,9 @@ static void _collision_box_convex_polygon(const Shape3DSW *p_a, const Transform
 
 	SeparatorAxisTest<BoxShape3DSW, ConvexPolygonShape3DSW, withMargin> separator(box_A, p_transform_a, convex_polygon_B, p_transform_b, p_collector, p_margin_a, p_margin_b);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
 	const Geometry::MeshData &mesh = convex_polygon_B->get_mesh();
 
@@ -815,16 +852,18 @@ static void _collision_box_convex_polygon(const Shape3DSW *p_a, const Transform
 	for (int i = 0; i < 3; i++) {
 		Vector3 axis = p_transform_a.basis.get_axis(i).normalized();
 
-		if (!separator.test_axis(axis))
+		if (!separator.test_axis(axis)) {
 			return;
+		}
 	}
 
 	// faces of B
 	for (int i = 0; i < face_count; i++) {
 		Vector3 axis = p_transform_b.xform(faces[i].plane).normal;
 
-		if (!separator.test_axis(axis))
+		if (!separator.test_axis(axis)) {
 			return;
+		}
 	}
 
 	// A<->B edges
@@ -836,8 +875,9 @@ static void _collision_box_convex_polygon(const Shape3DSW *p_a, const Transform
 
 			Vector3 axis = e1.cross(e2).normalized();
 
-			if (!separator.test_axis(axis))
+			if (!separator.test_axis(axis)) {
 				return;
+			}
 		}
 	}
 
@@ -867,8 +907,9 @@ static void _collision_box_convex_polygon(const Shape3DSW *p_a, const Transform
 				//a ->b
 				Vector3 axis_a = p_transform_a.basis.get_axis(i);
 
-				if (!separator.test_axis(axis_ab.cross(axis_a).cross(axis_a).normalized()))
+				if (!separator.test_axis(axis_ab.cross(axis_a).cross(axis_a).normalized())) {
 					return;
+				}
 			}
 		}
 
@@ -881,16 +922,18 @@ static void _collision_box_convex_polygon(const Shape3DSW *p_a, const Transform
 					he.y *= (j * 2 - 1);
 					he.z *= (k * 2 - 1);
 					Vector3 point = p_transform_a.origin;
-					for (int l = 0; l < 3; l++)
+					for (int l = 0; l < 3; l++) {
 						point += p_transform_a.basis.get_axis(l) * he[l];
+					}
 
 					for (int e = 0; e < edge_count; e++) {
 						Vector3 p1 = p_transform_b.xform(vertices[edges[e].a]);
 						Vector3 p2 = p_transform_b.xform(vertices[edges[e].b]);
 						Vector3 n = (p2 - p1);
 
-						if (!separator.test_axis((point - p2).cross(n).cross(n).normalized()))
+						if (!separator.test_axis((point - p2).cross(n).cross(n).normalized())) {
 							return;
+						}
 					}
 				}
 			}
@@ -913,15 +956,17 @@ static void _collision_box_face(const Shape3DSW *p_a, const Transform &p_transfo
 		p_transform_b.xform(face_B->vertex[2]),
 	};
 
-	if (!separator.test_axis((vertex[0] - vertex[2]).cross(vertex[0] - vertex[1]).normalized()))
+	if (!separator.test_axis((vertex[0] - vertex[2]).cross(vertex[0] - vertex[1]).normalized())) {
 		return;
+	}
 
 	// faces of A
 	for (int i = 0; i < 3; i++) {
 		Vector3 axis = p_transform_a.basis.get_axis(i).normalized();
 
-		if (!separator.test_axis(axis))
+		if (!separator.test_axis(axis)) {
 			return;
+		}
 	}
 
 	// combined edges
@@ -932,8 +977,9 @@ static void _collision_box_face(const Shape3DSW *p_a, const Transform &p_transfo
 		for (int j = 0; j < 3; j++) {
 			Vector3 axis = p_transform_a.basis.get_axis(j);
 
-			if (!separator.test_axis(e.cross(axis).normalized()))
+			if (!separator.test_axis(e.cross(axis).normalized())) {
 				return;
+			}
 		}
 	}
 
@@ -962,8 +1008,9 @@ static void _collision_box_face(const Shape3DSW *p_a, const Transform &p_transfo
 				//a ->b
 				Vector3 axis_a = p_transform_a.basis.get_axis(i);
 
-				if (!separator.test_axis(axis_ab.cross(axis_a).cross(axis_a).normalized()))
+				if (!separator.test_axis(axis_ab.cross(axis_a).cross(axis_a).normalized())) {
 					return;
+				}
 			}
 		}
 
@@ -976,8 +1023,9 @@ static void _collision_box_face(const Shape3DSW *p_a, const Transform &p_transfo
 					he.y *= (j * 2 - 1);
 					he.z *= (k * 2 - 1);
 					Vector3 point = p_transform_a.origin;
-					for (int l = 0; l < 3; l++)
+					for (int l = 0; l < 3; l++) {
 						point += p_transform_a.basis.get_axis(l) * he[l];
+					}
 
 					for (int e = 0; e < 3; e++) {
 						Vector3 p1 = vertex[e];
@@ -985,8 +1033,9 @@ static void _collision_box_face(const Shape3DSW *p_a, const Transform &p_transfo
 
 						Vector3 n = (p2 - p1);
 
-						if (!separator.test_axis((point - p2).cross(n).cross(n).normalized()))
+						if (!separator.test_axis((point - p2).cross(n).cross(n).normalized())) {
 							return;
+						}
 					}
 				}
 			}
@@ -1003,8 +1052,9 @@ static void _collision_capsule_capsule(const Shape3DSW *p_a, const Transform &p_
 
 	SeparatorAxisTest<CapsuleShape3DSW, CapsuleShape3DSW, withMargin> separator(capsule_A, p_transform_a, capsule_B, p_transform_b, p_collector, p_margin_a, p_margin_b);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
 	// some values
 
@@ -1018,34 +1068,43 @@ static void _collision_capsule_capsule(const Shape3DSW *p_a, const Transform &p_
 
 	//balls-balls
 
-	if (!separator.test_axis((capsule_A_ball_1 - capsule_B_ball_1).normalized()))
+	if (!separator.test_axis((capsule_A_ball_1 - capsule_B_ball_1).normalized())) {
 		return;
-	if (!separator.test_axis((capsule_A_ball_1 - capsule_B_ball_2).normalized()))
+	}
+	if (!separator.test_axis((capsule_A_ball_1 - capsule_B_ball_2).normalized())) {
 		return;
+	}
 
-	if (!separator.test_axis((capsule_A_ball_2 - capsule_B_ball_1).normalized()))
+	if (!separator.test_axis((capsule_A_ball_2 - capsule_B_ball_1).normalized())) {
 		return;
-	if (!separator.test_axis((capsule_A_ball_2 - capsule_B_ball_2).normalized()))
+	}
+	if (!separator.test_axis((capsule_A_ball_2 - capsule_B_ball_2).normalized())) {
 		return;
+	}
 
 	// edges-balls
 
-	if (!separator.test_axis((capsule_A_ball_1 - capsule_B_ball_1).cross(capsule_A_axis).cross(capsule_A_axis).normalized()))
+	if (!separator.test_axis((capsule_A_ball_1 - capsule_B_ball_1).cross(capsule_A_axis).cross(capsule_A_axis).normalized())) {
 		return;
+	}
 
-	if (!separator.test_axis((capsule_A_ball_1 - capsule_B_ball_2).cross(capsule_A_axis).cross(capsule_A_axis).normalized()))
+	if (!separator.test_axis((capsule_A_ball_1 - capsule_B_ball_2).cross(capsule_A_axis).cross(capsule_A_axis).normalized())) {
 		return;
+	}
 
-	if (!separator.test_axis((capsule_B_ball_1 - capsule_A_ball_1).cross(capsule_B_axis).cross(capsule_B_axis).normalized()))
+	if (!separator.test_axis((capsule_B_ball_1 - capsule_A_ball_1).cross(capsule_B_axis).cross(capsule_B_axis).normalized())) {
 		return;
+	}
 
-	if (!separator.test_axis((capsule_B_ball_1 - capsule_A_ball_2).cross(capsule_B_axis).cross(capsule_B_axis).normalized()))
+	if (!separator.test_axis((capsule_B_ball_1 - capsule_A_ball_2).cross(capsule_B_axis).cross(capsule_B_axis).normalized())) {
 		return;
+	}
 
 	// edges
 
-	if (!separator.test_axis(capsule_A_axis.cross(capsule_B_axis).normalized()))
+	if (!separator.test_axis(capsule_A_axis.cross(capsule_B_axis).normalized())) {
 		return;
+	}
 
 	separator.generate_contacts();
 }
@@ -1061,8 +1120,9 @@ static void _collision_capsule_convex_polygon(const Shape3DSW *p_a, const Transf
 
 	SeparatorAxisTest<CapsuleShape3DSW, ConvexPolygonShape3DSW, withMargin> separator(capsule_A, p_transform_a, convex_polygon_B, p_transform_b, p_collector, p_margin_a, p_margin_b);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
 	const Geometry::MeshData &mesh = convex_polygon_B->get_mesh();
 
@@ -1076,8 +1136,9 @@ static void _collision_capsule_convex_polygon(const Shape3DSW *p_a, const Transf
 	for (int i = 0; i < face_count; i++) {
 		Vector3 axis = p_transform_b.xform(faces[i].plane).normal;
 
-		if (!separator.test_axis(axis))
+		if (!separator.test_axis(axis)) {
 			return;
+		}
 	}
 
 	// edges of B, capsule cylinder
@@ -1087,8 +1148,9 @@ static void _collision_capsule_convex_polygon(const Shape3DSW *p_a, const Transf
 		Vector3 edge_axis = p_transform_b.basis.xform(vertices[edges[i].a]) - p_transform_b.basis.xform(vertices[edges[i].b]);
 		Vector3 axis = edge_axis.cross(p_transform_a.basis.get_axis(2)).normalized();
 
-		if (!separator.test_axis(axis))
+		if (!separator.test_axis(axis)) {
 			return;
+		}
 	}
 
 	// capsule balls, edges of B
@@ -1106,8 +1168,9 @@ static void _collision_capsule_convex_polygon(const Shape3DSW *p_a, const Transf
 
 			Vector3 axis = n1.cross(n2).cross(n2).normalized();
 
-			if (!separator.test_axis(axis))
+			if (!separator.test_axis(axis)) {
 				return;
+			}
 		}
 	}
 
@@ -1127,8 +1190,9 @@ static void _collision_capsule_face(const Shape3DSW *p_a, const Transform &p_tra
 		p_transform_b.xform(face_B->vertex[2]),
 	};
 
-	if (!separator.test_axis((vertex[0] - vertex[2]).cross(vertex[0] - vertex[1]).normalized()))
+	if (!separator.test_axis((vertex[0] - vertex[2]).cross(vertex[0] - vertex[1]).normalized())) {
 		return;
+	}
 
 	// edges of B, capsule cylinder
 
@@ -1139,11 +1203,13 @@ static void _collision_capsule_face(const Shape3DSW *p_a, const Transform &p_tra
 		Vector3 edge_axis = vertex[i] - vertex[(i + 1) % 3];
 		Vector3 axis = edge_axis.cross(capsule_axis).normalized();
 
-		if (!separator.test_axis(axis))
+		if (!separator.test_axis(axis)) {
 			return;
+		}
 
-		if (!separator.test_axis((p_transform_a.origin - vertex[i]).cross(capsule_axis).cross(capsule_axis).normalized()))
+		if (!separator.test_axis((p_transform_a.origin - vertex[i]).cross(capsule_axis).cross(capsule_axis).normalized())) {
 			return;
+		}
 
 		for (int j = 0; j < 2; j++) {
 			// point-spheres
@@ -1151,15 +1217,17 @@ static void _collision_capsule_face(const Shape3DSW *p_a, const Transform &p_tra
 
 			Vector3 n1 = sphere_pos - vertex[i];
 
-			if (!separator.test_axis(n1.normalized()))
+			if (!separator.test_axis(n1.normalized())) {
 				return;
+			}
 
 			Vector3 n2 = edge_axis;
 
 			axis = n1.cross(n2).cross(n2);
 
-			if (!separator.test_axis(axis.normalized()))
+			if (!separator.test_axis(axis.normalized())) {
 				return;
+			}
 		}
 	}
 
@@ -1185,8 +1253,9 @@ static void _collision_convex_polygon_convex_polygon(const Shape3DSW *p_a, const
 
 	SeparatorAxisTest<ConvexPolygonShape3DSW, ConvexPolygonShape3DSW, withMargin> separator(convex_polygon_A, p_transform_a, convex_polygon_B, p_transform_b, p_collector, p_margin_a, p_margin_b);
 
-	if (!separator.test_previous_axis())
+	if (!separator.test_previous_axis()) {
 		return;
+	}
 
 	const Geometry::MeshData &mesh_A = convex_polygon_A->get_mesh();
 
@@ -1211,8 +1280,9 @@ static void _collision_convex_polygon_convex_polygon(const Shape3DSW *p_a, const
 		Vector3 axis = p_transform_a.xform(faces_A[i].plane).normal;
 		//Vector3 axis = p_transform_a.basis.xform( faces_A[i].plane.normal ).normalized();
 
-		if (!separator.test_axis(axis))
+		if (!separator.test_axis(axis)) {
 			return;
+		}
 	}
 
 	// faces of B
@@ -1220,8 +1290,9 @@ static void _collision_convex_polygon_convex_polygon(const Shape3DSW *p_a, const
 		Vector3 axis = p_transform_b.xform(faces_B[i].plane).normal;
 		//Vector3 axis = p_transform_b.basis.xform( faces_B[i].plane.normal ).normalized();
 
-		if (!separator.test_axis(axis))
+		if (!separator.test_axis(axis)) {
 			return;
+		}
 	}
 
 	// A<->B edges
@@ -1233,8 +1304,9 @@ static void _collision_convex_polygon_convex_polygon(const Shape3DSW *p_a, const
 
 			Vector3 axis = e1.cross(e2).normalized();
 
-			if (!separator.test_axis(axis))
+			if (!separator.test_axis(axis)) {
 				return;
+			}
 		}
 	}
 
@@ -1244,8 +1316,9 @@ static void _collision_convex_polygon_convex_polygon(const Shape3DSW *p_a, const
 			Vector3 va = p_transform_a.xform(vertices_A[i]);
 
 			for (int j = 0; j < vertex_count_B; j++) {
-				if (!separator.test_axis((va - p_transform_b.xform(vertices_B[j])).normalized()))
+				if (!separator.test_axis((va - p_transform_b.xform(vertices_B[j])).normalized())) {
 					return;
+				}
 			}
 		}
 		//edge-vertex (shell)
@@ -1258,8 +1331,9 @@ static void _collision_convex_polygon_convex_polygon(const Shape3DSW *p_a, const
 			for (int j = 0; j < vertex_count_B; j++) {
 				Vector3 e3 = p_transform_b.xform(vertices_B[j]);
 
-				if (!separator.test_axis((e1 - e3).cross(n).cross(n).normalized()))
+				if (!separator.test_axis((e1 - e3).cross(n).cross(n).normalized())) {
 					return;
+				}
 			}
 		}
 
@@ -1271,8 +1345,9 @@ static void _collision_convex_polygon_convex_polygon(const Shape3DSW *p_a, const
 			for (int j = 0; j < vertex_count_A; j++) {
 				Vector3 e3 = p_transform_a.xform(vertices_A[j]);
 
-				if (!separator.test_axis((e1 - e3).cross(n).cross(n).normalized()))
+				if (!separator.test_axis((e1 - e3).cross(n).cross(n).normalized())) {
 					return;
+				}
 			}
 		}
 	}
@@ -1302,16 +1377,18 @@ static void _collision_convex_polygon_face(const Shape3DSW *p_a, const Transform
 		p_transform_b.xform(face_B->vertex[2]),
 	};
 
-	if (!separator.test_axis((vertex[0] - vertex[2]).cross(vertex[0] - vertex[1]).normalized()))
+	if (!separator.test_axis((vertex[0] - vertex[2]).cross(vertex[0] - vertex[1]).normalized())) {
 		return;
+	}
 
 	// faces of A
 	for (int i = 0; i < face_count; i++) {
 		//Vector3 axis = p_transform_a.xform( faces[i].plane ).normal;
 		Vector3 axis = p_transform_a.basis.xform(faces[i].plane.normal).normalized();
 
-		if (!separator.test_axis(axis))
+		if (!separator.test_axis(axis)) {
 			return;
+		}
 	}
 
 	// A<->B edges
@@ -1323,8 +1400,9 @@ static void _collision_convex_polygon_face(const Shape3DSW *p_a, const Transform
 
 			Vector3 axis = e1.cross(e2).normalized();
 
-			if (!separator.test_axis(axis))
+			if (!separator.test_axis(axis)) {
 				return;
+			}
 		}
 	}
 
@@ -1334,8 +1412,9 @@ static void _collision_convex_polygon_face(const Shape3DSW *p_a, const Transform
 			Vector3 va = p_transform_a.xform(vertices[i]);
 
 			for (int j = 0; j < 3; j++) {
-				if (!separator.test_axis((va - vertex[j]).normalized()))
+				if (!separator.test_axis((va - vertex[j]).normalized())) {
 					return;
+				}
 			}
 		}
 		//edge-vertex (shell)
@@ -1348,8 +1427,9 @@ static void _collision_convex_polygon_face(const Shape3DSW *p_a, const Transform
 			for (int j = 0; j < 3; j++) {
 				Vector3 e3 = vertex[j];
 
-				if (!separator.test_axis((e1 - e3).cross(n).cross(n).normalized()))
+				if (!separator.test_axis((e1 - e3).cross(n).cross(n).normalized())) {
 					return;
+				}
 			}
 		}
 
@@ -1361,8 +1441,9 @@ static void _collision_convex_polygon_face(const Shape3DSW *p_a, const Transform
 			for (int j = 0; j < vertex_count; j++) {
 				Vector3 e3 = p_transform_a.xform(vertices[j]);
 
-				if (!separator.test_axis((e1 - e3).cross(n).cross(n).normalized()))
+				if (!separator.test_axis((e1 - e3).cross(n).cross(n).normalized())) {
 					return;
+				}
 			}
 		}
 	}

servers/physics_3d/collision_solver_3d_sw.cpp

@@ -38,8 +38,9 @@
 
 bool CollisionSolver3DSW::solve_static_plane(const Shape3DSW *p_shape_A, const Transform &p_transform_A, const Shape3DSW *p_shape_B, const Transform &p_transform_B, CallbackResult p_result_callback, void *p_userdata, bool p_swap_result) {
 	const PlaneShape3DSW *plane = static_cast<const PlaneShape3DSW *>(p_shape_A);
-	if (p_shape_B->get_type() == PhysicsServer3D::SHAPE_PLANE)
+	if (p_shape_B->get_type() == PhysicsServer3D::SHAPE_PLANE) {
 		return false;
+	}
 	Plane p = p_transform_A.xform(plane->get_plane());
 
 	static const int max_supports = 16;
@@ -52,17 +53,19 @@ bool CollisionSolver3DSW::solve_static_plane(const Shape3DSW *p_shape_A, const T
 
 	for (int i = 0; i < support_count; i++) {
 		supports[i] = p_transform_B.xform(supports[i]);
-		if (p.distance_to(supports[i]) >= 0)
+		if (p.distance_to(supports[i]) >= 0) {
 			continue;
+		}
 		found = true;
 
 		Vector3 support_A = p.project(supports[i]);
 
 		if (p_result_callback) {
-			if (p_swap_result)
+			if (p_swap_result) {
 				p_result_callback(supports[i], support_A, p_userdata);
-			else
+			} else {
 				p_result_callback(support_A, supports[i], p_userdata);
+			}
 		}
 	}
 
@@ -82,8 +85,9 @@ bool CollisionSolver3DSW::solve_ray(const Shape3DSW *p_shape_A, const Transform
 	to = ai.xform(to);
 
 	Vector3 p, n;
-	if (!p_shape_B->intersect_segment(from, to, p, n))
+	if (!p_shape_B->intersect_segment(from, to, p, n)) {
 		return false;
+	}
 
 	Vector3 support_B = p_transform_B.xform(p);
 	if (ray->get_slips_on_slope()) {
@@ -92,10 +96,11 @@ bool CollisionSolver3DSW::solve_ray(const Shape3DSW *p_shape_A, const Transform
 	}
 
 	if (p_result_callback) {
-		if (p_swap_result)
+		if (p_swap_result) {
 			p_result_callback(support_B, support_A, p_userdata);
-		else
+		} else {
 			p_result_callback(support_A, support_B, p_userdata);
+		}
 	}
 	return true;
 }
@@ -121,8 +126,9 @@ void CollisionSolver3DSW::concave_callback(void *p_userdata, Shape3DSW *p_convex
 	cinfo.aabb_tests++;
 
 	bool collided = collision_solver(cinfo.shape_A, *cinfo.transform_A, p_convex, *cinfo.transform_B, cinfo.result_callback, cinfo.userdata, cinfo.swap_result, nullptr, cinfo.margin_A, cinfo.margin_B);
-	if (!collided)
+	if (!collided) {
 		return;
+	}
 
 	cinfo.collided = true;
 	cinfo.collisions++;
@@ -187,8 +193,9 @@ bool CollisionSolver3DSW::solve_static(const Shape3DSW *p_shape_A, const Transfo
 	}
 
 	if (type_A == PhysicsServer3D::SHAPE_PLANE) {
-		if (type_B == PhysicsServer3D::SHAPE_PLANE)
+		if (type_B == PhysicsServer3D::SHAPE_PLANE) {
 			return false;
+		}
 		if (type_B == PhysicsServer3D::SHAPE_RAY) {
 			return false;
 		}
@@ -200,8 +207,9 @@ bool CollisionSolver3DSW::solve_static(const Shape3DSW *p_shape_A, const Transfo
 		}
 
 	} else if (type_A == PhysicsServer3D::SHAPE_RAY) {
-		if (type_B == PhysicsServer3D::SHAPE_RAY)
+		if (type_B == PhysicsServer3D::SHAPE_RAY) {
 			return false;
+		}
 
 		if (swap) {
 			return solve_ray(p_shape_B, p_transform_B, p_shape_A, p_transform_A, p_result_callback, p_userdata, true);
@@ -210,13 +218,15 @@ bool CollisionSolver3DSW::solve_static(const Shape3DSW *p_shape_A, const Transfo
 		}
 
 	} else if (concave_B) {
-		if (concave_A)
+		if (concave_A) {
 			return false;
+		}
 
-		if (!swap)
+		if (!swap) {
 			return solve_concave(p_shape_A, p_transform_A, p_shape_B, p_transform_B, p_result_callback, p_userdata, false, p_margin_A, p_margin_B);
-		else
+		} else {
 			return solve_concave(p_shape_B, p_transform_B, p_shape_A, p_transform_A, p_result_callback, p_userdata, true, p_margin_A, p_margin_B);
+		}
 
 	} else {
 		return collision_solver(p_shape_A, p_transform_A, p_shape_B, p_transform_B, p_result_callback, p_userdata, false, r_sep_axis, p_margin_A, p_margin_B);
@@ -226,14 +236,16 @@ bool CollisionSolver3DSW::solve_static(const Shape3DSW *p_shape_A, const Transfo
 void CollisionSolver3DSW::concave_distance_callback(void *p_userdata, Shape3DSW *p_convex) {
 	_ConcaveCollisionInfo &cinfo = *(_ConcaveCollisionInfo *)(p_userdata);
 	cinfo.aabb_tests++;
-	if (cinfo.collided)
+	if (cinfo.collided) {
 		return;
+	}
 
 	Vector3 close_A, close_B;
 	cinfo.collided = !gjk_epa_calculate_distance(cinfo.shape_A, *cinfo.transform_A, p_convex, *cinfo.transform_B, close_A, close_B);
 
-	if (cinfo.collided)
+	if (cinfo.collided) {
 		return;
+	}
 	if (!cinfo.tested || close_A.distance_squared_to(close_B) < cinfo.close_A.distance_squared_to(cinfo.close_B)) {
 		cinfo.close_A = close_A;
 		cinfo.close_B = close_B;
@@ -245,8 +257,9 @@ void CollisionSolver3DSW::concave_distance_callback(void *p_userdata, Shape3DSW
 
 bool CollisionSolver3DSW::solve_distance_plane(const Shape3DSW *p_shape_A, const Transform &p_transform_A, const Shape3DSW *p_shape_B, const Transform &p_transform_B, Vector3 &r_point_A, Vector3 &r_point_B) {
 	const PlaneShape3DSW *plane = static_cast<const PlaneShape3DSW *>(p_shape_A);
-	if (p_shape_B->get_type() == PhysicsServer3D::SHAPE_PLANE)
+	if (p_shape_B->get_type() == PhysicsServer3D::SHAPE_PLANE) {
 		return false;
+	}
 	Plane p = p_transform_A.xform(plane->get_plane());
 
 	static const int max_supports = 16;
@@ -265,8 +278,9 @@ bool CollisionSolver3DSW::solve_distance_plane(const Shape3DSW *p_shape_A, const
 		if (i == 0 || d < closest_d) {
 			closest = supports[i];
 			closest_d = d;
-			if (d <= 0)
+			if (d <= 0) {
 				collided = true;
+			}
 		}
 	}
 
@@ -277,8 +291,9 @@ bool CollisionSolver3DSW::solve_distance_plane(const Shape3DSW *p_shape_A, const
 }
 
 bool CollisionSolver3DSW::solve_distance(const Shape3DSW *p_shape_A, const Transform &p_transform_A, const Shape3DSW *p_shape_B, const Transform &p_transform_B, Vector3 &r_point_A, Vector3 &r_point_B, const AABB &p_concave_hint, Vector3 *r_sep_axis) {
-	if (p_shape_A->is_concave())
+	if (p_shape_A->is_concave()) {
 		return false;
+	}
 
 	if (p_shape_B->get_type() == PhysicsServer3D::SHAPE_PLANE) {
 		Vector3 a, b;
@@ -288,8 +303,9 @@ bool CollisionSolver3DSW::solve_distance(const Shape3DSW *p_shape_A, const Trans
 		return !col;
 
 	} else if (p_shape_B->is_concave()) {
-		if (p_shape_A->is_concave())
+		if (p_shape_A->is_concave()) {
 			return false;
+		}
 
 		const ConcaveShape3DSW *concave_B = static_cast<const ConcaveShape3DSW *>(p_shape_B);
 

servers/physics_3d/gjk_epa.cpp

@@ -123,10 +123,12 @@ struct	MinkowskiDiff {
 
 	_FORCE_INLINE_ Vector3	Support ( const Vector3& d,U index ) const
 	{
-		if ( index )
+		if ( index ) {
 			return ( Support1 ( d ) );
-		else
+		} else {
 			return ( Support0 ( d ) );
+
+}
 	}
 };
 
@@ -278,7 +280,9 @@ struct	GJK
 							m_free[m_nfree++]	=	cs.c[i];
 						}
 					}
-					if(mask==15) m_status=eStatus::Inside;
+					if(mask==15) { m_status=eStatus::Inside;
+
+}
 				}
 				else
 				{/* Return old simplex				*/
@@ -307,10 +311,14 @@ struct	GJK
 						Vector3		axis=Vector3(0,0,0);
 						axis[i]=1;
 						appendvertice(*m_simplex, axis);
-						if(EncloseOrigin())	return(true);
+						if(EncloseOrigin()) {	return(true);
+
+}
 						removevertice(*m_simplex);
 						appendvertice(*m_simplex,-axis);
-						if(EncloseOrigin())	return(true);
+						if(EncloseOrigin()) {	return(true);
+
+}
 						removevertice(*m_simplex);
 					}
 				}
@@ -326,10 +334,14 @@ struct	GJK
 						if(p.length_squared()>0)
 						{
 							appendvertice(*m_simplex, p);
-							if(EncloseOrigin())	return(true);
+							if(EncloseOrigin()) {	return(true);
+
+}
 							removevertice(*m_simplex);
 							appendvertice(*m_simplex,-p);
-							if(EncloseOrigin())	return(true);
+							if(EncloseOrigin()) {	return(true);
+
+}
 							removevertice(*m_simplex);
 						}
 					}
@@ -342,10 +354,14 @@ struct	GJK
 					if(n.length_squared()>0)
 					{
 						appendvertice(*m_simplex,n);
-						if(EncloseOrigin())	return(true);
+						if(EncloseOrigin()) {	return(true);
+
+}
 						removevertice(*m_simplex);
 						appendvertice(*m_simplex,-n);
-						if(EncloseOrigin())	return(true);
+						if(EncloseOrigin()) {	return(true);
+
+}
 						removevertice(*m_simplex);
 					}
 				}
@@ -354,8 +370,10 @@ struct	GJK
 				{
 					if(Math::abs(det(	m_simplex->c[0]->w-m_simplex->c[3]->w,
 						m_simplex->c[1]->w-m_simplex->c[3]->w,
-						m_simplex->c[2]->w-m_simplex->c[3]->w))>0)
+						m_simplex->c[2]->w-m_simplex->c[3]->w))>0) {
 						return(true);
+
+}
 				}
 				break;
 			}
@@ -561,15 +579,23 @@ struct	GJK
 			{
 				face->l[0]	=	nullptr;
 				face->l[1]	=	list.root;
-				if(list.root) list.root->l[0]=face;
+				if(list.root) { list.root->l[0]=face;
+
+}
 				list.root	=	face;
 				++list.count;
 			}
 			static inline void		remove(sList& list,sFace* face)
 			{
-				if(face->l[1]) face->l[1]->l[0]=face->l[0];
-				if(face->l[0]) face->l[0]->l[1]=face->l[1];
-				if(face==list.root) list.root=face->l[1];
+				if(face->l[1]) { face->l[1]->l[0]=face->l[0];
+
+}
+				if(face->l[0]) { face->l[0]->l[1]=face->l[1];
+
+}
+				if(face==list.root) { list.root=face->l[1];
+
+}
 				--list.count;
 			}
 
@@ -650,7 +676,9 @@ struct	GJK
 										remove(m_hull,best);
 										append(m_stock,best);
 										best=findbest();
-										if(best->p>=outer.p) outer=*best;
+										if(best->p>=outer.p) { outer=*best;
+
+}
 									} else { m_status=eStatus::InvalidHull;break; }
 								} else { m_status=eStatus::AccuraryReached;break; }
 							} else { m_status=eStatus::OutOfVertices;break; }
@@ -679,10 +707,12 @@ struct	GJK
 				m_status	=	eStatus::FallBack;
 				m_normal	=	-guess;
 				const real_t	nl=m_normal.length();
-				if(nl>0)
+				if(nl>0) {
 					m_normal	=	m_normal/nl;
-				else
+				} else {
 					m_normal	=	Vector3(1,0,0);
+
+}
 				m_depth	=	0;
 				m_result.rank=1;
 				m_result.c[0]=simplex.c[0];
@@ -716,8 +746,12 @@ struct	GJK
 						if(forced||(face->d>=-EPA_PLANE_EPS))
 						{
 							return(face);
-						} else m_status=eStatus::NonConvex;
-					} else m_status=eStatus::Degenerated;
+						} else { m_status=eStatus::NonConvex;
+
+}
+					} else { m_status=eStatus::Degenerated;
+
+}
 					remove(m_hull,face);
 					append(m_stock,face);
 					return(nullptr);
@@ -758,7 +792,9 @@ struct	GJK
 						if(nf)
 						{
 							bind(nf,0,f,e);
-							if(horizon.cf) bind(horizon.cf,1,nf,2); else horizon.ff=nf;
+							if(horizon.cf) { bind(horizon.cf,1,nf,2); } else { horizon.ff=nf;
+
+}
 							horizon.cf=nf;
 							++horizon.nf;
 							return(true);
@@ -880,7 +916,9 @@ bool Penetration(	const Shape3DSW*	shape0,
 				results.normal			=	-epa.m_normal;
 				results.distance		=	-epa.m_depth;
 				return(true);
-			} else results.status=sResults::EPA_Failed;
+			} else { results.status=sResults::EPA_Failed;
+
+}
 		}
 		break;
 	case	GJK::eStatus::Failed:
@@ -933,10 +971,11 @@ bool gjk_epa_calculate_penetration(const Shape3DSW *p_shape_A, const Transform &
 
 	if (GjkEpa2::Penetration(p_shape_A, p_transform_A, p_shape_B, p_transform_B, p_transform_B.origin - p_transform_A.origin, res)) {
 		if (p_result_callback) {
-			if (p_swap)
+			if (p_swap) {
 				p_result_callback(res.witnesses[1], res.witnesses[0], p_userdata);
-			else
+			} else {
 				p_result_callback(res.witnesses[0], res.witnesses[1], p_userdata);
+			}
 		}
 		return true;
 	}

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;
 }
@@ -325,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,
@@ -367,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,

servers/physics_3d/joints/pin_joint_3d_sw.cpp

@@ -109,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;

servers/physics_3d/physics_server_3d_sw.cpp

@@ -144,10 +144,11 @@ RID PhysicsServer3DSW::space_create() {
 void PhysicsServer3DSW::space_set_active(RID p_space, bool p_active) {
 	Space3DSW *space = space_owner.getornull(p_space);
 	ERR_FAIL_COND(!space);
-	if (p_active)
+	if (p_active) {
 		active_spaces.insert(space);
-	else
+	} else {
 		active_spaces.erase(space);
+	}
 }
 
 bool PhysicsServer3DSW::space_is_active(RID p_space) const {
@@ -213,8 +214,9 @@ void PhysicsServer3DSW::area_set_space(RID p_area, RID p_space) {
 		ERR_FAIL_COND(!space);
 	}
 
-	if (area->get_space() == space)
+	if (area->get_space() == space) {
 		return; //pointless
+	}
 
 	area->clear_constraints();
 	area->set_space(space);
@@ -225,8 +227,9 @@ RID PhysicsServer3DSW::area_get_space(RID p_area) const {
 	ERR_FAIL_COND_V(!area, RID());
 
 	Space3DSW *space = area->get_space();
-	if (!space)
+	if (!space) {
 		return RID();
+	}
 	return space->get_self();
 };
 
@@ -307,8 +310,9 @@ void PhysicsServer3DSW::area_clear_shapes(RID p_area) {
 	Area3DSW *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND(!area);
 
-	while (area->get_shape_count())
+	while (area->get_shape_count()) {
 		area->remove_shape(0);
+	}
 }
 
 void PhysicsServer3DSW::area_set_shape_disabled(RID p_area, int p_shape_idx, bool p_disabled) {
@@ -427,10 +431,12 @@ void PhysicsServer3DSW::area_set_area_monitor_callback(RID p_area, Object *p_rec
 
 RID PhysicsServer3DSW::body_create(BodyMode p_mode, bool p_init_sleeping) {
 	Body3DSW *body = memnew(Body3DSW);
-	if (p_mode != BODY_MODE_RIGID)
+	if (p_mode != BODY_MODE_RIGID) {
 		body->set_mode(p_mode);
-	if (p_init_sleeping)
+	}
+	if (p_init_sleeping) {
 		body->set_state(BODY_STATE_SLEEPING, p_init_sleeping);
+	}
 	RID rid = body_owner.make_rid(body);
 	body->set_self(rid);
 	return rid;
@@ -446,8 +452,9 @@ void PhysicsServer3DSW::body_set_space(RID p_body, RID p_space) {
 		ERR_FAIL_COND(!space);
 	}
 
-	if (body->get_space() == space)
+	if (body->get_space() == space) {
 		return; //pointless
+	}
 
 	body->clear_constraint_map();
 	body->set_space(space);
@@ -458,8 +465,9 @@ RID PhysicsServer3DSW::body_get_space(RID p_body) const {
 	ERR_FAIL_COND_V(!body, RID());
 
 	Space3DSW *space = body->get_space();
-	if (!space)
+	if (!space) {
 		return RID();
+	}
 	return space->get_self();
 };
 
@@ -549,8 +557,9 @@ void PhysicsServer3DSW::body_clear_shapes(RID p_body) {
 	Body3DSW *body = body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
-	while (body->get_shape_count())
+	while (body->get_shape_count()) {
 		body->remove_shape(0);
+	}
 }
 
 void PhysicsServer3DSW::body_set_enable_continuous_collision_detection(RID p_body, bool p_enable) {
@@ -1288,8 +1297,9 @@ void PhysicsServer3DSW::init() {
 void PhysicsServer3DSW::step(real_t p_step) {
 #ifndef _3D_DISABLED
 
-	if (!active)
+	if (!active) {
 		return;
+	}
 
 	_update_shapes();
 
@@ -1317,8 +1327,9 @@ void PhysicsServer3DSW::sync(){
 void PhysicsServer3DSW::flush_queries() {
 #ifndef _3D_DISABLED
 
-	if (!active)
+	if (!active) {
 		return;
+	}
 
 	doing_sync = true;
 
@@ -1399,8 +1410,9 @@ void PhysicsServer3DSW::_update_shapes() {
 void PhysicsServer3DSW::_shape_col_cbk(const Vector3 &p_point_A, const Vector3 &p_point_B, void *p_userdata) {
 	CollCbkData *cbk = (CollCbkData *)p_userdata;
 
-	if (cbk->max == 0)
+	if (cbk->max == 0) {
 		return;
+	}
 
 	if (cbk->amount == cbk->max) {
 		//find least deep
@@ -1415,8 +1427,9 @@ void PhysicsServer3DSW::_shape_col_cbk(const Vector3 &p_point_A, const Vector3 &
 		}
 
 		real_t d = p_point_A.distance_squared_to(p_point_B);
-		if (d < min_depth)
+		if (d < min_depth) {
 			return;
+		}
 		cbk->ptr[min_depth_idx * 2 + 0] = p_point_A;
 		cbk->ptr[min_depth_idx * 2 + 1] = p_point_B;
 

servers/physics_3d/shape_3d_sw.cpp

@@ -105,8 +105,9 @@ Vector3 PlaneShape3DSW::get_support(const Vector3 &p_normal) const {
 
 bool PlaneShape3DSW::intersect_segment(const Vector3 &p_begin, const Vector3 &p_end, Vector3 &r_result, Vector3 &r_normal) const {
 	bool inters = plane.intersects_segment(p_begin, p_end, &r_result);
-	if (inters)
+	if (inters) {
 		r_normal = plane.normal;
+	}
 	return inters;
 }
 
@@ -159,10 +160,11 @@ void RayShape3DSW::project_range(const Vector3 &p_normal, const Transform &p_tra
 }
 
 Vector3 RayShape3DSW::get_support(const Vector3 &p_normal) const {
-	if (p_normal.z > 0)
+	if (p_normal.z > 0) {
 		return Vector3(0, 0, length);
-	else
+	} else {
 		return Vector3(0, 0, 0);
+	}
 }
 
 void RayShape3DSW::get_supports(const Vector3 &p_normal, int p_max, Vector3 *r_supports, int &r_amount) const {
@@ -260,8 +262,9 @@ bool SphereShape3DSW::intersect_point(const Vector3 &p_point) const {
 Vector3 SphereShape3DSW::get_closest_point_to(const Vector3 &p_point) const {
 	Vector3 p = p_point;
 	float l = p.length();
-	if (l < radius)
+	if (l < radius) {
 		return p_point;
+	}
 	return (p / l) * radius;
 }
 
@@ -418,11 +421,13 @@ Vector3 BoxShape3DSW::get_closest_point_to(const Vector3 &p_point) const {
 		}
 	}
 
-	if (!outside)
+	if (!outside) {
 		return p_point; //it's inside, don't do anything else
+	}
 
-	if (outside == 1) //if only above one plane, this plane clearly wins
+	if (outside == 1) { //if only above one plane, this plane clearly wins
 		return min_point;
+	}
 
 	//check segments
 	float min_distance = 1e20;
@@ -597,8 +602,9 @@ Vector3 CapsuleShape3DSW::get_closest_point_to(const Vector3 &p_point) const {
 
 	Vector3 p = Geometry::get_closest_point_to_segment(p_point, s);
 
-	if (p.distance_to(p_point) < radius)
+	if (p.distance_to(p_point) < radius) {
 		return p_point;
+	}
 
 	return p + (p_point - p).normalized() * radius;
 }
@@ -641,18 +647,21 @@ CapsuleShape3DSW::CapsuleShape3DSW() {
 
 void ConvexPolygonShape3DSW::project_range(const Vector3 &p_normal, const Transform &p_transform, real_t &r_min, real_t &r_max) const {
 	int vertex_count = mesh.vertices.size();
-	if (vertex_count == 0)
+	if (vertex_count == 0) {
 		return;
+	}
 
 	const Vector3 *vrts = &mesh.vertices[0];
 
 	for (int i = 0; i < vertex_count; i++) {
 		real_t d = p_normal.dot(p_transform.xform(vrts[i]));
 
-		if (i == 0 || d > r_max)
+		if (i == 0 || d > r_max) {
 			r_max = d;
-		if (i == 0 || d < r_min)
+		}
+		if (i == 0 || d < r_min) {
 			r_min = d;
+		}
 	}
 }
 
@@ -663,8 +672,9 @@ Vector3 ConvexPolygonShape3DSW::get_support(const Vector3 &p_normal) const {
 	real_t support_max = 0;
 
 	int vertex_count = mesh.vertices.size();
-	if (vertex_count == 0)
+	if (vertex_count == 0) {
 		return Vector3();
+	}
 
 	const Vector3 *vrts = &mesh.vertices[0];
 
@@ -716,8 +726,9 @@ void ConvexPolygonShape3DSW::get_supports(const Vector3 &p_normal, int p_max, Ve
 				}
 			}
 
-			if (!valid)
+			if (!valid) {
 				continue;
+			}
 
 			int m = MIN(p_max, ic);
 			for (int j = 0; j < m; j++) {
@@ -754,8 +765,9 @@ bool ConvexPolygonShape3DSW::intersect_segment(const Vector3 &p_begin, const Vec
 	bool col = false;
 
 	for (int i = 0; i < fc; i++) {
-		if (faces[i].plane.normal.dot(n) > 0)
+		if (faces[i].plane.normal.dot(n) > 0) {
 			continue; //opposing face
+		}
 
 		int ic = faces[i].indices.size();
 		const int *ind = faces[i].indices.ptr();
@@ -785,8 +797,9 @@ bool ConvexPolygonShape3DSW::intersect_point(const Vector3 &p_point) const {
 	int fc = mesh.faces.size();
 
 	for (int i = 0; i < fc; i++) {
-		if (faces[i].plane.distance_to(p_point) >= 0)
+		if (faces[i].plane.distance_to(p_point) >= 0) {
 			return false;
+		}
 	}
 
 	return true;
@@ -799,8 +812,9 @@ Vector3 ConvexPolygonShape3DSW::get_closest_point_to(const Vector3 &p_point) con
 
 	bool all_inside = true;
 	for (int i = 0; i < fc; i++) {
-		if (!faces[i].plane.is_point_over(p_point))
+		if (!faces[i].plane.is_point_over(p_point)) {
 			continue;
+		}
 
 		all_inside = false;
 		bool is_inside = true;
@@ -861,16 +875,18 @@ Vector3 ConvexPolygonShape3DSW::get_moment_of_inertia(real_t p_mass) const {
 
 void ConvexPolygonShape3DSW::_setup(const Vector<Vector3> &p_vertices) {
 	Error err = QuickHull::build(p_vertices, mesh);
-	if (err != OK)
+	if (err != OK) {
 		ERR_PRINT("Failed to build QuickHull");
+	}
 
 	AABB _aabb;
 
 	for (int i = 0; i < mesh.vertices.size(); i++) {
-		if (i == 0)
+		if (i == 0) {
 			_aabb.position = mesh.vertices[i];
-		else
+		} else {
 			_aabb.expand_to(mesh.vertices[i]);
+		}
 	}
 
 	configure(_aabb);
@@ -894,11 +910,13 @@ void FaceShape3DSW::project_range(const Vector3 &p_normal, const Transform &p_tr
 		Vector3 v = p_transform.xform(vertex[i]);
 		real_t d = p_normal.dot(v);
 
-		if (i == 0 || d > r_max)
+		if (i == 0 || d > r_max) {
 			r_max = d;
+		}
 
-		if (i == 0 || d < r_min)
+		if (i == 0 || d < r_min) {
 			r_min = d;
+		}
 	}
 }
 
@@ -948,8 +966,9 @@ void FaceShape3DSW::get_supports(const Vector3 &p_normal, int p_max, Vector3 *r_
 
 	for (int i = 0; i < 3; i++) {
 		int nx = (i + 1) % 3;
-		if (i != vert_support_idx && nx != vert_support_idx)
+		if (i != vert_support_idx && nx != vert_support_idx) {
 			continue;
+		}
 
 		// check if edge is valid as a support
 		real_t dot = (vertex[i] - vertex[nx]).normalized().dot(n);
@@ -1021,17 +1040,20 @@ void ConcavePolygonShape3DSW::project_range(const Vector3 &p_normal, const Trans
 	for (int i = 0; i < count; i++) {
 		real_t d = p_normal.dot(p_transform.xform(vptr[i]));
 
-		if (i == 0 || d > r_max)
+		if (i == 0 || d > r_max) {
 			r_max = d;
-		if (i == 0 || d < r_min)
+		}
+		if (i == 0 || d < r_min) {
 			r_min = d;
+		}
 	}
 }
 
 Vector3 ConcavePolygonShape3DSW::get_support(const Vector3 &p_normal) const {
 	int count = vertices.size();
-	if (count == 0)
+	if (count == 0) {
 		return Vector3();
+	}
 
 	const Vector3 *vptr = vertices.ptr();
 
@@ -1091,16 +1113,19 @@ void ConcavePolygonShape3DSW::_cull_segment(int p_idx, _SegmentCullParams *p_par
 		}
 
 	} else {
-		if (bvh->left >= 0)
+		if (bvh->left >= 0) {
 			_cull_segment(bvh->left, p_params);
-		if (bvh->right >= 0)
+		}
+		if (bvh->right >= 0) {
 			_cull_segment(bvh->right, p_params);
+		}
 	}
 }
 
 bool ConcavePolygonShape3DSW::intersect_segment(const Vector3 &p_begin, const Vector3 &p_end, Vector3 &r_result, Vector3 &r_normal) const {
-	if (faces.size() == 0)
+	if (faces.size() == 0) {
 		return false;
+	}
 
 	// unlock data
 	const Face *fr = faces.ptr();
@@ -1141,8 +1166,9 @@ Vector3 ConcavePolygonShape3DSW::get_closest_point_to(const Vector3 &p_point) co
 void ConcavePolygonShape3DSW::_cull(int p_idx, _CullParams *p_params) const {
 	const BVH *bvh = &p_params->bvh[p_idx];
 
-	if (!p_params->aabb.intersects(bvh->aabb))
+	if (!p_params->aabb.intersects(bvh->aabb)) {
 		return;
+	}
 
 	if (bvh->face_index >= 0) {
 		const Face *f = &p_params->faces[bvh->face_index];
@@ -1166,8 +1192,9 @@ void ConcavePolygonShape3DSW::_cull(int p_idx, _CullParams *p_params) const {
 
 void ConcavePolygonShape3DSW::cull(const AABB &p_local_aabb, Callback p_callback, void *p_userdata) const {
 	// make matrix local to concave
-	if (faces.size() == 0)
+	if (faces.size() == 0) {
 		return;
+	}
 
 	AABB local_aabb = p_local_aabb;
 
@@ -1250,10 +1277,11 @@ _VolumeSW_BVH *_volume_sw_build_bvh(_VolumeSW_BVH_Element *p_elements, int p_siz
 
 	AABB aabb;
 	for (int i = 0; i < p_size; i++) {
-		if (i == 0)
+		if (i == 0) {
 			aabb = p_elements[i].aabb;
-		else
+		} else {
 			aabb.merge_with(p_elements[i].aabb);
+		}
 	}
 	bvh->aabb = aabb;
 	switch (aabb.get_longest_axis_index()) {
@@ -1345,10 +1373,11 @@ void ConcavePolygonShape3DSW::_setup(Vector<Vector3> p_faces) {
 		verticesw[i * 3 + 0] = face.vertex[0];
 		verticesw[i * 3 + 1] = face.vertex[1];
 		verticesw[i * 3 + 2] = face.vertex[2];
-		if (i == 0)
+		if (i == 0) {
 			_aabb = bvh_arrayw[i].aabb;
-		else
+		} else {
 			_aabb.merge_with(bvh_arrayw[i].aabb);
+		}
 	}
 
 	int count = 0;
@@ -1443,10 +1472,11 @@ void HeightMapShape3DSW::_setup(Vector<real_t> p_heights, int p_width, int p_dep
 			real_t h = r[i * width + j];
 
 			Vector3 pos(j * cell_size, h, i * cell_size);
-			if (i == 0 || j == 0)
+			if (i == 0 || j == 0) {
 				aabb.position = pos;
-			else
+			} else {
 				aabb.expand_to(pos);
+			}
 		}
 	}
 

servers/physics_3d/space_3d_sw.cpp

@@ -39,11 +39,13 @@ _FORCE_INLINE_ static bool _can_collide_with(CollisionObject3DSW *p_object, uint
 		return false;
 	}
 
-	if (p_object->get_type() == CollisionObject3DSW::TYPE_AREA && !p_collide_with_areas)
+	if (p_object->get_type() == CollisionObject3DSW::TYPE_AREA && !p_collide_with_areas) {
 		return false;
+	}
 
-	if (p_object->get_type() == CollisionObject3DSW::TYPE_BODY && !p_collide_with_bodies)
+	if (p_object->get_type() == CollisionObject3DSW::TYPE_BODY && !p_collide_with_bodies) {
 		return false;
+	}
 
 	return true;
 }
@@ -56,16 +58,19 @@ int PhysicsDirectSpaceState3DSW::intersect_point(const Vector3 &p_point, ShapeRe
 	//Transform ai = p_xform.affine_inverse();
 
 	for (int i = 0; i < amount; i++) {
-		if (cc >= p_result_max)
+		if (cc >= p_result_max) {
 			break;
+		}
 
-		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas))
+		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas)) {
 			continue;
+		}
 
 		//area can't be picked by ray (default)
 
-		if (p_exclude.has(space->intersection_query_results[i]->get_self()))
+		if (p_exclude.has(space->intersection_query_results[i]->get_self())) {
 			continue;
+		}
 
 		const CollisionObject3DSW *col_obj = space->intersection_query_results[i];
 		int shape_idx = space->intersection_query_subindex_results[i];
@@ -73,14 +78,16 @@ int PhysicsDirectSpaceState3DSW::intersect_point(const Vector3 &p_point, ShapeRe
 		Transform inv_xform = col_obj->get_transform() * col_obj->get_shape_transform(shape_idx);
 		inv_xform.affine_invert();
 
-		if (!col_obj->get_shape(shape_idx)->intersect_point(inv_xform.xform(p_point)))
+		if (!col_obj->get_shape(shape_idx)->intersect_point(inv_xform.xform(p_point))) {
 			continue;
+		}
 
 		r_results[cc].collider_id = col_obj->get_instance_id();
-		if (r_results[cc].collider_id.is_valid())
+		if (r_results[cc].collider_id.is_valid()) {
 			r_results[cc].collider = ObjectDB::get_instance(r_results[cc].collider_id);
-		else
+		} else {
 			r_results[cc].collider = nullptr;
+		}
 		r_results[cc].rid = col_obj->get_self();
 		r_results[cc].shape = shape_idx;
 
@@ -110,14 +117,17 @@ bool PhysicsDirectSpaceState3DSW::intersect_ray(const Vector3 &p_from, const Vec
 	real_t min_d = 1e10;
 
 	for (int i = 0; i < amount; i++) {
-		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas))
+		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas)) {
 			continue;
+		}
 
-		if (p_pick_ray && !(space->intersection_query_results[i]->is_ray_pickable()))
+		if (p_pick_ray && !(space->intersection_query_results[i]->is_ray_pickable())) {
 			continue;
+		}
 
-		if (p_exclude.has(space->intersection_query_results[i]->get_self()))
+		if (p_exclude.has(space->intersection_query_results[i]->get_self())) {
 			continue;
+		}
 
 		const CollisionObject3DSW *col_obj = space->intersection_query_results[i];
 
@@ -148,14 +158,16 @@ bool PhysicsDirectSpaceState3DSW::intersect_ray(const Vector3 &p_from, const Vec
 		}
 	}
 
-	if (!collided)
+	if (!collided) {
 		return false;
+	}
 
 	r_result.collider_id = res_obj->get_instance_id();
-	if (r_result.collider_id.is_valid())
+	if (r_result.collider_id.is_valid()) {
 		r_result.collider = ObjectDB::get_instance(r_result.collider_id);
-	else
+	} else {
 		r_result.collider = nullptr;
+	}
 	r_result.normal = res_normal;
 	r_result.position = res_point;
 	r_result.rid = res_obj->get_self();
@@ -165,8 +177,9 @@ bool PhysicsDirectSpaceState3DSW::intersect_ray(const Vector3 &p_from, const Vec
 }
 
 int PhysicsDirectSpaceState3DSW::intersect_shape(const RID &p_shape, const Transform &p_xform, real_t p_margin, ShapeResult *r_results, int p_result_max, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas) {
-	if (p_result_max <= 0)
+	if (p_result_max <= 0) {
 		return 0;
+	}
 
 	Shape3DSW *shape = static_cast<PhysicsServer3DSW *>(PhysicsServer3D::get_singleton())->shape_owner.getornull(p_shape);
 	ERR_FAIL_COND_V(!shape, 0);
@@ -180,29 +193,34 @@ int PhysicsDirectSpaceState3DSW::intersect_shape(const RID &p_shape, const Trans
 	//Transform ai = p_xform.affine_inverse();
 
 	for (int i = 0; i < amount; i++) {
-		if (cc >= p_result_max)
+		if (cc >= p_result_max) {
 			break;
+		}
 
-		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas))
+		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas)) {
 			continue;
+		}
 
 		//area can't be picked by ray (default)
 
-		if (p_exclude.has(space->intersection_query_results[i]->get_self()))
+		if (p_exclude.has(space->intersection_query_results[i]->get_self())) {
 			continue;
+		}
 
 		const CollisionObject3DSW *col_obj = space->intersection_query_results[i];
 		int shape_idx = space->intersection_query_subindex_results[i];
 
-		if (!CollisionSolver3DSW::solve_static(shape, p_xform, col_obj->get_shape(shape_idx), col_obj->get_transform() * col_obj->get_shape_transform(shape_idx), nullptr, nullptr, nullptr, p_margin, 0))
+		if (!CollisionSolver3DSW::solve_static(shape, p_xform, col_obj->get_shape(shape_idx), col_obj->get_transform() * col_obj->get_shape_transform(shape_idx), nullptr, nullptr, nullptr, p_margin, 0)) {
 			continue;
+		}
 
 		if (r_results) {
 			r_results[cc].collider_id = col_obj->get_instance_id();
-			if (r_results[cc].collider_id.is_valid())
+			if (r_results[cc].collider_id.is_valid()) {
 				r_results[cc].collider = ObjectDB::get_instance(r_results[cc].collider_id);
-			else
+			} else {
 				r_results[cc].collider = nullptr;
+			}
 			r_results[cc].rid = col_obj->get_self();
 			r_results[cc].shape = shape_idx;
 		}
@@ -236,11 +254,13 @@ bool PhysicsDirectSpaceState3DSW::cast_motion(const RID &p_shape, const Transfor
 	Vector3 closest_A, closest_B;
 
 	for (int i = 0; i < amount; i++) {
-		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas))
+		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas)) {
 			continue;
+		}
 
-		if (p_exclude.has(space->intersection_query_results[i]->get_self()))
+		if (p_exclude.has(space->intersection_query_results[i]->get_self())) {
 			continue; //ignore excluded
+		}
 
 		const CollisionObject3DSW *col_obj = space->intersection_query_results[i];
 		int shape_idx = space->intersection_query_subindex_results[i];
@@ -316,8 +336,9 @@ bool PhysicsDirectSpaceState3DSW::cast_motion(const RID &p_shape, const Transfor
 }
 
 bool PhysicsDirectSpaceState3DSW::collide_shape(RID p_shape, const Transform &p_shape_xform, real_t p_margin, Vector3 *r_results, int p_result_max, int &r_result_count, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas) {
-	if (p_result_max <= 0)
+	if (p_result_max <= 0) {
 		return false;
+	}
 
 	Shape3DSW *shape = static_cast<PhysicsServer3DSW *>(PhysicsServer3D::get_singleton())->shape_owner.getornull(p_shape);
 	ERR_FAIL_COND_V(!shape, 0);
@@ -339,8 +360,9 @@ bool PhysicsDirectSpaceState3DSW::collide_shape(RID p_shape, const Transform &p_
 	PhysicsServer3DSW::CollCbkData *cbkptr = &cbk;
 
 	for (int i = 0; i < amount; i++) {
-		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas))
+		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas)) {
 			continue;
+		}
 
 		const CollisionObject3DSW *col_obj = space->intersection_query_results[i];
 		int shape_idx = space->intersection_query_subindex_results[i];
@@ -375,10 +397,12 @@ static void _rest_cbk_result(const Vector3 &p_point_A, const Vector3 &p_point_B,
 
 	Vector3 contact_rel = p_point_B - p_point_A;
 	real_t len = contact_rel.length();
-	if (len < rd->min_allowed_depth)
+	if (len < rd->min_allowed_depth) {
 		return;
-	if (len <= rd->best_len)
+	}
+	if (len <= rd->best_len) {
 		return;
+	}
 
 	rd->best_len = len;
 	rd->best_contact = p_point_B;
@@ -403,24 +427,28 @@ bool PhysicsDirectSpaceState3DSW::rest_info(RID p_shape, const Transform &p_shap
 	rcd.min_allowed_depth = space->test_motion_min_contact_depth;
 
 	for (int i = 0; i < amount; i++) {
-		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas))
+		if (!_can_collide_with(space->intersection_query_results[i], p_collision_mask, p_collide_with_bodies, p_collide_with_areas)) {
 			continue;
+		}
 
 		const CollisionObject3DSW *col_obj = space->intersection_query_results[i];
 		int shape_idx = space->intersection_query_subindex_results[i];
 
-		if (p_exclude.has(col_obj->get_self()))
+		if (p_exclude.has(col_obj->get_self())) {
 			continue;
+		}
 
 		rcd.object = col_obj;
 		rcd.shape = shape_idx;
 		bool sc = CollisionSolver3DSW::solve_static(shape, p_shape_xform, col_obj->get_shape(shape_idx), col_obj->get_transform() * col_obj->get_shape_transform(shape_idx), _rest_cbk_result, &rcd, nullptr, p_margin);
-		if (!sc)
+		if (!sc) {
 			continue;
+		}
 	}
 
-	if (rcd.best_len == 0 || !rcd.best_object)
+	if (rcd.best_len == 0 || !rcd.best_object) {
 		return false;
+	}
 
 	r_info->collider_id = rcd.best_object->get_instance_id();
 	r_info->shape = rcd.best_shape;
@@ -454,8 +482,9 @@ Vector3 PhysicsDirectSpaceState3DSW::get_closest_point_to_object_volume(RID p_ob
 	bool shapes_found = false;
 
 	for (int i = 0; i < obj->get_shape_count(); i++) {
-		if (obj->is_shape_set_as_disabled(i))
+		if (obj->is_shape_set_as_disabled(i)) {
 			continue;
+		}
 
 		Transform shape_xform = obj->get_transform() * obj->get_shape_transform(i);
 		Shape3DSW *shape = obj->get_shape(i);
@@ -490,16 +519,17 @@ int Space3DSW::_cull_aabb_for_body(Body3DSW *p_body, const AABB &p_aabb) {
 	for (int i = 0; i < amount; i++) {
 		bool keep = true;
 
-		if (intersection_query_results[i] == p_body)
+		if (intersection_query_results[i] == p_body) {
 			keep = false;
-		else if (intersection_query_results[i]->get_type() == CollisionObject3DSW::TYPE_AREA)
+		} else if (intersection_query_results[i]->get_type() == CollisionObject3DSW::TYPE_AREA) {
 			keep = false;
-		else if ((static_cast<Body3DSW *>(intersection_query_results[i])->test_collision_mask(p_body)) == 0)
+		} else if ((static_cast<Body3DSW *>(intersection_query_results[i])->test_collision_mask(p_body)) == 0) {
 			keep = false;
-		else if (static_cast<Body3DSW *>(intersection_query_results[i])->has_exception(p_body->get_self()) || p_body->has_exception(intersection_query_results[i]->get_self()))
+		} else if (static_cast<Body3DSW *>(intersection_query_results[i])->has_exception(p_body->get_self()) || p_body->has_exception(intersection_query_results[i]->get_self())) {
 			keep = false;
-		else if (static_cast<Body3DSW *>(intersection_query_results[i])->is_shape_set_as_disabled(intersection_query_subindex_results[i]))
+		} else if (static_cast<Body3DSW *>(intersection_query_results[i])->is_shape_set_as_disabled(intersection_query_subindex_results[i])) {
 			keep = false;
+		}
 
 		if (!keep) {
 			if (i < amount - 1) {
@@ -521,8 +551,9 @@ int Space3DSW::test_body_ray_separation(Body3DSW *p_body, const Transform &p_tra
 	bool shapes_found = false;
 
 	for (int i = 0; i < p_body->get_shape_count(); i++) {
-		if (p_body->is_shape_set_as_disabled(i))
+		if (p_body->is_shape_set_as_disabled(i)) {
 			continue;
+		}
 
 		if (!shapes_found) {
 			body_aabb = p_body->get_shape_aabb(i);
@@ -567,13 +598,15 @@ int Space3DSW::test_body_ray_separation(Body3DSW *p_body, const Transform &p_tra
 			int amount = _cull_aabb_for_body(p_body, body_aabb);
 
 			for (int j = 0; j < p_body->get_shape_count(); j++) {
-				if (p_body->is_shape_set_as_disabled(j))
+				if (p_body->is_shape_set_as_disabled(j)) {
 					continue;
+				}
 
 				Shape3DSW *body_shape = p_body->get_shape(j);
 
-				if (body_shape->get_type() != PhysicsServer3D::SHAPE_RAY)
+				if (body_shape->get_type() != PhysicsServer3D::SHAPE_RAY) {
 					continue;
+				}
 
 				Transform body_shape_xform = body_transform * p_body->get_shape_transform(j);
 
@@ -681,8 +714,9 @@ bool Space3DSW::test_body_motion(Body3DSW *p_body, const Transform &p_from, cons
 	bool shapes_found = false;
 
 	for (int i = 0; i < p_body->get_shape_count(); i++) {
-		if (p_body->is_shape_set_as_disabled(i))
+		if (p_body->is_shape_set_as_disabled(i)) {
 			continue;
+		}
 
 		if (!shapes_found) {
 			body_aabb = p_body->get_shape_aabb(i);
@@ -728,8 +762,9 @@ bool Space3DSW::test_body_motion(Body3DSW *p_body, const Transform &p_from, cons
 			int amount = _cull_aabb_for_body(p_body, body_aabb);
 
 			for (int j = 0; j < p_body->get_shape_count(); j++) {
-				if (p_body->is_shape_set_as_disabled(j))
+				if (p_body->is_shape_set_as_disabled(j)) {
 					continue;
+				}
 
 				Transform body_shape_xform = body_transform * p_body->get_shape_transform(j);
 				Shape3DSW *body_shape = p_body->get_shape(j);
@@ -786,8 +821,9 @@ bool Space3DSW::test_body_motion(Body3DSW *p_body, const Transform &p_from, cons
 		int amount = _cull_aabb_for_body(p_body, motion_aabb);
 
 		for (int j = 0; j < p_body->get_shape_count(); j++) {
-			if (p_body->is_shape_set_as_disabled(j))
+			if (p_body->is_shape_set_as_disabled(j)) {
 				continue;
+			}
 
 			Transform body_shape_xform = body_transform * p_body->get_shape_transform(j);
 			Shape3DSW *body_shape = p_body->get_shape(j);
@@ -910,8 +946,9 @@ bool Space3DSW::test_body_motion(Body3DSW *p_body, const Transform &p_from, cons
 			rcd.object = col_obj;
 			rcd.shape = shape_idx;
 			bool sc = CollisionSolver3DSW::solve_static(body_shape, body_shape_xform, col_obj->get_shape(shape_idx), col_obj->get_transform() * col_obj->get_shape_transform(shape_idx), _rest_cbk_result, &rcd, nullptr, p_margin);
-			if (!sc)
+			if (!sc) {
 				continue;
+			}
 		}
 
 		if (rcd.best_len != 0) {
@@ -1179,8 +1216,9 @@ Space3DSW::Space3DSW() {
 	direct_access = memnew(PhysicsDirectSpaceState3DSW);
 	direct_access->space = this;
 
-	for (int i = 0; i < ELAPSED_TIME_MAX; i++)
+	for (int i = 0; i < ELAPSED_TIME_MAX; i++) {
 		elapsed_time[i] = 0;
+	}
 }
 
 Space3DSW::~Space3DSW() {

servers/physics_3d/space_3d_sw.h

@@ -185,8 +185,9 @@ public:
 	void set_debug_contacts(int p_amount) { contact_debug.resize(p_amount); }
 	_FORCE_INLINE_ bool is_debugging_contacts() const { return !contact_debug.empty(); }
 	_FORCE_INLINE_ void add_debug_contact(const Vector3 &p_contact) {
-		if (contact_debug_count < contact_debug.size())
+		if (contact_debug_count < contact_debug.size()) {
 			contact_debug.write[contact_debug_count++] = p_contact;
+		}
 	}
 	_FORCE_INLINE_ Vector<Vector3> get_debug_contacts() { return contact_debug; }
 	_FORCE_INLINE_ int get_debug_contact_count() { return contact_debug_count; }

servers/physics_3d/step_3d_sw.cpp

@@ -40,18 +40,21 @@ void Step3DSW::_populate_island(Body3DSW *p_body, Body3DSW **p_island, Constrain
 
 	for (Map<Constraint3DSW *, int>::Element *E = p_body->get_constraint_map().front(); E; E = E->next()) {
 		Constraint3DSW *c = (Constraint3DSW *)E->key();
-		if (c->get_island_step() == _step)
+		if (c->get_island_step() == _step) {
 			continue; //already processed
+		}
 		c->set_island_step(_step);
 		c->set_island_next(*p_constraint_island);
 		*p_constraint_island = c;
 
 		for (int i = 0; i < c->get_body_count(); i++) {
-			if (i == E->get())
+			if (i == E->get()) {
 				continue;
+			}
 			Body3DSW *b = c->get_body_ptr()[i];
-			if (b->get_island_step() == _step || b->get_mode() == PhysicsServer3D::BODY_MODE_STATIC || b->get_mode() == PhysicsServer3D::BODY_MODE_KINEMATIC)
+			if (b->get_island_step() == _step || b->get_mode() == PhysicsServer3D::BODY_MODE_STATIC || b->get_mode() == PhysicsServer3D::BODY_MODE_KINEMATIC) {
 				continue; //no go
+			}
 			_populate_island(c->get_body_ptr()[i], p_island, p_constraint_island);
 		}
 	}
@@ -110,8 +113,9 @@ void Step3DSW::_check_suspend(Body3DSW *p_island, real_t p_delta) {
 			continue; //ignore for static
 		}
 
-		if (!b->sleep_test(p_delta))
+		if (!b->sleep_test(p_delta)) {
 			can_sleep = false;
+		}
 
 		b = b->get_island_next();
 	}
@@ -127,8 +131,9 @@ void Step3DSW::_check_suspend(Body3DSW *p_island, real_t p_delta) {
 
 		bool active = b->is_active();
 
-		if (active == can_sleep)
+		if (active == can_sleep) {
 			b->set_active(!can_sleep);
+		}
 
 		b = b->get_island_next();
 	}
@@ -198,8 +203,9 @@ void Step3DSW::step(Space3DSW *p_space, real_t p_delta, int p_iterations) {
 	while (aml.first()) {
 		for (const Set<Constraint3DSW *>::Element *E = aml.first()->self()->get_constraints().front(); E; E = E->next()) {
 			Constraint3DSW *c = E->get();
-			if (c->get_island_step() == _step)
+			if (c->get_island_step() == _step) {
 				continue;
+			}
 			c->set_island_step(_step);
 			c->set_island_next(nullptr);
 			c->set_island_list_next(constraint_island_list);

servers/physics_server_2d.cpp

@@ -45,15 +45,17 @@ void PhysicsDirectBodyState2D::integrate_forces() {
 
 	float damp = 1.0 - step * get_total_linear_damp();
 
-	if (damp < 0) // reached zero in the given time
+	if (damp < 0) { // reached zero in the given time
 		damp = 0;
+	}
 
 	lv *= damp;
 
 	damp = 1.0 - step * get_total_angular_damp();
 
-	if (damp < 0) // reached zero in the given time
+	if (damp < 0) { // reached zero in the given time
 		damp = 0;
+	}
 
 	av *= damp;
 
@@ -177,8 +179,9 @@ int PhysicsShapeQueryParameters2D::get_collision_mask() const {
 
 void PhysicsShapeQueryParameters2D::set_exclude(const Vector<RID> &p_exclude) {
 	exclude.clear();
-	for (int i = 0; i < p_exclude.size(); i++)
+	for (int i = 0; i < p_exclude.size(); i++) {
 		exclude.insert(p_exclude[i]);
+	}
 }
 
 Vector<RID> PhysicsShapeQueryParameters2D::get_exclude() const {
@@ -254,13 +257,15 @@ PhysicsShapeQueryParameters2D::PhysicsShapeQueryParameters2D() {
 Dictionary PhysicsDirectSpaceState2D::_intersect_ray(const Vector2 &p_from, const Vector2 &p_to, const Vector<RID> &p_exclude, uint32_t p_layers, bool p_collide_with_bodies, bool p_collide_with_areas) {
 	RayResult inters;
 	Set<RID> exclude;
-	for (int i = 0; i < p_exclude.size(); i++)
+	for (int i = 0; i < p_exclude.size(); i++) {
 		exclude.insert(p_exclude[i]);
+	}
 
 	bool res = intersect_ray(p_from, p_to, inters, exclude, p_layers, p_collide_with_bodies, p_collide_with_areas);
 
-	if (!res)
+	if (!res) {
 		return Dictionary();
+	}
 
 	Dictionary d;
 	d["position"] = inters.position;
@@ -300,8 +305,9 @@ Array PhysicsDirectSpaceState2D::_cast_motion(const Ref<PhysicsShapeQueryParamet
 
 	float closest_safe, closest_unsafe;
 	bool res = cast_motion(p_shape_query->shape, p_shape_query->transform, p_shape_query->motion, p_shape_query->margin, closest_safe, closest_unsafe, p_shape_query->exclude, p_shape_query->collision_mask, p_shape_query->collide_with_bodies, p_shape_query->collide_with_areas);
-	if (!res)
+	if (!res) {
 		return Array();
+	}
 	Array ret;
 	ret.resize(2);
 	ret[0] = closest_safe;
@@ -311,20 +317,23 @@ Array PhysicsDirectSpaceState2D::_cast_motion(const Ref<PhysicsShapeQueryParamet
 
 Array PhysicsDirectSpaceState2D::_intersect_point_impl(const Vector2 &p_point, int p_max_results, const Vector<RID> &p_exclude, uint32_t p_layers, bool p_collide_with_bodies, bool p_collide_with_areas, bool p_filter_by_canvas, ObjectID p_canvas_instance_id) {
 	Set<RID> exclude;
-	for (int i = 0; i < p_exclude.size(); i++)
+	for (int i = 0; i < p_exclude.size(); i++) {
 		exclude.insert(p_exclude[i]);
+	}
 
 	Vector<ShapeResult> ret;
 	ret.resize(p_max_results);
 
 	int rc;
-	if (p_filter_by_canvas)
+	if (p_filter_by_canvas) {
 		rc = intersect_point(p_point, ret.ptrw(), ret.size(), exclude, p_layers, p_collide_with_bodies, p_collide_with_areas);
-	else
+	} else {
 		rc = intersect_point_on_canvas(p_point, p_canvas_instance_id, ret.ptrw(), ret.size(), exclude, p_layers, p_collide_with_bodies, p_collide_with_areas);
+	}
 
-	if (rc == 0)
+	if (rc == 0) {
 		return Array();
+	}
 
 	Array r;
 	r.resize(rc);
@@ -355,12 +364,14 @@ Array PhysicsDirectSpaceState2D::_collide_shape(const Ref<PhysicsShapeQueryParam
 	ret.resize(p_max_results * 2);
 	int rc = 0;
 	bool res = collide_shape(p_shape_query->shape, p_shape_query->transform, p_shape_query->motion, p_shape_query->margin, ret.ptrw(), p_max_results, rc, p_shape_query->exclude, p_shape_query->collision_mask, p_shape_query->collide_with_bodies, p_shape_query->collide_with_areas);
-	if (!res)
+	if (!res) {
 		return Array();
+	}
 	Array r;
 	r.resize(rc * 2);
-	for (int i = 0; i < rc * 2; i++)
+	for (int i = 0; i < rc * 2; i++) {
 		r[i] = ret[i];
+	}
 	return r;
 }
 
@@ -371,8 +382,9 @@ Dictionary PhysicsDirectSpaceState2D::_get_rest_info(const Ref<PhysicsShapeQuery
 
 	bool res = rest_info(p_shape_query->shape, p_shape_query->transform, p_shape_query->motion, p_shape_query->margin, &sri, p_shape_query->exclude, p_shape_query->collision_mask, p_shape_query->collide_with_bodies, p_shape_query->collide_with_areas);
 	Dictionary r;
-	if (!res)
+	if (!res) {
 		return r;
+	}
 
 	r["point"] = sri.point;
 	r["normal"] = sri.normal;
@@ -499,8 +511,9 @@ PhysicsTestMotionResult2D::PhysicsTestMotionResult2D() {
 
 bool PhysicsServer2D::_body_test_motion(RID p_body, const Transform2D &p_from, const Vector2 &p_motion, bool p_infinite_inertia, float p_margin, const Ref<PhysicsTestMotionResult2D> &p_result) {
 	MotionResult *r = nullptr;
-	if (p_result.is_valid())
+	if (p_result.is_valid()) {
 		r = p_result->get_result_ptr();
+	}
 	return body_test_motion(p_body, p_from, p_motion, p_infinite_inertia, p_margin, r);
 }
 

servers/physics_server_3d.cpp

@@ -45,13 +45,15 @@ void PhysicsDirectBodyState3D::integrate_forces() {
 
 	float linear_damp = 1.0 - step * get_total_linear_damp();
 
-	if (linear_damp < 0) // reached zero in the given time
+	if (linear_damp < 0) { // reached zero in the given time
 		linear_damp = 0;
+	}
 
 	float angular_damp = 1.0 - step * get_total_angular_damp();
 
-	if (angular_damp < 0) // reached zero in the given time
+	if (angular_damp < 0) { // reached zero in the given time
 		angular_damp = 0;
+	}
 
 	lv *= linear_damp;
 	av *= angular_damp;
@@ -173,8 +175,9 @@ int PhysicsShapeQueryParameters3D::get_collision_mask() const {
 
 void PhysicsShapeQueryParameters3D::set_exclude(const Vector<RID> &p_exclude) {
 	exclude.clear();
-	for (int i = 0; i < p_exclude.size(); i++)
+	for (int i = 0; i < p_exclude.size(); i++) {
 		exclude.insert(p_exclude[i]);
+	}
 }
 
 Vector<RID> PhysicsShapeQueryParameters3D::get_exclude() const {
@@ -248,13 +251,15 @@ PhysicsShapeQueryParameters3D::PhysicsShapeQueryParameters3D() {
 Dictionary PhysicsDirectSpaceState3D::_intersect_ray(const Vector3 &p_from, const Vector3 &p_to, const Vector<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas) {
 	RayResult inters;
 	Set<RID> exclude;
-	for (int i = 0; i < p_exclude.size(); i++)
+	for (int i = 0; i < p_exclude.size(); i++) {
 		exclude.insert(p_exclude[i]);
+	}
 
 	bool res = intersect_ray(p_from, p_to, inters, exclude, p_collision_mask, p_collide_with_bodies, p_collide_with_areas);
 
-	if (!res)
+	if (!res) {
 		return Dictionary();
+	}
 
 	Dictionary d;
 	d["position"] = inters.position;
@@ -292,8 +297,9 @@ Array PhysicsDirectSpaceState3D::_cast_motion(const Ref<PhysicsShapeQueryParamet
 
 	float closest_safe, closest_unsafe;
 	bool res = cast_motion(p_shape_query->shape, p_shape_query->transform, p_motion, p_shape_query->margin, closest_safe, closest_unsafe, p_shape_query->exclude, p_shape_query->collision_mask, p_shape_query->collide_with_bodies, p_shape_query->collide_with_areas);
-	if (!res)
+	if (!res) {
 		return Array();
+	}
 	Array ret;
 	ret.resize(2);
 	ret[0] = closest_safe;
@@ -308,12 +314,14 @@ Array PhysicsDirectSpaceState3D::_collide_shape(const Ref<PhysicsShapeQueryParam
 	ret.resize(p_max_results * 2);
 	int rc = 0;
 	bool res = collide_shape(p_shape_query->shape, p_shape_query->transform, p_shape_query->margin, ret.ptrw(), p_max_results, rc, p_shape_query->exclude, p_shape_query->collision_mask, p_shape_query->collide_with_bodies, p_shape_query->collide_with_areas);
-	if (!res)
+	if (!res) {
 		return Array();
+	}
 	Array r;
 	r.resize(rc * 2);
-	for (int i = 0; i < rc * 2; i++)
+	for (int i = 0; i < rc * 2; i++) {
 		r[i] = ret[i];
+	}
 	return r;
 }
 
@@ -324,8 +332,9 @@ Dictionary PhysicsDirectSpaceState3D::_get_rest_info(const Ref<PhysicsShapeQuery
 
 	bool res = rest_info(p_shape_query->shape, p_shape_query->transform, p_shape_query->margin, &sri, p_shape_query->exclude, p_shape_query->collision_mask, p_shape_query->collide_with_bodies, p_shape_query->collide_with_areas);
 	Dictionary r;
-	if (!res)
+	if (!res) {
 		return r;
+	}
 
 	r["point"] = sri.point;
 	r["normal"] = sri.normal;

servers/rendering/rasterizer.h

@@ -855,8 +855,9 @@ public:
 
 		_FORCE_INLINE_ TextureBinding() { binding_id = 0; }
 		_FORCE_INLINE_ ~TextureBinding() {
-			if (binding_id)
+			if (binding_id) {
 				singleton->free_texture_binding(binding_id);
+			}
 		}
 	};
 
@@ -884,8 +885,9 @@ public:
 
 		_FORCE_INLINE_ Polygon() { polygon_id = 0; }
 		_FORCE_INLINE_ ~Polygon() {
-			if (polygon_id)
+			if (polygon_id) {
 				singleton->free_polygon(polygon_id);
+			}
 		}
 	};
 
@@ -1054,8 +1056,9 @@ public:
 		Rect2 global_rect_cache;
 
 		const Rect2 &get_rect() const {
-			if (custom_rect || (!rect_dirty && !update_when_visible))
+			if (custom_rect || (!rect_dirty && !update_when_visible)) {
 				return rect;
+			}
 
 			//must update rect
 
@@ -1265,8 +1268,9 @@ public:
 			for (int i = 0; i < blocks.size(); i++) {
 				memfree(blocks[i].memory);
 			}
-			if (copy_back_buffer)
+			if (copy_back_buffer) {
 				memdelete(copy_back_buffer);
+			}
 			if (custom_data) {
 				memdelete(custom_data);
 			}

servers/rendering/rasterizer_rd/rasterizer_scene_high_end_rd.cpp

@@ -1297,8 +1297,9 @@ void RasterizerSceneHighEndRD::_add_geometry(InstanceBase *p_instance, uint32_t
 
 	while (material->next_pass.is_valid()) {
 		material = (MaterialData *)storage->material_get_data(material->next_pass, RasterizerStorageRD::SHADER_TYPE_3D);
-		if (!material || !material->shader_data->valid)
+		if (!material || !material->shader_data->valid) {
 			break;
+		}
 		_add_geometry_with_material(p_instance, p_surface, material, material->next_pass, p_pass_mode, p_geometry_index);
 	}
 }
@@ -1347,8 +1348,9 @@ void RasterizerSceneHighEndRD::_add_geometry_with_material(InstanceBase *p_insta
 
 	RenderList::Element *e = (has_alpha || p_material->shader_data->depth_test == ShaderData::DEPTH_TEST_DISABLED) ? render_list.add_alpha_element() : render_list.add_element();
 
-	if (!e)
+	if (!e) {
 		return;
+	}
 
 	e->instance = p_instance;
 	e->material = p_material;

servers/rendering/rasterizer_rd/rasterizer_scene_high_end_rd.h

@@ -576,15 +576,17 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
 		}
 
 		_FORCE_INLINE_ Element *add_element() {
-			if (element_count + alpha_element_count >= max_elements)
+			if (element_count + alpha_element_count >= max_elements) {
 				return nullptr;
+			}
 			elements[element_count] = &base_elements[element_count];
 			return elements[element_count++];
 		}
 
 		_FORCE_INLINE_ Element *add_alpha_element() {
-			if (element_count + alpha_element_count >= max_elements)
+			if (element_count + alpha_element_count >= max_elements) {
 				return nullptr;
+			}
 			int idx = max_elements - alpha_element_count - 1;
 			elements[idx] = &base_elements[idx];
 			alpha_element_count++;
@@ -596,8 +598,9 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
 			alpha_element_count = 0;
 			elements = memnew_arr(Element *, max_elements);
 			base_elements = memnew_arr(Element, max_elements);
-			for (int i = 0; i < max_elements; i++)
+			for (int i = 0; i < max_elements; i++) {
 				elements[i] = &base_elements[i]; // assign elements
+			}
 		}
 
 		RenderList() {

servers/rendering/rasterizer_rd/rasterizer_scene_rd.cpp

@@ -1676,8 +1676,9 @@ void RasterizerSceneRD::shadow_atlas_set_size(RID p_atlas, int p_size) {
 	ERR_FAIL_COND(p_size < 0);
 	p_size = next_power_of_2(p_size);
 
-	if (p_size == shadow_atlas->size)
+	if (p_size == shadow_atlas->size) {
 		return;
+	}
 
 	// erasing atlas
 	if (shadow_atlas->depth.is_valid()) {
@@ -1728,8 +1729,9 @@ void RasterizerSceneRD::shadow_atlas_set_quadrant_subdivision(RID p_atlas, int p
 
 	//obtain the number that will be x*x
 
-	if (shadow_atlas->quadrants[p_quadrant].subdivision == subdiv)
+	if (shadow_atlas->quadrants[p_quadrant].subdivision == subdiv) {
 		return;
+	}
 
 	//erase all data from quadrant
 	for (int i = 0; i < shadow_atlas->quadrants[p_quadrant].shadows.size(); i++) {
@@ -1801,8 +1803,9 @@ bool RasterizerSceneRD::_shadow_atlas_find_shadow(ShadowAtlas *shadow_atlas, int
 
 			if (sli->last_scene_pass != scene_pass) {
 				//was just allocated, don't kill it so soon, wait a bit..
-				if (p_tick - sarr[j].alloc_tick < shadow_atlas_realloc_tolerance_msec)
+				if (p_tick - sarr[j].alloc_tick < shadow_atlas_realloc_tolerance_msec) {
 					continue;
+				}
 
 				if (found_used_idx == -1 || sli->last_scene_pass < min_pass) {
 					found_used_idx = j;
@@ -1811,8 +1814,9 @@ bool RasterizerSceneRD::_shadow_atlas_find_shadow(ShadowAtlas *shadow_atlas, int
 			}
 		}
 
-		if (found_free_idx == -1 && found_used_idx == -1)
+		if (found_free_idx == -1 && found_used_idx == -1) {
 			continue; //nothing found
+		}
 
 		if (found_free_idx == -1 && found_used_idx != -1) {
 			found_free_idx = found_used_idx;
@@ -1850,13 +1854,15 @@ bool RasterizerSceneRD::shadow_atlas_update_light(RID p_atlas, RID p_light_intan
 	for (int i = 0; i < 4; i++) {
 		int q = shadow_atlas->size_order[i];
 		int sd = shadow_atlas->quadrants[q].subdivision;
-		if (sd == 0)
+		if (sd == 0) {
 			continue; //unused
+		}
 
 		int max_fit = quad_size / sd;
 
-		if (best_size != -1 && max_fit > best_size)
+		if (best_size != -1 && max_fit > best_size) {
 			break; //too large
+		}
 
 		valid_quadrants[valid_quadrant_count++] = q;
 		best_subdiv = sd;

servers/rendering/rasterizer_rd/rasterizer_storage_rd.cpp

@@ -1006,16 +1006,17 @@ void RasterizerStorageRD::shader_set_code(RID p_shader, const String &p_code) {
 	String mode_string = ShaderLanguage::get_shader_type(p_code);
 
 	ShaderType new_type;
-	if (mode_string == "canvas_item")
+	if (mode_string == "canvas_item") {
 		new_type = SHADER_TYPE_2D;
-	else if (mode_string == "particles")
+	} else if (mode_string == "particles") {
 		new_type = SHADER_TYPE_PARTICLES;
-	else if (mode_string == "spatial")
+	} else if (mode_string == "spatial") {
 		new_type = SHADER_TYPE_3D;
-	else if (mode_string == "sky")
+	} else if (mode_string == "sky") {
 		new_type = SHADER_TYPE_SKY;
-	else
+	} else {
 		new_type = SHADER_TYPE_MAX;
+	}
 
 	if (new_type != shader->type) {
 		if (shader->data) {
@@ -1341,10 +1342,11 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
 			const int *r = iv.ptr();
 
 			for (int i = 0; i < 2; i++) {
-				if (i < s)
+				if (i < s) {
 					gui[i] = r[i];
-				else
+				} else {
 					gui[i] = 0;
+				}
 			}
 
 		} break;
@@ -1356,10 +1358,11 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
 			const int *r = iv.ptr();
 
 			for (int i = 0; i < 3; i++) {
-				if (i < s)
+				if (i < s) {
 					gui[i] = r[i];
-				else
+				} else {
 					gui[i] = 0;
+				}
 			}
 		} break;
 		case ShaderLanguage::TYPE_IVEC4: {
@@ -1370,10 +1373,11 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
 			const int *r = iv.ptr();
 
 			for (int i = 0; i < 4; i++) {
-				if (i < s)
+				if (i < s) {
 					gui[i] = r[i];
-				else
+				} else {
 					gui[i] = 0;
+				}
 			}
 		} break;
 		case ShaderLanguage::TYPE_UINT: {
@@ -1390,10 +1394,11 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
 			const int *r = iv.ptr();
 
 			for (int i = 0; i < 2; i++) {
-				if (i < s)
+				if (i < s) {
 					gui[i] = r[i];
-				else
+				} else {
 					gui[i] = 0;
+				}
 			}
 		} break;
 		case ShaderLanguage::TYPE_UVEC3: {
@@ -1404,10 +1409,11 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
 			const int *r = iv.ptr();
 
 			for (int i = 0; i < 3; i++) {
-				if (i < s)
+				if (i < s) {
 					gui[i] = r[i];
-				else
+				} else {
 					gui[i] = 0;
+				}
 			}
 
 		} break;
@@ -1419,10 +1425,11 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
 			const int *r = iv.ptr();
 
 			for (int i = 0; i < 4; i++) {
-				if (i < s)
+				if (i < s) {
 					gui[i] = r[i];
-				else
+				} else {
 					gui[i] = 0;
+				}
 			}
 		} break;
 		case ShaderLanguage::TYPE_FLOAT: {
@@ -1735,8 +1742,9 @@ void RasterizerStorageRD::MaterialData::update_uniform_buffer(const Map<StringNa
 	bool uses_global_buffer = false;
 
 	for (Map<StringName, ShaderLanguage::ShaderNode::Uniform>::Element *E = p_uniforms.front(); E; E = E->next()) {
-		if (E->get().order < 0)
+		if (E->get().order < 0) {
 			continue; // texture, does not go here
+		}
 
 		if (E->get().scope == ShaderLanguage::ShaderNode::Uniform::SCOPE_INSTANCE) {
 			continue; //instance uniforms don't appear in the bufferr
@@ -2280,8 +2288,9 @@ AABB RasterizerStorageRD::mesh_get_aabb(RID p_mesh, RID p_skeleton) {
 
 			if (skeleton->use_2d) {
 				for (int j = 0; j < bs; j++) {
-					if (skbones[0].size == Vector3())
+					if (skbones[0].size == Vector3()) {
 						continue; //bone is unused
+					}
 
 					const float *dataptr = baseptr + j * 8;
 
@@ -2306,8 +2315,9 @@ AABB RasterizerStorageRD::mesh_get_aabb(RID p_mesh, RID p_skeleton) {
 				}
 			} else {
 				for (int j = 0; j < bs; j++) {
-					if (skbones[0].size == Vector3())
+					if (skbones[0].size == Vector3()) {
 						continue; //bone is unused
+					}
 
 					const float *dataptr = baseptr + j * 12;
 
@@ -3109,8 +3119,9 @@ void RasterizerStorageRD::skeleton_allocate(RID p_skeleton, int p_bones, bool p_
 	ERR_FAIL_COND(!skeleton);
 	ERR_FAIL_COND(p_bones < 0);
 
-	if (skeleton->size == p_bones && skeleton->use_2d == p_2d_skeleton)
+	if (skeleton->size == p_bones && skeleton->use_2d == p_2d_skeleton) {
 		return;
+	}
 
 	skeleton->size = p_bones;
 	skeleton->use_2d = p_2d_skeleton;

servers/rendering/rasterizer_rd/shader_compiler_rd.cpp

@@ -265,8 +265,9 @@ static String get_constant_text(SL::DataType p_type, const Vector<SL::ConstantNo
 		case SL::TYPE_BVEC4: {
 			String text = "bvec" + itos(p_type - SL::TYPE_BOOL + 1) + "(";
 			for (int i = 0; i < p_values.size(); i++) {
-				if (i > 0)
+				if (i > 0) {
 					text += ",";
+				}
 
 				text += p_values[i].boolean ? "true" : "false";
 			}
@@ -281,8 +282,9 @@ static String get_constant_text(SL::DataType p_type, const Vector<SL::ConstantNo
 		case SL::TYPE_IVEC4: {
 			String text = "ivec" + itos(p_type - SL::TYPE_INT + 1) + "(";
 			for (int i = 0; i < p_values.size(); i++) {
-				if (i > 0)
+				if (i > 0) {
 					text += ",";
+				}
 
 				text += itos(p_values[i].sint);
 			}
@@ -297,8 +299,9 @@ static String get_constant_text(SL::DataType p_type, const Vector<SL::ConstantNo
 		case SL::TYPE_UVEC4: {
 			String text = "uvec" + itos(p_type - SL::TYPE_UINT + 1) + "(";
 			for (int i = 0; i < p_values.size(); i++) {
-				if (i > 0)
+				if (i > 0) {
 					text += ",";
+				}
 
 				text += itos(p_values[i].uint) + "u";
 			}
@@ -312,8 +315,9 @@ static String get_constant_text(SL::DataType p_type, const Vector<SL::ConstantNo
 		case SL::TYPE_VEC4: {
 			String text = "vec" + itos(p_type - SL::TYPE_FLOAT + 1) + "(";
 			for (int i = 0; i < p_values.size(); i++) {
-				if (i > 0)
+				if (i > 0) {
 					text += ",";
+				}
 
 				text += f2sp0(p_values[i].real);
 			}
@@ -326,8 +330,9 @@ static String get_constant_text(SL::DataType p_type, const Vector<SL::ConstantNo
 		case SL::TYPE_MAT4: {
 			String text = "mat" + itos(p_type - SL::TYPE_MAT2 + 2) + "(";
 			for (int i = 0; i < p_values.size(); i++) {
-				if (i > 0)
+				if (i > 0) {
 					text += ",";
+				}
 
 				text += f2sp0(p_values[i].real);
 			}
@@ -391,8 +396,9 @@ void ShaderCompilerRD::_dump_function_deps(const SL::ShaderNode *p_node, const S
 			header = _typestr(fnode->return_type) + " " + _mkid(fnode->name) + "(";
 		}
 		for (int i = 0; i < fnode->arguments.size(); i++) {
-			if (i > 0)
+			if (i > 0) {
 				header += ", ";
+			}
 			if (fnode->arguments[i].type == SL::TYPE_STRUCT) {
 				header += _qualstr(fnode->arguments[i].qualifier) + _mkid(fnode->arguments[i].type_str) + " " + _mkid(fnode->arguments[i].name);
 			} else {
@@ -828,9 +834,9 @@ String ShaderCompilerRD::_dump_node_code(const SL::Node *p_node, int p_level, Ge
 				used_flag_pointers.insert(vnode->name);
 			}
 
-			if (p_default_actions.renames.has(vnode->name))
+			if (p_default_actions.renames.has(vnode->name)) {
 				code = p_default_actions.renames[vnode->name];
-			else {
+			} else {
 				if (shader->uniforms.has(vnode->name)) {
 					//its a uniform!
 					const ShaderLanguage::ShaderNode::Uniform &u = shader->uniforms[vnode->name];
@@ -953,10 +959,11 @@ String ShaderCompilerRD::_dump_node_code(const SL::Node *p_node, int p_level, Ge
 				used_flag_pointers.insert(anode->name);
 			}
 
-			if (p_default_actions.renames.has(anode->name))
+			if (p_default_actions.renames.has(anode->name)) {
 				code = p_default_actions.renames[anode->name];
-			else
+			} else {
 				code = _mkid(anode->name);
+			}
 
 			if (anode->call_expression != nullptr) {
 				code += ".";
@@ -1038,8 +1045,9 @@ String ShaderCompilerRD::_dump_node_code(const SL::Node *p_node, int p_level, Ge
 					code += "(";
 
 					for (int i = 1; i < onode->arguments.size(); i++) {
-						if (i > 1)
+						if (i > 1) {
 							code += ", ";
+						}
 						String node_code = _dump_node_code(onode->arguments[i], p_level, r_gen_code, p_actions, p_default_actions, p_assigning);
 						if (is_texture_func && i == 1 && onode->arguments[i]->type == SL::Node::TYPE_VARIABLE) {
 							//need to map from texture to sampler in order to sample

servers/rendering/rendering_server_canvas.cpp

@@ -52,8 +52,9 @@ void RenderingServerCanvas::_render_canvas_item_tree(RID p_to_render_target, Can
 	RasterizerCanvas::Item *list_end = nullptr;
 
 	for (int i = 0; i < z_range; i++) {
-		if (!z_list[i])
+		if (!z_list[i]) {
 			continue;
+		}
 		if (!list) {
 			list = z_list[i];
 			list_end = z_last_list[i];
@@ -82,8 +83,9 @@ void _collect_ysort_children(RenderingServerCanvas::Item *p_canvas_item, Transfo
 
 			r_index++;
 
-			if (child_items[i]->sort_y)
+			if (child_items[i]->sort_y) {
 				_collect_ysort_children(child_items[i], p_transform * child_items[i]->xform, child_items[i]->use_parent_material ? p_material_owner : child_items[i], r_items, r_index);
+			}
 		}
 	}
 }
@@ -98,8 +100,9 @@ void _mark_ysort_dirty(RenderingServerCanvas::Item *ysort_owner, RID_PtrOwner<Re
 void RenderingServerCanvas::_cull_canvas_item(Item *p_canvas_item, const Transform2D &p_transform, const Rect2 &p_clip_rect, const Color &p_modulate, int p_z, RasterizerCanvas::Item **z_list, RasterizerCanvas::Item **z_last_list, Item *p_canvas_clip, Item *p_material_owner) {
 	Item *ci = p_canvas_item;
 
-	if (!ci->visible)
+	if (!ci->visible) {
 		return;
+	}
 
 	if (ci->children_order_dirty) {
 		ci->child_items.sort_custom<ItemIndexSort>();
@@ -111,17 +114,18 @@ void RenderingServerCanvas::_cull_canvas_item(Item *p_canvas_item, const Transfo
 	Rect2 global_rect = xform.xform(rect);
 	global_rect.position += p_clip_rect.position;
 
-	if (ci->use_parent_material && p_material_owner)
+	if (ci->use_parent_material && p_material_owner) {
 		ci->material_owner = p_material_owner;
-	else {
+	} else {
 		p_material_owner = ci;
 		ci->material_owner = nullptr;
 	}
 
 	Color modulate(ci->modulate.r * p_modulate.r, ci->modulate.g * p_modulate.g, ci->modulate.b * p_modulate.b, ci->modulate.a * p_modulate.a);
 
-	if (modulate.a < 0.007)
+	if (modulate.a < 0.007) {
 		return;
+	}
 
 	int child_item_count = ci->child_items.size();
 	Item **child_items = ci->child_items.ptrw();
@@ -154,14 +158,16 @@ void RenderingServerCanvas::_cull_canvas_item(Item *p_canvas_item, const Transfo
 		sorter.sort(child_items, child_item_count);
 	}
 
-	if (ci->z_relative)
+	if (ci->z_relative) {
 		p_z = CLAMP(p_z + ci->z_index, RS::CANVAS_ITEM_Z_MIN, RS::CANVAS_ITEM_Z_MAX);
-	else
+	} else {
 		p_z = ci->z_index;
+	}
 
 	for (int i = 0; i < child_item_count; i++) {
-		if (!child_items[i]->behind || (ci->sort_y && child_items[i]->sort_y))
+		if (!child_items[i]->behind || (ci->sort_y && child_items[i]->sort_y)) {
 			continue;
+		}
 		if (ci->sort_y) {
 			_cull_canvas_item(child_items[i], xform * child_items[i]->ysort_xform, p_clip_rect, modulate, p_z, z_list, z_last_list, (Item *)ci->final_clip_owner, (Item *)child_items[i]->material_owner);
 		} else {
@@ -202,8 +208,9 @@ void RenderingServerCanvas::_cull_canvas_item(Item *p_canvas_item, const Transfo
 	}
 
 	for (int i = 0; i < child_item_count; i++) {
-		if (child_items[i]->behind || (ci->sort_y && child_items[i]->sort_y))
+		if (child_items[i]->behind || (ci->sort_y && child_items[i]->sort_y)) {
 			continue;
+		}
 		if (ci->sort_y) {
 			_cull_canvas_item(child_items[i], xform * child_items[i]->ysort_xform, p_clip_rect, modulate, p_z, z_list, z_last_list, (Item *)ci->final_clip_owner, (Item *)child_items[i]->material_owner);
 		} else {
@@ -213,8 +220,9 @@ void RenderingServerCanvas::_cull_canvas_item(Item *p_canvas_item, const Transfo
 }
 
 void RenderingServerCanvas::_light_mask_canvas_items(int p_z, RasterizerCanvas::Item *p_canvas_item, RasterizerCanvas::Light *p_masked_lights) {
-	if (!p_masked_lights)
+	if (!p_masked_lights) {
 		return;
+	}
 
 	RasterizerCanvas::Item *ci = p_canvas_item;
 
@@ -960,8 +968,9 @@ void RenderingServerCanvas::canvas_light_attach_to_canvas(RID p_light, RID p_can
 		canvas->lights.erase(clight);
 	}
 
-	if (!canvas_owner.owns(p_canvas))
+	if (!canvas_owner.owns(p_canvas)) {
 		p_canvas = RID();
+	}
 
 	clight->canvas = p_canvas;
 
@@ -1085,8 +1094,9 @@ void RenderingServerCanvas::canvas_light_set_shadow_buffer_size(RID p_light, int
 	ERR_FAIL_COND(!clight);
 
 	int new_size = next_power_of_2(p_size);
-	if (new_size == clight->shadow_buffer_size)
+	if (new_size == clight->shadow_buffer_size) {
 		return;
+	}
 
 	clight->shadow_buffer_size = next_power_of_2(p_size);
 	clight->version++;
@@ -1129,8 +1139,9 @@ void RenderingServerCanvas::canvas_light_occluder_attach_to_canvas(RID p_occlude
 		canvas->occluders.erase(occluder);
 	}
 
-	if (!canvas_owner.owns(p_canvas))
+	if (!canvas_owner.owns(p_canvas)) {
 		p_canvas = RID();
+	}
 
 	occluder->canvas = p_canvas;
 
@@ -1234,10 +1245,11 @@ void RenderingServerCanvas::canvas_occluder_polygon_set_shape_as_lines(RID p_occ
 	{
 		const Vector2 *r = p_shape.ptr();
 		for (int i = 0; i < lc; i++) {
-			if (i == 0)
+			if (i == 0) {
 				occluder_poly->aabb.position = r[i];
-			else
+			} else {
 				occluder_poly->aabb.expand_to(r[i]);
+			}
 		}
 	}
 
@@ -1327,8 +1339,9 @@ bool RenderingServerCanvas::free(RID p_rid) {
 
 		if (canvas_light->canvas.is_valid()) {
 			Canvas *canvas = canvas_owner.getornull(canvas_light->canvas);
-			if (canvas)
+			if (canvas) {
 				canvas->lights.erase(canvas_light);
+			}
 		}
 
 		RSG::canvas_render->free(canvas_light->light_internal);

servers/rendering/rendering_server_canvas.h

@@ -82,8 +82,9 @@ public:
 
 	struct ItemPtrSort {
 		_FORCE_INLINE_ bool operator()(const Item *p_left, const Item *p_right) const {
-			if (Math::is_equal_approx(p_left->ysort_pos.y, p_right->ysort_pos.y))
+			if (Math::is_equal_approx(p_left->ysort_pos.y, p_right->ysort_pos.y)) {
 				return p_left->ysort_pos.x < p_right->ysort_pos.x;
+			}
 
 			return p_left->ysort_pos.y < p_right->ysort_pos.y;
 		}
@@ -128,15 +129,17 @@ public:
 
 		int find_item(Item *p_item) {
 			for (int i = 0; i < child_items.size(); i++) {
-				if (child_items[i].item == p_item)
+				if (child_items[i].item == p_item) {
 					return i;
+				}
 			}
 			return -1;
 		}
 		void erase_item(Item *p_item) {
 			int idx = find_item(p_item);
-			if (idx >= 0)
+			if (idx >= 0) {
 				child_items.remove(idx);
+			}
 		}
 
 		Canvas() {

servers/rendering/rendering_server_raster.cpp

@@ -65,16 +65,21 @@ void RenderingServerRaster::_draw_margins() {
 /* FREE */
 
 void RenderingServerRaster::free(RID p_rid) {
-	if (RSG::storage->free(p_rid))
+	if (RSG::storage->free(p_rid)) {
 		return;
-	if (RSG::canvas->free(p_rid))
+	}
+	if (RSG::canvas->free(p_rid)) {
 		return;
-	if (RSG::viewport->free(p_rid))
+	}
+	if (RSG::viewport->free(p_rid)) {
 		return;
-	if (RSG::scene->free(p_rid))
+	}
+	if (RSG::scene->free(p_rid)) {
 		return;
-	if (RSG::scene_render->free(p_rid))
+	}
+	if (RSG::scene_render->free(p_rid)) {
 		return;
+	}
 }
 
 /* EVENT QUEUING */

servers/rendering/rendering_server_scene.cpp

@@ -328,13 +328,16 @@ void RenderingServerScene::scenario_set_reflection_atlas_size(RID p_scenario, in
 /* INSTANCING API */
 
 void RenderingServerScene::_instance_queue_update(Instance *p_instance, bool p_update_aabb, bool p_update_dependencies) {
-	if (p_update_aabb)
+	if (p_update_aabb) {
 		p_instance->update_aabb = true;
-	if (p_update_dependencies)
+	}
+	if (p_update_dependencies) {
 		p_instance->update_dependencies = true;
+	}
 
-	if (p_instance->update_item.in_list())
+	if (p_instance->update_item.in_list()) {
 		return;
+	}
 
 	_instance_update_list.add(&p_instance->update_item);
 }
@@ -597,8 +600,9 @@ void RenderingServerScene::instance_set_transform(RID p_instance, const Transfor
 	Instance *instance = instance_owner.getornull(p_instance);
 	ERR_FAIL_COND(!instance);
 
-	if (instance->transform == p_transform)
+	if (instance->transform == p_transform) {
 		return; //must be checked to avoid worst evil
+	}
 
 #ifdef DEBUG_ENABLED
 
@@ -656,8 +660,9 @@ void RenderingServerScene::instance_set_visible(RID p_instance, bool p_visible)
 	Instance *instance = instance_owner.getornull(p_instance);
 	ERR_FAIL_COND(!instance);
 
-	if (instance->visible == p_visible)
+	if (instance->visible == p_visible) {
 		return;
+	}
 
 	instance->visible = p_visible;
 
@@ -708,8 +713,9 @@ void RenderingServerScene::instance_set_custom_aabb(RID p_instance, AABB p_aabb)
 
 	if (p_aabb != AABB()) {
 		// Set custom AABB
-		if (instance->custom_aabb == nullptr)
+		if (instance->custom_aabb == nullptr) {
 			instance->custom_aabb = memnew(AABB);
+		}
 		*instance->custom_aabb = p_aabb;
 
 	} else {
@@ -720,16 +726,18 @@ void RenderingServerScene::instance_set_custom_aabb(RID p_instance, AABB p_aabb)
 		}
 	}
 
-	if (instance->scenario)
+	if (instance->scenario) {
 		_instance_queue_update(instance, true, false);
+	}
 }
 
 void RenderingServerScene::instance_attach_skeleton(RID p_instance, RID p_skeleton) {
 	Instance *instance = instance_owner.getornull(p_instance);
 	ERR_FAIL_COND(!instance);
 
-	if (instance->skeleton == p_skeleton)
+	if (instance->skeleton == p_skeleton) {
 		return;
+	}
 
 	instance->skeleton = p_skeleton;
 
@@ -765,8 +773,9 @@ Vector<ObjectID> RenderingServerScene::instances_cull_aabb(const AABB &p_aabb, R
 	for (int i = 0; i < culled; i++) {
 		Instance *instance = cull[i];
 		ERR_CONTINUE(!instance);
-		if (instance->object_id.is_null())
+		if (instance->object_id.is_null()) {
 			continue;
+		}
 
 		instances.push_back(instance->object_id);
 	}
@@ -787,8 +796,9 @@ Vector<ObjectID> RenderingServerScene::instances_cull_ray(const Vector3 &p_from,
 	for (int i = 0; i < culled; i++) {
 		Instance *instance = cull[i];
 		ERR_CONTINUE(!instance);
-		if (instance->object_id.is_null())
+		if (instance->object_id.is_null()) {
 			continue;
+		}
 
 		instances.push_back(instance->object_id);
 	}
@@ -810,8 +820,9 @@ Vector<ObjectID> RenderingServerScene::instances_cull_convex(const Vector<Plane>
 	for (int i = 0; i < culled; i++) {
 		Instance *instance = cull[i];
 		ERR_CONTINUE(!instance);
-		if (instance->object_id.is_null())
+		if (instance->object_id.is_null()) {
 			continue;
+		}
 
 		instances.push_back(instance->object_id);
 	}
@@ -1079,32 +1090,36 @@ void RenderingServerScene::_update_instance_aabb(Instance *p_instance) {
 			// do nothing
 		} break;
 		case RenderingServer::INSTANCE_MESH: {
-			if (p_instance->custom_aabb)
+			if (p_instance->custom_aabb) {
 				new_aabb = *p_instance->custom_aabb;
-			else
+			} else {
 				new_aabb = RSG::storage->mesh_get_aabb(p_instance->base, p_instance->skeleton);
+			}
 
 		} break;
 
 		case RenderingServer::INSTANCE_MULTIMESH: {
-			if (p_instance->custom_aabb)
+			if (p_instance->custom_aabb) {
 				new_aabb = *p_instance->custom_aabb;
-			else
+			} else {
 				new_aabb = RSG::storage->multimesh_get_aabb(p_instance->base);
+			}
 
 		} break;
 		case RenderingServer::INSTANCE_IMMEDIATE: {
-			if (p_instance->custom_aabb)
+			if (p_instance->custom_aabb) {
 				new_aabb = *p_instance->custom_aabb;
-			else
+			} else {
 				new_aabb = RSG::storage->immediate_get_aabb(p_instance->base);
+			}
 
 		} break;
 		case RenderingServer::INSTANCE_PARTICLES: {
-			if (p_instance->custom_aabb)
+			if (p_instance->custom_aabb) {
 				new_aabb = *p_instance->custom_aabb;
-			else
+			} else {
 				new_aabb = RSG::storage->particles_get_aabb(p_instance->base);
+			}
 
 		} break;
 		case RenderingServer::INSTANCE_LIGHT: {
@@ -1132,8 +1147,9 @@ void RenderingServerScene::_update_instance_aabb(Instance *p_instance) {
 	}
 
 	// <Zylann> This is why I didn't re-use Instance::aabb to implement custom AABBs
-	if (p_instance->extra_margin)
+	if (p_instance->extra_margin) {
 		new_aabb.grow_by(p_instance->extra_margin);
+	}
 
 	p_instance->aabb = new_aabb;
 }
@@ -1364,20 +1380,26 @@ bool RenderingServerScene::_light_instance_update_shadow(Instance *p_instance, c
 					real_t d_y = y_vec.dot(endpoints[j]);
 					real_t d_z = z_vec.dot(endpoints[j]);
 
-					if (j == 0 || d_x < x_min)
+					if (j == 0 || d_x < x_min) {
 						x_min = d_x;
-					if (j == 0 || d_x > x_max)
+					}
+					if (j == 0 || d_x > x_max) {
 						x_max = d_x;
+					}
 
-					if (j == 0 || d_y < y_min)
+					if (j == 0 || d_y < y_min) {
 						y_min = d_y;
-					if (j == 0 || d_y > y_max)
+					}
+					if (j == 0 || d_y > y_max) {
 						y_max = d_y;
+					}
 
-					if (j == 0 || d_z < z_min)
+					if (j == 0 || d_z < z_min) {
 						z_min = d_z;
-					if (j == 0 || d_z > z_max)
+					}
+					if (j == 0 || d_z > z_max) {
 						z_max = d_z;
+					}
 				}
 
 				real_t radius = 0;
@@ -1396,8 +1418,9 @@ bool RenderingServerScene::_light_instance_update_shadow(Instance *p_instance, c
 
 					for (int j = 0; j < 8; j++) {
 						real_t d = center.distance_to(endpoints[j]);
-						if (d > radius)
+						if (d > radius) {
 							radius = d;
+						}
 					}
 
 					radius *= texture_size / (texture_size - 2.0); //add a texel by each side
@@ -1524,8 +1547,9 @@ bool RenderingServerScene::_light_instance_update_shadow(Instance *p_instance, c
 
 						real_t d_z = z_vec.dot(endpoints_square[j]);
 
-						if (j == 0 || d_z > z_max_square)
+						if (j == 0 || d_z > z_max_square) {
 							z_max_square = d_z;
+						}
 					}
 
 					if (cull_max > z_max_square) {
@@ -1538,8 +1562,9 @@ bool RenderingServerScene::_light_instance_update_shadow(Instance *p_instance, c
 
 					for (int j = 0; j < 8; j++) {
 						real_t d = center_square.distance_to(endpoints_square[j]);
-						if (d > radius_square)
+						if (d > radius_square) {
 							radius_square = d;
+						}
 					}
 
 					radius_square *= texture_size / (texture_size - 2.0); //add a texel by each side
@@ -2073,8 +2098,9 @@ void RenderingServerScene::_prepare_scene(const Transform p_cam_transform, const
 				break;
 			}
 
-			if (!E->get()->visible)
+			if (!E->get()->visible) {
 				continue;
+			}
 
 			InstanceLightData *light = static_cast<InstanceLightData *>(E->get()->base_data);
 
@@ -2107,8 +2133,9 @@ void RenderingServerScene::_prepare_scene(const Transform p_cam_transform, const
 		for (int i = 0; i < light_cull_count; i++) {
 			Instance *ins = light_cull_result[i];
 
-			if (!p_shadow_atlas.is_valid() || !RSG::storage->light_has_shadow(ins->base))
+			if (!p_shadow_atlas.is_valid() || !RSG::storage->light_has_shadow(ins->base)) {
 				continue;
+			}
 
 			InstanceLightData *light = static_cast<InstanceLightData *>(ins->base_data);
 
@@ -2205,12 +2232,13 @@ void RenderingServerScene::_render_scene(RID p_render_buffers, const Transform p
 	/* ENVIRONMENT */
 
 	RID environment;
-	if (p_force_environment.is_valid()) //camera has more environment priority
+	if (p_force_environment.is_valid()) { //camera has more environment priority
 		environment = p_force_environment;
-	else if (scenario->environment.is_valid())
+	} else if (scenario->environment.is_valid()) {
 		environment = scenario->environment;
-	else
+	} else {
 		environment = scenario->fallback_environment;
+	}
 
 	RID camera_effects;
 	if (p_force_camera_effects.is_valid()) {
@@ -2230,10 +2258,11 @@ void RenderingServerScene::render_empty_scene(RID p_render_buffers, RID p_scenar
 	Scenario *scenario = scenario_owner.getornull(p_scenario);
 
 	RID environment;
-	if (scenario->environment.is_valid())
+	if (scenario->environment.is_valid()) {
 		environment = scenario->environment;
-	else
+	} else {
 		environment = scenario->fallback_environment;
+	}
 	RENDER_TIMESTAMP("Render Empty Scene ");
 	RSG::scene_render->render_scene(p_render_buffers, Transform(), CameraMatrix(), true, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0, environment, RID(), p_shadow_atlas, scenario->reflection_atlas, RID(), 0);
 #endif
@@ -2321,8 +2350,9 @@ void RenderingServerScene::render_probes() {
 
 		switch (RSG::storage->reflection_probe_get_update_mode(base)) {
 			case RS::REFLECTION_PROBE_UPDATE_ONCE: {
-				if (busy) //already rendering something
+				if (busy) { //already rendering something
 					break;
+				}
 
 				bool done = _render_reflection_probe_step(ref_probe->self()->owner, ref_probe->self()->render_step);
 				if (done) {
@@ -2707,8 +2737,9 @@ void RenderingServerScene::_update_dirty_instance(Instance *p_instance) {
 
 					for (int i = 0; i < dp; i++) {
 						RID mesh = RSG::storage->particles_get_draw_pass_mesh(p_instance->base, i);
-						if (!mesh.is_valid())
+						if (!mesh.is_valid()) {
 							continue;
+						}
 
 						int sc = RSG::storage->mesh_get_surface_count(mesh);
 						for (int j = 0; j < sc; j++) {

servers/rendering/rendering_server_scene.h

@@ -217,10 +217,12 @@ public:
 		}
 
 		~Instance() {
-			if (base_data)
+			if (base_data) {
 				memdelete(base_data);
-			if (custom_aabb)
+			}
+			if (custom_aabb) {
 				memdelete(custom_aabb);
+			}
 		}
 	};
 

servers/rendering/rendering_server_viewport.cpp

@@ -205,8 +205,9 @@ void RenderingServerViewport::_draw_viewport(Viewport *p_viewport, XRInterface::
 				Transform2D xf = _canvas_get_transform(p_viewport, canvas, &E->get(), clip_rect.size);
 
 				for (Set<RasterizerCanvas::LightOccluderInstance *>::Element *F = canvas->occluders.front(); F; F = F->next()) {
-					if (!F->get()->enabled)
+					if (!F->get()->enabled) {
 						continue;
+					}
 					F->get()->xform_cache = xf * F->get()->xform;
 					if (shadow_rect.intersects_transformed(F->get()->xform_cache, F->get()->aabb_cache)) {
 						F->get()->next = occluders;
@@ -321,8 +322,9 @@ void RenderingServerViewport::draw_viewports() {
 
 		Viewport *vp = active_viewports[i];
 
-		if (vp->update_mode == RS::VIEWPORT_UPDATE_DISABLED)
+		if (vp->update_mode == RS::VIEWPORT_UPDATE_DISABLED) {
 			continue;
+		}
 
 		if (!vp->render_target.is_valid()) {
 			continue;
@@ -550,8 +552,9 @@ void RenderingServerViewport::viewport_set_render_direct_to_screen(RID p_viewpor
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
-	if (p_enable == viewport->viewport_render_direct_to_screen)
+	if (p_enable == viewport->viewport_render_direct_to_screen) {
 		return;
+	}
 
 	// if disabled, reset render_target size and position
 	if (!p_enable) {
@@ -722,8 +725,9 @@ int RenderingServerViewport::viewport_get_render_info(RID p_viewport, RS::Viewpo
 	ERR_FAIL_INDEX_V(p_info, RS::VIEWPORT_RENDER_INFO_MAX, -1);
 
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
-	if (!viewport)
+	if (!viewport) {
 		return 0; //there should be a lock here..
+	}
 
 	return viewport->render_info[p_info];
 }

servers/rendering/rendering_server_viewport.h

@@ -91,8 +91,9 @@ public:
 			int64_t stacking;
 			RID canvas;
 			bool operator<(const CanvasKey &p_canvas) const {
-				if (stacking == p_canvas.stacking)
+				if (stacking == p_canvas.stacking) {
 					return canvas < p_canvas.canvas;
+				}
 				return stacking < p_canvas.stacking;
 			}
 			CanvasKey() {

servers/rendering/shader_language.cpp

@@ -549,31 +549,38 @@ ShaderLanguage::Token ShaderLanguage::_get_token() {
 
 					while (true) {
 						if (GETCHAR(i) == '.') {
-							if (period_found || exponent_found || hexa_found || float_suffix_found)
+							if (period_found || exponent_found || hexa_found || float_suffix_found) {
 								return _make_token(TK_ERROR, "Invalid numeric constant");
+							}
 							period_found = true;
 						} else if (GETCHAR(i) == 'x') {
-							if (hexa_found || str.length() != 1 || str[0] != '0')
+							if (hexa_found || str.length() != 1 || str[0] != '0') {
 								return _make_token(TK_ERROR, "Invalid numeric constant");
+							}
 							hexa_found = true;
 						} else if (GETCHAR(i) == 'e') {
-							if (hexa_found || exponent_found || float_suffix_found)
+							if (hexa_found || exponent_found || float_suffix_found) {
 								return _make_token(TK_ERROR, "Invalid numeric constant");
+							}
 							exponent_found = true;
 						} else if (GETCHAR(i) == 'f') {
-							if (hexa_found || exponent_found)
+							if (hexa_found || exponent_found) {
 								return _make_token(TK_ERROR, "Invalid numeric constant");
+							}
 							float_suffix_found = true;
 						} else if (_is_number(GETCHAR(i))) {
-							if (float_suffix_found)
+							if (float_suffix_found) {
 								return _make_token(TK_ERROR, "Invalid numeric constant");
+							}
 						} else if (hexa_found && _is_hex(GETCHAR(i))) {
 						} else if ((GETCHAR(i) == '-' || GETCHAR(i) == '+') && exponent_found) {
-							if (sign_found)
+							if (sign_found) {
 								return _make_token(TK_ERROR, "Invalid numeric constant");
+							}
 							sign_found = true;
-						} else
+						} else {
 							break;
+						}
 
 						str += CharType(GETCHAR(i));
 						i++;
@@ -629,10 +636,11 @@ ShaderLanguage::Token ShaderLanguage::_get_token() {
 
 					char_idx += str.length();
 					Token tk;
-					if (period_found || exponent_found || float_suffix_found)
+					if (period_found || exponent_found || float_suffix_found) {
 						tk.type = TK_REAL_CONSTANT;
-					else
+					} else {
 						tk.type = TK_INT_CONSTANT;
+					}
 
 					if (hexa_found) {
 						tk.constant = (double)str.hex_to_int64(true);
@@ -675,10 +683,11 @@ ShaderLanguage::Token ShaderLanguage::_get_token() {
 					return _make_token(TK_IDENTIFIER, str);
 				}
 
-				if (GETCHAR(0) > 32)
+				if (GETCHAR(0) > 32) {
 					return _make_token(TK_ERROR, "Tokenizer: Unknown character #" + itos(GETCHAR(0)) + ": '" + String::chr(GETCHAR(0)) + "'");
-				else
+				} else {
 					return _make_token(TK_ERROR, "Tokenizer: Unknown character #" + itos(GETCHAR(0)));
+				}
 
 			} break;
 		}
@@ -775,10 +784,11 @@ bool ShaderLanguage::is_token_interpolation(TokenType p_type) {
 }
 
 ShaderLanguage::DataInterpolation ShaderLanguage::get_token_interpolation(TokenType p_type) {
-	if (p_type == TK_INTERPOLATION_FLAT)
+	if (p_type == TK_INTERPOLATION_FLAT) {
 		return INTERPOLATION_FLAT;
-	else
+	} else {
 		return INTERPOLATION_SMOOTH;
+	}
 }
 
 bool ShaderLanguage::is_token_precision(TokenType p_type) {
@@ -789,12 +799,13 @@ bool ShaderLanguage::is_token_precision(TokenType p_type) {
 }
 
 ShaderLanguage::DataPrecision ShaderLanguage::get_token_precision(TokenType p_type) {
-	if (p_type == TK_PRECISION_LOW)
+	if (p_type == TK_PRECISION_LOW) {
 		return PRECISION_LOWP;
-	else if (p_type == TK_PRECISION_HIGH)
+	} else if (p_type == TK_PRECISION_HIGH) {
 		return PRECISION_HIGHP;
-	else
+	} else {
 		return PRECISION_MEDIUMP;
+	}
 }
 
 String ShaderLanguage::get_precision_name(DataPrecision p_type) {
@@ -1013,8 +1024,9 @@ bool ShaderLanguage::_find_identifier(const BlockNode *p_block, bool p_allow_rea
 	}
 
 	for (int i = 0; i < shader->functions.size(); i++) {
-		if (!shader->functions[i].callable)
+		if (!shader->functions[i].callable) {
 			continue;
+		}
 
 		if (shader->functions[i].name == p_identifier) {
 			if (r_data_type) {
@@ -1400,8 +1412,9 @@ bool ShaderLanguage::_validate_operator(OperatorNode *p_op, DataType *r_ret_type
 		}
 	}
 
-	if (r_ret_type)
+	if (r_ret_type) {
 		*r_ret_type = ret_type;
+	}
 	return valid;
 }
 
@@ -2179,8 +2192,9 @@ bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const Map<Strin
 					}
 				}
 
-				if (!fail && argcount < 4 && builtin_func_defs[idx].args[argcount] != TYPE_VOID)
+				if (!fail && argcount < 4 && builtin_func_defs[idx].args[argcount] != TYPE_VOID) {
 					fail = true; //make sure the number of arguments matches
+				}
 
 				if (!fail) {
 					//make sure its not an out argument used in the wrong way
@@ -2293,8 +2307,9 @@ bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const Map<Strin
 						p_func->arguments.write[i + 1] = conversion;
 					}
 
-					if (r_ret_type)
+					if (r_ret_type) {
 						*r_ret_type = builtin_func_defs[idx].rettype;
+					}
 
 					return true;
 				}
@@ -2321,8 +2336,9 @@ bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const Map<Strin
 	if (failed_builtin) {
 		String err = "Invalid arguments for built-in function: " + String(name) + "(";
 		for (int i = 0; i < argcount; i++) {
-			if (i > 0)
+			if (i > 0) {
 				err += ",";
+			}
 
 			if (p_func->arguments[i + 1]->type == Node::TYPE_CONSTANT && p_func->arguments[i + 1]->get_datatype() == TYPE_INT && static_cast<ConstantNode *>(p_func->arguments[i + 1])->values[0].sint < 0) {
 				err += "-";
@@ -2352,8 +2368,9 @@ bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const Map<Strin
 	}
 
 	for (int i = 0; i < shader->functions.size(); i++) {
-		if (name != shader->functions[i].name)
+		if (name != shader->functions[i].name) {
 			continue;
+		}
 
 		if (!shader->functions[i].callable) {
 			_set_error("Function '" + String(name) + " can't be called from source code.");
@@ -2362,8 +2379,9 @@ bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const Map<Strin
 
 		FunctionNode *pfunc = shader->functions[i].function;
 
-		if (pfunc->arguments.size() != args.size())
+		if (pfunc->arguments.size() != args.size()) {
 			continue;
+		}
 
 		bool fail = false;
 
@@ -2541,8 +2559,9 @@ bool ShaderLanguage::convert_constant(ConstantNode *p_constant, DataType p_to_ty
 			p_value->sint = p_constant->values[0].uint;
 		}
 		return true;
-	} else
+	} else {
 		return false;
+	}
 }
 
 bool ShaderLanguage::is_scalar_type(DataType p_type) {
@@ -2997,8 +3016,9 @@ bool ShaderLanguage::_validate_assign(Node *p_node, const Map<StringName, BuiltI
 			return _validate_assign(op->arguments[1], p_builtin_types, r_message);
 
 		} else if (op->op == OP_CALL) {
-			if (r_message)
+			if (r_message) {
 				*r_message = RTR("Assignment to function.");
+			}
 			return false;
 		}
 
@@ -3006,8 +3026,9 @@ bool ShaderLanguage::_validate_assign(Node *p_node, const Map<StringName, BuiltI
 		MemberNode *member = static_cast<MemberNode *>(p_node);
 
 		if (member->has_swizzling_duplicates) {
-			if (r_message)
+			if (r_message) {
 				*r_message = RTR("Swizzling assignment contains duplicates.");
+			}
 			return false;
 		}
 
@@ -3017,20 +3038,23 @@ bool ShaderLanguage::_validate_assign(Node *p_node, const Map<StringName, BuiltI
 		VariableNode *var = static_cast<VariableNode *>(p_node);
 
 		if (shader->uniforms.has(var->name)) {
-			if (r_message)
+			if (r_message) {
 				*r_message = RTR("Assignment to uniform.");
+			}
 			return false;
 		}
 
 		if (shader->varyings.has(var->name) && current_function != String("vertex")) {
-			if (r_message)
+			if (r_message) {
 				*r_message = RTR("Varyings can only be assigned in vertex function.");
+			}
 			return false;
 		}
 
 		if (shader->constants.has(var->name) || var->is_const) {
-			if (r_message)
+			if (r_message) {
 				*r_message = RTR("Constants cannot be modified.");
+			}
 			return false;
 		}
 
@@ -3041,22 +3065,25 @@ bool ShaderLanguage::_validate_assign(Node *p_node, const Map<StringName, BuiltI
 		ArrayNode *arr = static_cast<ArrayNode *>(p_node);
 
 		if (arr->is_const) {
-			if (r_message)
+			if (r_message) {
 				*r_message = RTR("Constants cannot be modified.");
+			}
 			return false;
 		}
 
 		if (shader->varyings.has(arr->name) && current_function != String("vertex")) {
-			if (r_message)
+			if (r_message) {
 				*r_message = RTR("Varyings can only be assigned in vertex function.");
+			}
 			return false;
 		}
 
 		return true;
 	}
 
-	if (r_message)
+	if (r_message) {
 		*r_message = "Assignment to constant expression.";
+	}
 	return false;
 }
 
@@ -3145,8 +3172,9 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
 			//handle subexpression
 
 			expr = _parse_and_reduce_expression(p_block, p_builtin_types);
-			if (!expr)
+			if (!expr) {
 				return nullptr;
+			}
 
 			tk = _get_token();
 
@@ -3226,8 +3254,9 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
 				completion_argument = carg;
 			}
 
-			if (!ok)
+			if (!ok) {
 				return nullptr;
+			}
 
 			if (!_validate_function_call(p_block, p_builtin_types, func, &func->return_cache, &func->struct_name)) {
 				_set_error("No matching constructor found for: '" + String(funcname->name) + "'");
@@ -3387,10 +3416,11 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
 										an->initializer.push_back(n);
 										break;
 									} else {
-										if (auto_size)
+										if (auto_size) {
 											_set_error("Expected '}' or ','");
-										else
+										} else {
 											_set_error("Expected ')' or ','");
+										}
 										return nullptr;
 									}
 								}
@@ -3485,8 +3515,9 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
 						completion_argument = carg;
 					}
 
-					if (!ok)
+					if (!ok) {
 						return nullptr;
+					}
 
 					if (!_validate_function_call(p_block, p_builtin_types, func, &func->return_cache, &func->struct_name)) {
 						_set_error("No matching function found for: '" + String(funcname->name) + "'");
@@ -3653,14 +3684,16 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
 						p_block->block_tag = SubClassTag::TAG_ARRAY;
 						call_expression = _parse_and_reduce_expression(p_block, p_builtin_types);
 						p_block->block_tag = SubClassTag::TAG_GLOBAL;
-						if (!call_expression)
+						if (!call_expression) {
 							return nullptr;
+						}
 						data_type = call_expression->get_datatype();
 					} else { // indexing
 
 						index_expression = _parse_and_reduce_expression(p_block, p_builtin_types);
-						if (!index_expression)
+						if (!index_expression) {
 							return nullptr;
+						}
 
 						if (index_expression->get_datatype() != TYPE_INT && index_expression->get_datatype() != TYPE_UINT) {
 							_set_error("Only integer expressions are allowed for indexing");
@@ -4038,8 +4071,9 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
 						return nullptr;
 					} else if (tk.type == TK_BRACKET_OPEN) {
 						Node *index_expression = _parse_and_reduce_expression(p_block, p_builtin_types);
-						if (!index_expression)
+						if (!index_expression) {
 							return nullptr;
+						}
 
 						if (index_expression->get_datatype() != TYPE_INT && index_expression->get_datatype() != TYPE_UINT) {
 							_set_error("Only integer expressions are allowed for indexing");
@@ -4086,8 +4120,9 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
 	*/
 			} else if (tk.type == TK_BRACKET_OPEN) {
 				Node *index = _parse_and_reduce_expression(p_block, p_builtin_types);
-				if (!index)
+				if (!index) {
 					return nullptr;
+				}
 
 				if (index->get_datatype() != TYPE_INT && index->get_datatype() != TYPE_UINT) {
 					_set_error("Only integer datatypes are allowed for indexing");
@@ -4536,8 +4571,9 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
 				if (!_validate_operator(op, &op->return_cache)) {
 					String at;
 					for (int j = 0; j < op->arguments.size(); j++) {
-						if (j > 0)
+						if (j > 0) {
 							at += " and ";
+						}
 						at += get_datatype_name(op->arguments[j]->get_datatype());
 					}
 					_set_error("Invalid arguments to unary operator '" + get_operator_text(op->op) + "' :" + at);
@@ -4568,8 +4604,9 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
 			if (!_validate_operator(op, &op->return_cache)) {
 				String at;
 				for (int i = 0; i < op->arguments.size(); i++) {
-					if (i > 0)
+					if (i > 0) {
 						at += " and ";
+					}
 					at += get_datatype_name(op->arguments[i]->get_datatype());
 				}
 				_set_error("Invalid argument to ternary ?: operator: " + at);
@@ -4620,8 +4657,9 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
 			if (!_validate_operator(op, &op->return_cache)) {
 				String at;
 				for (int i = 0; i < op->arguments.size(); i++) {
-					if (i > 0)
+					if (i > 0) {
 						at += " and ";
+					}
 					if (op->arguments[i]->get_datatype() == TYPE_STRUCT) {
 						at += op->arguments[i]->get_datatype_name();
 					} else {
@@ -4641,8 +4679,9 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
 }
 
 ShaderLanguage::Node *ShaderLanguage::_reduce_expression(BlockNode *p_block, ShaderLanguage::Node *p_node) {
-	if (p_node->type != Node::TYPE_OPERATOR)
+	if (p_node->type != Node::TYPE_OPERATOR) {
 		return p_node;
+	}
 
 	//for now only reduce simple constructors
 	OperatorNode *op = static_cast<OperatorNode *>(p_node);
@@ -4750,8 +4789,9 @@ ShaderLanguage::Node *ShaderLanguage::_reduce_expression(BlockNode *p_block, Sha
 
 ShaderLanguage::Node *ShaderLanguage::_parse_and_reduce_expression(BlockNode *p_block, const Map<StringName, BuiltInInfo> &p_builtin_types) {
 	ShaderLanguage::Node *expr = _parse_expression(p_block, p_builtin_types);
-	if (!expr) //errored
+	if (!expr) { //errored
 		return nullptr;
+	}
 
 	expr = _reduce_expression(p_block, expr);
 
@@ -5068,10 +5108,11 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const Map<StringName, Bui
 									decl.initializer.push_back(n);
 									break;
 								} else {
-									if (curly)
+									if (curly) {
 										_set_error("Expected '}' or ','");
-									else
+									} else {
 										_set_error("Expected ')' or ','");
+									}
 									return ERR_PARSE_ERROR;
 								}
 							}
@@ -5114,8 +5155,9 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const Map<StringName, Bui
 
 					//variable created with assignment! must parse an expression
 					Node *n = _parse_and_reduce_expression(p_block, p_builtin_types);
-					if (!n)
+					if (!n) {
 						return ERR_PARSE_ERROR;
+					}
 					if (node->is_const && n->type == Node::TYPE_OPERATOR && ((OperatorNode *)n)->op == OP_CALL) {
 						_set_error("Expected constant expression after '='");
 						return ERR_PARSE_ERROR;
@@ -5187,8 +5229,9 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const Map<StringName, Bui
 			ControlFlowNode *cf = alloc_node<ControlFlowNode>();
 			cf->flow_op = FLOW_OP_IF;
 			Node *n = _parse_and_reduce_expression(p_block, p_builtin_types);
-			if (!n)
+			if (!n) {
 				return ERR_PARSE_ERROR;
+			}
 
 			if (n->get_datatype() != TYPE_BOOL) {
 				_set_error("Expected boolean expression");
@@ -5208,8 +5251,9 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const Map<StringName, Bui
 			p_block->statements.push_back(cf);
 
 			Error err = _parse_block(block, p_builtin_types, true, p_can_break, p_can_continue);
-			if (err)
+			if (err) {
 				return err;
+			}
 
 			pos = _get_tkpos();
 			tk = _get_token();
@@ -5237,8 +5281,9 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const Map<StringName, Bui
 			ControlFlowNode *cf = alloc_node<ControlFlowNode>();
 			cf->flow_op = FLOW_OP_SWITCH;
 			Node *n = _parse_and_reduce_expression(p_block, p_builtin_types);
-			if (!n)
+			if (!n) {
 				return ERR_PARSE_ERROR;
+			}
 			if (n->get_datatype() != TYPE_INT) {
 				_set_error("Expected integer expression");
 				return ERR_PARSE_ERROR;
@@ -5365,8 +5410,9 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const Map<StringName, Bui
 			p_block->statements.push_back(cf);
 
 			Error err = _parse_block(case_block, p_builtin_types, false, true, false);
-			if (err)
+			if (err) {
 				return err;
+			}
 
 			return OK;
 
@@ -5398,8 +5444,9 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const Map<StringName, Bui
 			p_block->statements.push_back(cf);
 
 			Error err = _parse_block(default_block, p_builtin_types, false, true, false);
-			if (err)
+			if (err) {
 				return err;
+			}
 
 			return OK;
 
@@ -5414,8 +5461,9 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const Map<StringName, Bui
 				do_block->parent_block = p_block;
 
 				Error err = _parse_block(do_block, p_builtin_types, true, true, true);
-				if (err)
+				if (err) {
 					return err;
+				}
 
 				tk = _get_token();
 				if (tk.type != TK_CF_WHILE) {
@@ -5437,8 +5485,9 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const Map<StringName, Bui
 				cf->flow_op = FLOW_OP_WHILE;
 			}
 			Node *n = _parse_and_reduce_expression(p_block, p_builtin_types);
-			if (!n)
+			if (!n) {
 				return ERR_PARSE_ERROR;
+			}
 
 			tk = _get_token();
 			if (tk.type != TK_PARENTHESIS_CLOSE) {
@@ -5453,8 +5502,9 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const Map<StringName, Bui
 				p_block->statements.push_back(cf);
 
 				Error err = _parse_block(block, p_builtin_types, true, true, true);
-				if (err)
+				if (err) {
 					return err;
+				}
 			} else {
 				cf->expressions.push_back(n);
 				cf->blocks.push_back(do_block);
@@ -5487,8 +5537,9 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const Map<StringName, Bui
 			}
 
 			Node *n = _parse_and_reduce_expression(init_block, p_builtin_types);
-			if (!n)
+			if (!n) {
 				return ERR_PARSE_ERROR;
+			}
 
 			if (n->get_datatype() != TYPE_BOOL) {
 				_set_error("Middle expression is expected to be boolean.");
@@ -5504,8 +5555,9 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const Map<StringName, Bui
 			cf->expressions.push_back(n);
 
 			n = _parse_and_reduce_expression(init_block, p_builtin_types);
-			if (!n)
+			if (!n) {
 				return ERR_PARSE_ERROR;
+			}
 
 			cf->expressions.push_back(n);
 
@@ -5521,8 +5573,9 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const Map<StringName, Bui
 			p_block->statements.push_back(cf);
 
 			Error err = _parse_block(block, p_builtin_types, true, true, true);
-			if (err)
+			if (err) {
 				return err;
+			}
 
 		} else if (tk.type == TK_CF_RETURN) {
 			//check return type
@@ -5550,8 +5603,9 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const Map<StringName, Bui
 			} else {
 				_set_tkpos(pos); //rollback, wants expression
 				Node *expr = _parse_and_reduce_expression(p_block, p_builtin_types);
-				if (!expr)
+				if (!expr) {
 					return ERR_PARSE_ERROR;
+				}
 
 				if (b->parent_function->return_type != expr->get_datatype()) {
 					_set_error("Expected return expression of type '" + get_datatype_name(b->parent_function->return_type) + "'");
@@ -5651,8 +5705,9 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const Map<StringName, Bui
 			//nothing else, so expression
 			_set_tkpos(pos); //rollback
 			Node *expr = _parse_and_reduce_expression(p_block, p_builtin_types);
-			if (!expr)
+			if (!expr) {
 				return ERR_PARSE_ERROR;
+			}
 			p_block->statements.push_back(expr);
 			tk = _get_token();
 
@@ -5662,8 +5717,9 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const Map<StringName, Bui
 			}
 		}
 
-		if (p_just_one)
+		if (p_just_one) {
 			break;
+		}
 	}
 
 	return OK;
@@ -6239,8 +6295,9 @@ Error ShaderLanguage::_parse_shader(const Map<StringName, FunctionInfo> &p_funct
 
 					if (tk.type == TK_OP_ASSIGN) {
 						Node *expr = _parse_and_reduce_expression(nullptr, Map<StringName, BuiltInInfo>());
-						if (!expr)
+						if (!expr) {
 							return ERR_PARSE_ERROR;
+						}
 						if (expr->type != Node::TYPE_CONSTANT) {
 							_set_error("Expected constant expression after '='");
 							return ERR_PARSE_ERROR;
@@ -6397,8 +6454,9 @@ Error ShaderLanguage::_parse_shader(const Map<StringName, FunctionInfo> &p_funct
 
 							//variable created with assignment! must parse an expression
 							Node *expr = _parse_and_reduce_expression(nullptr, Map<StringName, BuiltInInfo>());
-							if (!expr)
+							if (!expr) {
 								return ERR_PARSE_ERROR;
+							}
 							if (expr->type == Node::TYPE_OPERATOR && ((OperatorNode *)expr)->op == OP_CALL) {
 								_set_error("Expected constant expression after '='");
 								return ERR_PARSE_ERROR;
@@ -6633,8 +6691,9 @@ Error ShaderLanguage::_parse_shader(const Map<StringName, FunctionInfo> &p_funct
 				current_function = name;
 
 				Error err = _parse_block(func_node->body, builtin_types);
-				if (err)
+				if (err) {
 					return err;
+				}
 
 				if (func_node->return_type != DataType::TYPE_VOID) {
 					BlockNode *block = func_node->body;
@@ -6730,8 +6789,9 @@ static int _get_first_ident_pos(const String &p_code) {
 		if (GETCHAR(0) == '/' && GETCHAR(1) == '/') {
 			idx += 2;
 			while (true) {
-				if (GETCHAR(0) == 0)
+				if (GETCHAR(0) == 0) {
 					return 0;
+				}
 				if (GETCHAR(0) == '\n') {
 					idx++;
 					break; // loop
@@ -6741,8 +6801,9 @@ static int _get_first_ident_pos(const String &p_code) {
 		} else if (GETCHAR(0) == '/' && GETCHAR(1) == '*') {
 			idx += 2;
 			while (true) {
-				if (GETCHAR(0) == 0)
+				if (GETCHAR(0) == 0) {
 					return 0;
+				}
 				if (GETCHAR(0) == '*' && GETCHAR(1) == '/') {
 					idx += 2;
 					break; // loop
@@ -6793,8 +6854,9 @@ String ShaderLanguage::get_shader_type(const String &p_code) {
 		}
 	}
 
-	if (reading_type)
+	if (reading_type) {
 		return cur_identifier;
+	}
 
 	return String();
 }
@@ -6917,8 +6979,9 @@ Error ShaderLanguage::complete(const String &p_code, const Map<StringName, Funct
 				}
 
 				for (int i = 0; i < shader->functions.size(); i++) {
-					if (!shader->functions[i].callable || shader->functions[i].name == skip_function)
+					if (!shader->functions[i].callable || shader->functions[i].name == skip_function) {
 						continue;
+					}
 					matches.insert(String(shader->functions[i].name), ScriptCodeCompletionOption::KIND_FUNCTION);
 				}
 
@@ -6962,8 +7025,9 @@ Error ShaderLanguage::complete(const String &p_code, const Map<StringName, Funct
 		} break;
 		case COMPLETION_CALL_ARGUMENTS: {
 			for (int i = 0; i < shader->functions.size(); i++) {
-				if (!shader->functions[i].callable)
+				if (!shader->functions[i].callable) {
 					continue;
+				}
 				if (shader->functions[i].name == completion_function) {
 					String calltip;
 
@@ -6973,10 +7037,11 @@ Error ShaderLanguage::complete(const String &p_code, const Map<StringName, Funct
 					calltip += "(";
 
 					for (int j = 0; j < shader->functions[i].function->arguments.size(); j++) {
-						if (j > 0)
+						if (j > 0) {
 							calltip += ", ";
-						else
+						} else {
 							calltip += " ";
+						}
 
 						if (j == completion_argument) {
 							calltip += CharType(0xFFFF);
@@ -6999,8 +7064,9 @@ Error ShaderLanguage::complete(const String &p_code, const Map<StringName, Funct
 						}
 					}
 
-					if (shader->functions[i].function->arguments.size())
+					if (shader->functions[i].function->arguments.size()) {
 						calltip += " ";
+					}
 					calltip += ")";
 
 					r_call_hint = calltip;
@@ -7035,8 +7101,9 @@ Error ShaderLanguage::complete(const String &p_code, const Map<StringName, Funct
 						continue;
 					}
 
-					if (calltip.length())
+					if (calltip.length()) {
 						calltip += "\n";
+					}
 
 					calltip += get_datatype_name(builtin_func_defs[idx].rettype);
 					calltip += " ";
@@ -7045,13 +7112,15 @@ Error ShaderLanguage::complete(const String &p_code, const Map<StringName, Funct
 
 					bool found_arg = false;
 					for (int i = 0; i < 4; i++) {
-						if (builtin_func_defs[idx].args[i] == TYPE_VOID)
+						if (builtin_func_defs[idx].args[i] == TYPE_VOID) {
 							break;
+						}
 
-						if (i > 0)
+						if (i > 0) {
 							calltip += ", ";
-						else
+						} else {
 							calltip += " ";
+						}
 
 						if (i == completion_argument) {
 							calltip += CharType(0xFFFF);
@@ -7070,8 +7139,9 @@ Error ShaderLanguage::complete(const String &p_code, const Map<StringName, Funct
 						found_arg = true;
 					}
 
-					if (found_arg)
+					if (found_arg) {
 						calltip += " ";
+					}
 					calltip += ")";
 				}
 				idx++;

servers/rendering/shader_language.h

@@ -770,8 +770,9 @@ private:
 	}
 
 	void _set_error(const String &p_str) {
-		if (error_set)
+		if (error_set) {
 			return;
+		}
 
 		error_line = tk_line;
 		error_set = true;

servers/rendering_server.cpp

@@ -43,8 +43,9 @@ RenderingServer *RenderingServer::get_singleton() {
 RenderingServer *RenderingServer::create() {
 	ERR_FAIL_COND_V(singleton, nullptr);
 
-	if (create_func)
+	if (create_func) {
 		return create_func();
+	}
 
 	return nullptr;
 }
@@ -148,12 +149,15 @@ RID RenderingServer::get_test_texture() {
 }
 
 void RenderingServer::_free_internal_rids() {
-	if (test_texture.is_valid())
+	if (test_texture.is_valid()) {
 		free(test_texture);
-	if (white_texture.is_valid())
+	}
+	if (white_texture.is_valid()) {
 		free(white_texture);
-	if (test_material.is_valid())
+	}
+	if (test_material.is_valid()) {
 		free(test_material);
+	}
 }
 
 RID RenderingServer::_make_test_cube() {
@@ -183,10 +187,11 @@ RID RenderingServer::_make_test_cube() {
 			v[2] = v[1] * (1 - 2 * (j & 1));
 
 			for (int k = 0; k < 3; k++) {
-				if (i < 3)
+				if (i < 3) {
 					face_points[j][(i + k) % 3] = v[k];
-				else
+				} else {
 					face_points[3 - j][(i + k) % 3] = -v[k];
+				}
 			}
 			normal_points[j] = Vector3();
 			normal_points[j][i % 3] = (i >= 3 ? -1 : 1);
@@ -213,8 +218,9 @@ RID RenderingServer::_make_test_cube() {
 
 	Vector<int> indices;
 	indices.resize(vertices.size());
-	for (int i = 0; i < vertices.size(); i++)
+	for (int i = 0; i < vertices.size(); i++) {
 		indices.set(i, i);
+	}
 	d[RenderingServer::ARRAY_INDEX] = indices;
 
 	mesh_add_surface_from_arrays(test_cube, PRIMITIVE_TRIANGLES, d);
@@ -290,15 +296,17 @@ RID RenderingServer::make_sphere_mesh(int p_lats, int p_lons, float p_radius) {
 }
 
 RID RenderingServer::get_white_texture() {
-	if (white_texture.is_valid())
+	if (white_texture.is_valid()) {
 		return white_texture;
+	}
 
 	Vector<uint8_t> wt;
 	wt.resize(16 * 3);
 	{
 		uint8_t *w = wt.ptrw();
-		for (int i = 0; i < 16 * 3; i++)
+		for (int i = 0; i < 16 * 3; i++) {
 			w[i] = 255;
+		}
 	}
 	Ref<Image> white = memnew(Image(4, 4, 0, Image::FORMAT_RGB8, wt));
 	white_texture = texture_2d_create(white);
@@ -319,8 +327,9 @@ Error RenderingServer::_surface_set_data(Array p_arrays, uint32_t p_format, uint
 	int max_bone = 0;
 
 	for (int ai = 0; ai < RS::ARRAY_MAX; ai++) {
-		if (!(p_format & (1 << ai))) // no array
+		if (!(p_format & (1 << ai))) { // no array
 			continue;
+		}
 
 		switch (ai) {
 			case RS::ARRAY_VERTEX: {
@@ -621,8 +630,9 @@ Error RenderingServer::_surface_set_data(Array p_arrays, uint32_t p_format, uint
 				for (int j = 0; j < 4; j++) {
 					int idx = rb[i * 4 + j];
 					float w = rw[i * 4 + j];
-					if (w == 0)
+					if (w == 0) {
 						continue; //break;
+					}
 					ERR_FAIL_INDEX_V(idx, total_bones, ERR_INVALID_DATA);
 
 					if (bptr[idx].size.x < 0) {
@@ -660,8 +670,9 @@ uint32_t RenderingServer::mesh_surface_make_offsets_from_format(uint32_t p_forma
 	for (int i = 0; i < RS::ARRAY_MAX; i++) {
 		r_offsets[i] = 0; //reset
 
-		if (!(p_format & (1 << i))) // no array
+		if (!(p_format & (1 << i))) { // no array
 			continue;
+		}
 
 		int elem_size = 0;
 
@@ -768,8 +779,9 @@ Error RenderingServer::mesh_create_surface_data_from_arrays(SurfaceData *r_surfa
 	int array_len = 0;
 
 	for (int i = 0; i < p_arrays.size(); i++) {
-		if (p_arrays[i].get_type() == Variant::NIL)
+		if (p_arrays[i].get_type() == Variant::NIL) {
 			continue;
+		}
 
 		format |= (1 << i);
 
@@ -802,8 +814,9 @@ Error RenderingServer::mesh_create_surface_data_from_arrays(SurfaceData *r_surfa
 			uint32_t bsformat = 0;
 			Array arr = p_blend_shapes[i];
 			for (int j = 0; j < arr.size(); j++) {
-				if (arr[j].get_type() != Variant::NIL)
+				if (arr[j].get_type() != Variant::NIL) {
 					bsformat |= (1 << j);
+				}
 			}
 
 			ERR_FAIL_COND_V((bsformat) != (format & (RS::ARRAY_FORMAT_INDEX - 1)), ERR_INVALID_PARAMETER);
@@ -817,8 +830,9 @@ Error RenderingServer::mesh_create_surface_data_from_arrays(SurfaceData *r_surfa
 	for (int i = 0; i < RS::ARRAY_MAX; i++) {
 		offsets[i] = 0; //reset
 
-		if (!(format & (1 << i))) // no array
+		if (!(format & (1 << i))) { // no array
 			continue;
+		}
 
 		int elem_size = 0;
 
@@ -1018,8 +1032,9 @@ Array RenderingServer::_get_array_from_surface(uint32_t p_format, Vector<uint8_t
 	for (int i = 0; i < RS::ARRAY_MAX; i++) {
 		offsets[i] = 0; //reset
 
-		if (!(p_format & (1 << i))) // no array
+		if (!(p_format & (1 << i))) { // no array
 			continue;
+		}
 
 		int elem_size = 0;
 
@@ -1115,8 +1130,9 @@ Array RenderingServer::_get_array_from_surface(uint32_t p_format, Vector<uint8_t
 	const uint8_t *r = p_vertex_data.ptr();
 
 	for (int i = 0; i < RS::ARRAY_MAX; i++) {
-		if (!(p_format & (1 << i)))
+		if (!(p_format & (1 << i))) {
 			continue;
+		}
 
 		switch (i) {
 			case RS::ARRAY_VERTEX: {