Style: clang-format: Disable KeepEmptyLinesAtTheStartOfBlocks

Which means that reduz' beloved style which we all became used to
will now be changed automatically to remove the first empty line.

This makes us lean closer to 1TBS (the one true brace style) instead
of hybridating it with some Allman-inspired spacing.

There's still the case of braces around single-statement blocks that
needs to be addressed (but clang-format can't help with that, but
clang-tidy may if we agree about it).

Part of #33027.

1 files changed, 0 insertions, 243 deletions

diff --git a/servers/rendering/rasterizer_rd/rasterizer_storage_rd.cpp b/servers/rendering/rasterizer_rd/rasterizer_storage_rd.cpp
index 5f3803e8be..63abe6b215 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_storage_rd.cpp
+++ b/servers/rendering/rasterizer_rd/rasterizer_storage_rd.cpp
@@ -36,7 +36,6 @@
 #include "servers/rendering/shader_language.h"
 
 Ref<Image> RasterizerStorageRD::_validate_texture_format(const Ref<Image> &p_image, TextureToRDFormat &r_format) {
-
 	Ref<Image> image = p_image->duplicate();
 
 	switch (p_image->get_format()) {
@@ -403,7 +402,6 @@ Ref<Image> RasterizerStorageRD::_validate_texture_format(const Ref<Image> &p_ima
 
 		} break; //etc2
 		case Image::FORMAT_ETC2_R11S: {
-
 			if (RD::get_singleton()->texture_is_format_supported_for_usage(RD::DATA_FORMAT_EAC_R11_SNORM_BLOCK, RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_UPDATE_BIT)) {
 				r_format.format = RD::DATA_FORMAT_EAC_R11_SNORM_BLOCK;
 			} else {
@@ -481,7 +479,6 @@ Ref<Image> RasterizerStorageRD::_validate_texture_format(const Ref<Image> &p_ima
 			r_format.swizzle_a = RD::TEXTURE_SWIZZLE_A;
 		} break;
 		case Image::FORMAT_ETC2_RGB8A1: {
-
 			if (RD::get_singleton()->texture_is_format_supported_for_usage(RD::DATA_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_UPDATE_BIT)) {
 				r_format.format = RD::DATA_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK;
 				r_format.format_srgb = RD::DATA_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK;
@@ -498,7 +495,6 @@ Ref<Image> RasterizerStorageRD::_validate_texture_format(const Ref<Image> &p_ima
 			r_format.swizzle_a = RD::TEXTURE_SWIZZLE_A;
 		} break;
 		case Image::FORMAT_ETC2_RA_AS_RG: {
-
 			if (RD::get_singleton()->texture_is_format_supported_for_usage(RD::DATA_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_UPDATE_BIT)) {
 				r_format.format = RD::DATA_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
 				r_format.format_srgb = RD::DATA_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK;
@@ -609,7 +605,6 @@ RID RasterizerStorageRD::texture_2d_create(const Ref<Image> &p_image) {
 }
 
 RID RasterizerStorageRD::texture_2d_layered_create(const Vector<Ref<Image>> &p_layers, RS::TextureLayeredType p_layered_type) {
-
 	ERR_FAIL_COND_V(p_layers.size() == 0, RID());
 
 	ERR_FAIL_COND_V(p_layered_type == RS::TEXTURE_LAYERED_CUBEMAP && p_layers.size() != 6, RID());
@@ -719,7 +714,6 @@ RID RasterizerStorageRD::texture_2d_layered_create(const Vector<Ref<Image>> &p_l
 	return texture_owner.make_rid(texture);
 }
 RID RasterizerStorageRD::texture_3d_create(const Vector<Ref<Image>> &p_slices) {
-
 	return RID();
 }
 
@@ -747,7 +741,6 @@ RID RasterizerStorageRD::texture_proxy_create(RID p_base) {
 }
 
 void RasterizerStorageRD::_texture_2d_update(RID p_texture, const Ref<Image> &p_image, int p_layer, bool p_immediate) {
-
 	ERR_FAIL_COND(p_image.is_null() || p_image->empty());
 
 	Texture *tex = texture_owner.getornull(p_texture);
@@ -779,7 +772,6 @@ void RasterizerStorageRD::texture_3d_update(RID p_texture, const Ref<Image> &p_i
 }
 
 void RasterizerStorageRD::texture_proxy_update(RID p_texture, RID p_proxy_to) {
-
 	Texture *tex = texture_owner.getornull(p_texture);
 	ERR_FAIL_COND(!tex);
 	ERR_FAIL_COND(!tex->is_proxy);
@@ -820,7 +812,6 @@ void RasterizerStorageRD::texture_proxy_update(RID p_texture, RID p_proxy_to) {
 
 //these two APIs can be used together or in combination with the others.
 RID RasterizerStorageRD::texture_2d_placeholder_create() {
-
 	//this could be better optimized to reuse an existing image , done this way
 	//for now to get it working
 	Ref<Image> image;
@@ -836,7 +827,6 @@ RID RasterizerStorageRD::texture_2d_placeholder_create() {
 	return texture_2d_create(image);
 }
 RID RasterizerStorageRD::texture_2d_layered_placeholder_create(RS::TextureLayeredType p_layered_type) {
-
 	//this could be better optimized to reuse an existing image , done this way
 	//for now to get it working
 	Ref<Image> image;
@@ -862,12 +852,10 @@ RID RasterizerStorageRD::texture_2d_layered_placeholder_create(RS::TextureLayere
 	return texture_2d_layered_create(images, p_layered_type);
 }
 RID RasterizerStorageRD::texture_3d_placeholder_create() {
-
 	return RID();
 }
 
 Ref<Image> RasterizerStorageRD::texture_2d_get(RID p_texture) const {
-
 	Texture *tex = texture_owner.getornull(p_texture);
 	ERR_FAIL_COND_V(!tex, Ref<Image>());
 
@@ -895,16 +883,13 @@ Ref<Image> RasterizerStorageRD::texture_2d_get(RID p_texture) const {
 	return image;
 }
 Ref<Image> RasterizerStorageRD::texture_2d_layer_get(RID p_texture, int p_layer) const {
-
 	return Ref<Image>();
 }
 Ref<Image> RasterizerStorageRD::texture_3d_slice_get(RID p_texture, int p_depth, int p_mipmap) const {
-
 	return Ref<Image>();
 }
 
 void RasterizerStorageRD::texture_replace(RID p_texture, RID p_by_texture) {
-
 	Texture *tex = texture_owner.getornull(p_texture);
 	ERR_FAIL_COND(!tex);
 	ERR_FAIL_COND(tex->proxy_to.is_valid()); //cant replace proxy
@@ -993,7 +978,6 @@ Size2 RasterizerStorageRD::texture_size_with_proxy(RID p_proxy) {
 /* SHADER API */
 
 RID RasterizerStorageRD::shader_create() {
-
 	Shader shader;
 	shader.data = nullptr;
 	shader.type = SHADER_TYPE_MAX;
@@ -1027,7 +1011,6 @@ void RasterizerStorageRD::shader_set_code(RID p_shader, const String &p_code) {
 		}
 
 		for (Set<Material *>::Element *E = shader->owners.front(); E; E = E->next()) {
-
 			Material *material = E->get();
 			material->shader_type = new_type;
 			if (material->data) {
@@ -1073,7 +1056,6 @@ String RasterizerStorageRD::shader_get_code(RID p_shader) const {
 	return shader->code;
 }
 void RasterizerStorageRD::shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const {
-
 	Shader *shader = shader_owner.getornull(p_shader);
 	ERR_FAIL_COND(!shader);
 	if (shader->data) {
@@ -1082,7 +1064,6 @@ void RasterizerStorageRD::shader_get_param_list(RID p_shader, List<PropertyInfo>
 }
 
 void RasterizerStorageRD::shader_set_default_texture_param(RID p_shader, const StringName &p_name, RID p_texture) {
-
 	Shader *shader = shader_owner.getornull(p_shader);
 	ERR_FAIL_COND(!shader);
 
@@ -1123,7 +1104,6 @@ void RasterizerStorageRD::shader_set_data_request_function(ShaderType p_shader_t
 /* COMMON MATERIAL API */
 
 RID RasterizerStorageRD::material_create() {
-
 	Material material;
 	material.data = nullptr;
 	material.shader = nullptr;
@@ -1154,7 +1134,6 @@ void RasterizerStorageRD::_material_queue_update(Material *material, bool p_unif
 }
 
 void RasterizerStorageRD::material_set_shader(RID p_material, RID p_shader) {
-
 	Material *material = material_owner.getornull(p_material);
 	ERR_FAIL_COND(!material);
 
@@ -1196,7 +1175,6 @@ void RasterizerStorageRD::material_set_shader(RID p_material, RID p_shader) {
 }
 
 void RasterizerStorageRD::material_set_param(RID p_material, const StringName &p_param, const Variant &p_value) {
-
 	Material *material = material_owner.getornull(p_material);
 	ERR_FAIL_COND(!material);
 
@@ -1274,7 +1252,6 @@ bool RasterizerStorageRD::material_casts_shadows(RID p_material) {
 }
 
 void RasterizerStorageRD::material_get_instance_shader_parameters(RID p_material, List<InstanceShaderParam> *r_parameters) {
-
 	Material *material = material_owner.getornull(p_material);
 	ERR_FAIL_COND(!material);
 	if (material->shader && material->shader->data) {
@@ -1303,14 +1280,12 @@ void RasterizerStorageRD::material_set_data_request_function(ShaderType p_shader
 _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataType type, const Variant &value, uint8_t *data, bool p_linear_color) {
 	switch (type) {
 		case ShaderLanguage::TYPE_BOOL: {
-
 			bool v = value;
 
 			uint32_t *gui = (uint32_t *)data;
 			*gui = v ? 1 : 0;
 		} break;
 		case ShaderLanguage::TYPE_BVEC2: {
-
 			int v = value;
 			uint32_t *gui = (uint32_t *)data;
 			gui[0] = v & 1 ? 1 : 0;
@@ -1318,7 +1293,6 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
 
 		} break;
 		case ShaderLanguage::TYPE_BVEC3: {
-
 			int v = value;
 			uint32_t *gui = (uint32_t *)data;
 			gui[0] = (v & 1) ? 1 : 0;
@@ -1327,7 +1301,6 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
 
 		} break;
 		case ShaderLanguage::TYPE_BVEC4: {
-
 			int v = value;
 			uint32_t *gui = (uint32_t *)data;
 			gui[0] = (v & 1) ? 1 : 0;
@@ -1337,14 +1310,12 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
 
 		} break;
 		case ShaderLanguage::TYPE_INT: {
-
 			int v = value;
 			int32_t *gui = (int32_t *)data;
 			gui[0] = v;
 
 		} break;
 		case ShaderLanguage::TYPE_IVEC2: {
-
 			Vector<int> iv = value;
 			int s = iv.size();
 			int32_t *gui = (int32_t *)data;
@@ -1360,7 +1331,6 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
 
 		} break;
 		case ShaderLanguage::TYPE_IVEC3: {
-
 			Vector<int> iv = value;
 			int s = iv.size();
 			int32_t *gui = (int32_t *)data;
@@ -1375,7 +1345,6 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
 			}
 		} break;
 		case ShaderLanguage::TYPE_IVEC4: {
-
 			Vector<int> iv = value;
 			int s = iv.size();
 			int32_t *gui = (int32_t *)data;
@@ -1390,14 +1359,12 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
 			}
 		} break;
 		case ShaderLanguage::TYPE_UINT: {
-
 			int v = value;
 			uint32_t *gui = (uint32_t *)data;
 			gui[0] = v;
 
 		} break;
 		case ShaderLanguage::TYPE_UVEC2: {
-
 			Vector<int> iv = value;
 			int s = iv.size();
 			uint32_t *gui = (uint32_t *)data;
@@ -1462,7 +1429,6 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
 
 		} break;
 		case ShaderLanguage::TYPE_VEC4: {
-
 			float *gui = (float *)data;
 
 			if (value.get_type() == Variant::COLOR) {
@@ -1514,7 +1480,6 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
 			gui[7] = 0;
 		} break;
 		case ShaderLanguage::TYPE_MAT3: {
-
 			Basis v = value;
 			float *gui = (float *)data;
 
@@ -1532,7 +1497,6 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
 			gui[11] = 0;
 		} break;
 		case ShaderLanguage::TYPE_MAT4: {
-
 			Transform v = value;
 			float *gui = (float *)data;
 
@@ -1559,22 +1523,18 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
 }
 
 _FORCE_INLINE_ static void _fill_std140_ubo_value(ShaderLanguage::DataType type, const Vector<ShaderLanguage::ConstantNode::Value> &value, uint8_t *data) {
-
 	switch (type) {
 		case ShaderLanguage::TYPE_BOOL: {
-
 			uint32_t *gui = (uint32_t *)data;
 			*gui = value[0].boolean ? 1 : 0;
 		} break;
 		case ShaderLanguage::TYPE_BVEC2: {
-
 			uint32_t *gui = (uint32_t *)data;
 			gui[0] = value[0].boolean ? 1 : 0;
 			gui[1] = value[1].boolean ? 1 : 0;
 
 		} break;
 		case ShaderLanguage::TYPE_BVEC3: {
-
 			uint32_t *gui = (uint32_t *)data;
 			gui[0] = value[0].boolean ? 1 : 0;
 			gui[1] = value[1].boolean ? 1 : 0;
@@ -1582,7 +1542,6 @@ _FORCE_INLINE_ static void _fill_std140_ubo_value(ShaderLanguage::DataType type,
 
 		} break;
 		case ShaderLanguage::TYPE_BVEC4: {
-
 			uint32_t *gui = (uint32_t *)data;
 			gui[0] = value[0].boolean ? 1 : 0;
 			gui[1] = value[1].boolean ? 1 : 0;
@@ -1591,13 +1550,11 @@ _FORCE_INLINE_ static void _fill_std140_ubo_value(ShaderLanguage::DataType type,
 
 		} break;
 		case ShaderLanguage::TYPE_INT: {
-
 			int32_t *gui = (int32_t *)data;
 			gui[0] = value[0].sint;
 
 		} break;
 		case ShaderLanguage::TYPE_IVEC2: {
-
 			int32_t *gui = (int32_t *)data;
 
 			for (int i = 0; i < 2; i++) {
@@ -1606,7 +1563,6 @@ _FORCE_INLINE_ static void _fill_std140_ubo_value(ShaderLanguage::DataType type,
 
 		} break;
 		case ShaderLanguage::TYPE_IVEC3: {
-
 			int32_t *gui = (int32_t *)data;
 
 			for (int i = 0; i < 3; i++) {
@@ -1615,7 +1571,6 @@ _FORCE_INLINE_ static void _fill_std140_ubo_value(ShaderLanguage::DataType type,
 
 		} break;
 		case ShaderLanguage::TYPE_IVEC4: {
-
 			int32_t *gui = (int32_t *)data;
 
 			for (int i = 0; i < 4; i++) {
@@ -1624,13 +1579,11 @@ _FORCE_INLINE_ static void _fill_std140_ubo_value(ShaderLanguage::DataType type,
 
 		} break;
 		case ShaderLanguage::TYPE_UINT: {
-
 			uint32_t *gui = (uint32_t *)data;
 			gui[0] = value[0].uint;
 
 		} break;
 		case ShaderLanguage::TYPE_UVEC2: {
-
 			int32_t *gui = (int32_t *)data;
 
 			for (int i = 0; i < 2; i++) {
@@ -1653,13 +1606,11 @@ _FORCE_INLINE_ static void _fill_std140_ubo_value(ShaderLanguage::DataType type,
 			}
 		} break;
 		case ShaderLanguage::TYPE_FLOAT: {
-
 			float *gui = (float *)data;
 			gui[0] = value[0].real;
 
 		} break;
 		case ShaderLanguage::TYPE_VEC2: {
-
 			float *gui = (float *)data;
 
 			for (int i = 0; i < 2; i++) {
@@ -1668,7 +1619,6 @@ _FORCE_INLINE_ static void _fill_std140_ubo_value(ShaderLanguage::DataType type,
 
 		} break;
 		case ShaderLanguage::TYPE_VEC3: {
-
 			float *gui = (float *)data;
 
 			for (int i = 0; i < 3; i++) {
@@ -1677,7 +1627,6 @@ _FORCE_INLINE_ static void _fill_std140_ubo_value(ShaderLanguage::DataType type,
 
 		} break;
 		case ShaderLanguage::TYPE_VEC4: {
-
 			float *gui = (float *)data;
 
 			for (int i = 0; i < 4; i++) {
@@ -1698,7 +1647,6 @@ _FORCE_INLINE_ static void _fill_std140_ubo_value(ShaderLanguage::DataType type,
 			gui[7] = 0;
 		} break;
 		case ShaderLanguage::TYPE_MAT3: {
-
 			float *gui = (float *)data;
 
 			gui[0] = value[0].real;
@@ -1715,7 +1663,6 @@ _FORCE_INLINE_ static void _fill_std140_ubo_value(ShaderLanguage::DataType type,
 			gui[11] = 0;
 		} break;
 		case ShaderLanguage::TYPE_MAT4: {
-
 			float *gui = (float *)data;
 
 			for (int i = 0; i < 16; i++) {
@@ -1728,9 +1675,7 @@ _FORCE_INLINE_ static void _fill_std140_ubo_value(ShaderLanguage::DataType type,
 }
 
 _FORCE_INLINE_ static void _fill_std140_ubo_empty(ShaderLanguage::DataType type, uint8_t *data) {
-
 	switch (type) {
-
 		case ShaderLanguage::TYPE_BOOL:
 		case ShaderLanguage::TYPE_INT:
 		case ShaderLanguage::TYPE_UINT:
@@ -1751,15 +1696,12 @@ _FORCE_INLINE_ static void _fill_std140_ubo_empty(ShaderLanguage::DataType type,
 		case ShaderLanguage::TYPE_IVEC4:
 		case ShaderLanguage::TYPE_UVEC4:
 		case ShaderLanguage::TYPE_VEC4: {
-
 			zeromem(data, 16);
 		} break;
 		case ShaderLanguage::TYPE_MAT2: {
-
 			zeromem(data, 32);
 		} break;
 		case ShaderLanguage::TYPE_MAT3: {
-
 			zeromem(data, 48);
 		} break;
 		case ShaderLanguage::TYPE_MAT4: {
@@ -1772,11 +1714,9 @@ _FORCE_INLINE_ static void _fill_std140_ubo_empty(ShaderLanguage::DataType type,
 }
 
 void RasterizerStorageRD::MaterialData::update_uniform_buffer(const Map<StringName, ShaderLanguage::ShaderNode::Uniform> &p_uniforms, const uint32_t *p_uniform_offsets, const Map<StringName, Variant> &p_parameters, uint8_t *p_buffer, uint32_t p_buffer_size, bool p_use_linear_color) {
-
 	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)
 			continue; // texture, does not go here
 
@@ -1866,7 +1806,6 @@ RasterizerStorageRD::MaterialData::~MaterialData() {
 }
 
 void RasterizerStorageRD::MaterialData::update_textures(const Map<StringName, Variant> &p_parameters, const Map<StringName, RID> &p_default_textures, const Vector<ShaderCompilerRD::GeneratedCode::Texture> &p_texture_uniforms, RID *p_textures, bool p_use_linear_color) {
-
 	RasterizerStorageRD *singleton = (RasterizerStorageRD *)RasterizerStorage::base_singleton;
 #ifdef TOOLS_ENABLED
 	Texture *roughness_detect_texture = nullptr;
@@ -1878,13 +1817,11 @@ void RasterizerStorageRD::MaterialData::update_textures(const Map<StringName, Va
 	global_textures_pass++;
 
 	for (int i = 0; i < p_texture_uniforms.size(); i++) {
-
 		const StringName &uniform_name = p_texture_uniforms[i].name;
 
 		RID texture;
 
 		if (p_texture_uniforms[i].global) {
-
 			RasterizerStorageRD *rs = base_singleton;
 
 			uses_global_textures = true;
@@ -1895,7 +1832,6 @@ void RasterizerStorageRD::MaterialData::update_textures(const Map<StringName, Va
 					WARN_PRINT("Shader uses global uniform texture '" + String(uniform_name) + "', but it changed type and is no longer a texture!.");
 
 				} else {
-
 					Map<StringName, uint64_t>::Element *E = used_global_textures.find(uniform_name);
 					if (!E) {
 						E = used_global_textures.insert(uniform_name, global_textures_pass);
@@ -1912,7 +1848,6 @@ void RasterizerStorageRD::MaterialData::update_textures(const Map<StringName, Va
 			}
 		} else {
 			if (!texture.is_valid()) {
-
 				const Map<StringName, Variant>::Element *V = p_parameters.find(uniform_name);
 				if (V) {
 					texture = V->get();
@@ -1922,7 +1857,6 @@ void RasterizerStorageRD::MaterialData::update_textures(const Map<StringName, Va
 			if (!texture.is_valid()) {
 				const Map<StringName, RID>::Element *W = p_default_textures.find(uniform_name);
 				if (W) {
-
 					texture = W->get();
 				}
 			}
@@ -1953,7 +1887,6 @@ void RasterizerStorageRD::MaterialData::update_textures(const Map<StringName, Va
 			Texture *tex = singleton->texture_owner.getornull(texture);
 
 			if (tex) {
-
 				rd_texture = (srgb && tex->rd_texture_srgb.is_valid()) ? tex->rd_texture_srgb : tex->rd_texture;
 #ifdef TOOLS_ENABLED
 				if (tex->detect_3d_callback && p_use_linear_color) {
@@ -2048,13 +1981,11 @@ void RasterizerStorageRD::_update_queued_materials() {
 /* MESH API */
 
 RID RasterizerStorageRD::mesh_create() {
-
 	return mesh_owner.make_rid(Mesh());
 }
 
 /// Returns stride
 void RasterizerStorageRD::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_surface) {
-
 	Mesh *mesh = mesh_owner.getornull(p_mesh);
 	ERR_FAIL_COND(!mesh);
 
@@ -2065,17 +1996,12 @@ void RasterizerStorageRD::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_
 #ifdef DEBUG_ENABLED
 	//do a validation, to catch errors first
 	{
-
 		uint32_t stride = 0;
 
 		for (int i = 0; i < RS::ARRAY_WEIGHTS; i++) {
-
 			if ((p_surface.format & (1 << i))) {
-
 				switch (i) {
-
 					case RS::ARRAY_VERTEX: {
-
 						if (p_surface.format & RS::ARRAY_FLAG_USE_2D_VERTICES) {
 							stride += sizeof(float) * 2;
 						} else {
@@ -2084,7 +2010,6 @@ void RasterizerStorageRD::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_
 
 					} break;
 					case RS::ARRAY_NORMAL: {
-
 						if (p_surface.format & RS::ARRAY_COMPRESS_NORMAL) {
 							stride += sizeof(int8_t) * 4;
 						} else {
@@ -2093,7 +2018,6 @@ void RasterizerStorageRD::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_
 
 					} break;
 					case RS::ARRAY_TANGENT: {
-
 						if (p_surface.format & RS::ARRAY_COMPRESS_TANGENT) {
 							stride += sizeof(int8_t) * 4;
 						} else {
@@ -2102,7 +2026,6 @@ void RasterizerStorageRD::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_
 
 					} break;
 					case RS::ARRAY_COLOR: {
-
 						if (p_surface.format & RS::ARRAY_COMPRESS_COLOR) {
 							stride += sizeof(int8_t) * 4;
 						} else {
@@ -2111,7 +2034,6 @@ void RasterizerStorageRD::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_
 
 					} break;
 					case RS::ARRAY_TEX_UV: {
-
 						if (p_surface.format & RS::ARRAY_COMPRESS_TEX_UV) {
 							stride += sizeof(int16_t) * 2;
 						} else {
@@ -2120,7 +2042,6 @@ void RasterizerStorageRD::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_
 
 					} break;
 					case RS::ARRAY_TEX_UV2: {
-
 						if (p_surface.format & RS::ARRAY_COMPRESS_TEX_UV2) {
 							stride += sizeof(int16_t) * 2;
 						} else {
@@ -2165,7 +2086,6 @@ void RasterizerStorageRD::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_
 			s->lod_count = p_surface.lods.size();
 
 			for (int i = 0; i < p_surface.lods.size(); i++) {
-
 				uint32_t indices = p_surface.lods[i].index_data.size() / (is_index_16 ? 2 : 4);
 				s->lods[i].index_buffer = RD::get_singleton()->index_buffer_create(indices, is_index_16 ? RD::INDEX_BUFFER_FORMAT_UINT16 : RD::INDEX_BUFFER_FORMAT_UINT32, p_surface.lods[i].index_data);
 				s->lods[i].index_array = RD::get_singleton()->index_array_create(s->lods[i].index_buffer, 0, indices);
@@ -2178,7 +2098,6 @@ void RasterizerStorageRD::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_
 	s->bone_aabbs = p_surface.bone_aabbs; //only really useful for returning them.
 
 	for (int i = 0; i < p_surface.blend_shapes.size(); i++) {
-
 		if (p_surface.blend_shapes[i].size() != p_surface.vertex_data.size()) {
 			memdelete(s);
 			ERR_FAIL_COND(p_surface.blend_shapes[i].size() != p_surface.vertex_data.size());
@@ -2258,7 +2177,6 @@ RID RasterizerStorageRD::mesh_surface_get_material(RID p_mesh, int p_surface) co
 }
 
 RS::SurfaceData RasterizerStorageRD::mesh_get_surface(RID p_mesh, int p_surface) const {
-
 	Mesh *mesh = mesh_owner.getornull(p_mesh);
 	ERR_FAIL_COND_V(!mesh, RS::SurfaceData());
 	ERR_FAIL_UNSIGNED_INDEX_V((uint32_t)p_surface, mesh->surface_count, RS::SurfaceData());
@@ -2327,10 +2245,8 @@ AABB RasterizerStorageRD::mesh_get_aabb(RID p_mesh, RID p_skeleton) {
 	AABB aabb;
 
 	for (uint32_t i = 0; i < mesh->surface_count; i++) {
-
 		AABB laabb;
 		if ((mesh->surfaces[i]->format & RS::ARRAY_FORMAT_BONES) && mesh->surfaces[i]->bone_aabbs.size()) {
-
 			int bs = mesh->surfaces[i]->bone_aabbs.size();
 			const AABB *skbones = mesh->surfaces[i]->bone_aabbs.ptr();
 
@@ -2342,7 +2258,6 @@ 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())
 						continue; //bone is unused
 
@@ -2369,7 +2284,6 @@ AABB RasterizerStorageRD::mesh_get_aabb(RID p_mesh, RID p_skeleton) {
 				}
 			} else {
 				for (int j = 0; j < bs; j++) {
-
 					if (skbones[0].size == Vector3())
 						continue; //bone is unused
 
@@ -2404,7 +2318,6 @@ AABB RasterizerStorageRD::mesh_get_aabb(RID p_mesh, RID p_skeleton) {
 				laabb = mesh->surfaces[i]->aabb;
 			}
 		} else {
-
 			laabb = mesh->surfaces[i]->aabb;
 		}
 
@@ -2419,7 +2332,6 @@ AABB RasterizerStorageRD::mesh_get_aabb(RID p_mesh, RID p_skeleton) {
 }
 
 void RasterizerStorageRD::mesh_clear(RID p_mesh) {
-
 	Mesh *mesh = mesh_owner.getornull(p_mesh);
 	ERR_FAIL_COND(!mesh);
 	for (uint32_t i = 0; i < mesh->surface_count; i++) {
@@ -2473,7 +2385,6 @@ void RasterizerStorageRD::_mesh_surface_generate_version_for_input_mask(Mesh::Su
 	uint32_t stride = 0;
 
 	for (int i = 0; i < RS::ARRAY_WEIGHTS; i++) {
-
 		RD::VertexAttribute vd;
 		RID buffer;
 		vd.location = i;
@@ -2482,9 +2393,7 @@ void RasterizerStorageRD::_mesh_surface_generate_version_for_input_mask(Mesh::Su
 			// Not supplied by surface, use default value
 			buffer = mesh_default_rd_buffers[i];
 			switch (i) {
-
 				case RS::ARRAY_VERTEX: {
-
 					vd.format = RD::DATA_FORMAT_R32G32B32_SFLOAT;
 
 				} break;
@@ -2492,25 +2401,20 @@ void RasterizerStorageRD::_mesh_surface_generate_version_for_input_mask(Mesh::Su
 					vd.format = RD::DATA_FORMAT_R32G32B32_SFLOAT;
 				} break;
 				case RS::ARRAY_TANGENT: {
-
 					vd.format = RD::DATA_FORMAT_R32G32B32A32_SFLOAT;
 				} break;
 				case RS::ARRAY_COLOR: {
-
 					vd.format = RD::DATA_FORMAT_R32G32B32A32_SFLOAT;
 
 				} break;
 				case RS::ARRAY_TEX_UV: {
-
 					vd.format = RD::DATA_FORMAT_R32G32_SFLOAT;
 
 				} break;
 				case RS::ARRAY_TEX_UV2: {
-
 					vd.format = RD::DATA_FORMAT_R32G32_SFLOAT;
 				} break;
 				case RS::ARRAY_BONES: {
-
 					//assumed weights too
 					vd.format = RD::DATA_FORMAT_R32G32B32A32_UINT;
 				} break;
@@ -2523,9 +2427,7 @@ void RasterizerStorageRD::_mesh_surface_generate_version_for_input_mask(Mesh::Su
 			buffer = s->vertex_buffer;
 
 			switch (i) {
-
 				case RS::ARRAY_VERTEX: {
-
 					if (s->format & RS::ARRAY_FLAG_USE_2D_VERTICES) {
 						vd.format = RD::DATA_FORMAT_R32G32_SFLOAT;
 						stride += sizeof(float) * 2;
@@ -2536,7 +2438,6 @@ void RasterizerStorageRD::_mesh_surface_generate_version_for_input_mask(Mesh::Su
 
 				} break;
 				case RS::ARRAY_NORMAL: {
-
 					if (s->format & RS::ARRAY_COMPRESS_NORMAL) {
 						vd.format = RD::DATA_FORMAT_R8G8B8A8_SNORM;
 						stride += sizeof(int8_t) * 4;
@@ -2547,7 +2448,6 @@ void RasterizerStorageRD::_mesh_surface_generate_version_for_input_mask(Mesh::Su
 
 				} break;
 				case RS::ARRAY_TANGENT: {
-
 					if (s->format & RS::ARRAY_COMPRESS_TANGENT) {
 						vd.format = RD::DATA_FORMAT_R8G8B8A8_SNORM;
 						stride += sizeof(int8_t) * 4;
@@ -2558,7 +2458,6 @@ void RasterizerStorageRD::_mesh_surface_generate_version_for_input_mask(Mesh::Su
 
 				} break;
 				case RS::ARRAY_COLOR: {
-
 					if (s->format & RS::ARRAY_COMPRESS_COLOR) {
 						vd.format = RD::DATA_FORMAT_R8G8B8A8_UNORM;
 						stride += sizeof(int8_t) * 4;
@@ -2569,7 +2468,6 @@ void RasterizerStorageRD::_mesh_surface_generate_version_for_input_mask(Mesh::Su
 
 				} break;
 				case RS::ARRAY_TEX_UV: {
-
 					if (s->format & RS::ARRAY_COMPRESS_TEX_UV) {
 						vd.format = RD::DATA_FORMAT_R16G16_SFLOAT;
 						stride += sizeof(int16_t) * 2;
@@ -2580,7 +2478,6 @@ void RasterizerStorageRD::_mesh_surface_generate_version_for_input_mask(Mesh::Su
 
 				} break;
 				case RS::ARRAY_TEX_UV2: {
-
 					if (s->format & RS::ARRAY_COMPRESS_TEX_UV2) {
 						vd.format = RD::DATA_FORMAT_R16G16_SFLOAT;
 						stride += sizeof(int16_t) * 2;
@@ -2625,12 +2522,10 @@ void RasterizerStorageRD::_mesh_surface_generate_version_for_input_mask(Mesh::Su
 ////////////////// MULTIMESH
 
 RID RasterizerStorageRD::multimesh_create() {
-
 	return multimesh_owner.make_rid(MultiMesh());
 }
 
 void RasterizerStorageRD::multimesh_allocate(RID p_multimesh, int p_instances, RS::MultimeshTransformFormat p_transform_format, bool p_use_colors, bool p_use_custom_data) {
-
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
 
@@ -2666,7 +2561,6 @@ void RasterizerStorageRD::multimesh_allocate(RID p_multimesh, int p_instances, R
 	multimesh->visible_instances = MIN(multimesh->visible_instances, multimesh->instances);
 
 	if (multimesh->instances) {
-
 		multimesh->buffer = RD::get_singleton()->storage_buffer_create(multimesh->instances * multimesh->stride_cache * 4);
 	}
 }
@@ -2721,7 +2615,6 @@ void RasterizerStorageRD::_multimesh_make_local(MultiMesh *multimesh) const {
 		if (multimesh->buffer_set) {
 			Vector<uint8_t> buffer = RD::get_singleton()->buffer_get_data(multimesh->buffer);
 			{
-
 				const uint8_t *r = buffer.ptr();
 				copymem(w, r, buffer.size());
 			}
@@ -2738,7 +2631,6 @@ void RasterizerStorageRD::_multimesh_make_local(MultiMesh *multimesh) const {
 }
 
 void RasterizerStorageRD::_multimesh_mark_dirty(MultiMesh *multimesh, int p_index, bool p_aabb) {
-
 	uint32_t region_index = p_index / MULTIMESH_DIRTY_REGION_SIZE;
 #ifdef DEBUG_ENABLED
 	uint32_t data_cache_dirty_region_count = (multimesh->instances - 1) / MULTIMESH_DIRTY_REGION_SIZE + 1;
@@ -2784,7 +2676,6 @@ void RasterizerStorageRD::_multimesh_mark_all_dirty(MultiMesh *multimesh, bool p
 }
 
 void RasterizerStorageRD::_multimesh_re_create_aabb(MultiMesh *multimesh, const float *p_data, int p_instances) {
-
 	ERR_FAIL_COND(multimesh->mesh.is_null());
 	AABB aabb;
 	AABB mesh_aabb = mesh_get_aabb(multimesh->mesh);
@@ -2793,7 +2684,6 @@ void RasterizerStorageRD::_multimesh_re_create_aabb(MultiMesh *multimesh, const
 		Transform t;
 
 		if (multimesh->xform_format == RS::MULTIMESH_TRANSFORM_3D) {
-
 			t.basis.elements[0][0] = data[0];
 			t.basis.elements[0][1] = data[1];
 			t.basis.elements[0][2] = data[2];
@@ -2808,7 +2698,6 @@ void RasterizerStorageRD::_multimesh_re_create_aabb(MultiMesh *multimesh, const
 			t.origin.z = data[11];
 
 		} else {
-
 			t.basis.elements[0].x = data[0];
 			t.basis.elements[1].x = data[1];
 			t.origin.x = data[3];
@@ -2829,7 +2718,6 @@ void RasterizerStorageRD::_multimesh_re_create_aabb(MultiMesh *multimesh, const
 }
 
 void RasterizerStorageRD::multimesh_instance_set_transform(RID p_multimesh, int p_index, const Transform &p_transform) {
-
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
 	ERR_FAIL_INDEX(p_index, multimesh->instances);
@@ -2860,7 +2748,6 @@ void RasterizerStorageRD::multimesh_instance_set_transform(RID p_multimesh, int
 }
 
 void RasterizerStorageRD::multimesh_instance_set_transform_2d(RID p_multimesh, int p_index, const Transform2D &p_transform) {
-
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
 	ERR_FAIL_INDEX(p_index, multimesh->instances);
@@ -2886,7 +2773,6 @@ void RasterizerStorageRD::multimesh_instance_set_transform_2d(RID p_multimesh, i
 	_multimesh_mark_dirty(multimesh, p_index, true);
 }
 void RasterizerStorageRD::multimesh_instance_set_color(RID p_multimesh, int p_index, const Color &p_color) {
-
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
 	ERR_FAIL_INDEX(p_index, multimesh->instances);
@@ -2930,7 +2816,6 @@ void RasterizerStorageRD::multimesh_instance_set_custom_data(RID p_multimesh, in
 }
 
 RID RasterizerStorageRD::multimesh_get_mesh(RID p_multimesh) const {
-
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND_V(!multimesh, RID());
 
@@ -2938,7 +2823,6 @@ RID RasterizerStorageRD::multimesh_get_mesh(RID p_multimesh) const {
 }
 
 Transform RasterizerStorageRD::multimesh_instance_get_transform(RID p_multimesh, int p_index) const {
-
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND_V(!multimesh, Transform());
 	ERR_FAIL_INDEX_V(p_index, multimesh->instances, Transform());
@@ -2969,7 +2853,6 @@ Transform RasterizerStorageRD::multimesh_instance_get_transform(RID p_multimesh,
 	return t;
 }
 Transform2D RasterizerStorageRD::multimesh_instance_get_transform_2d(RID p_multimesh, int p_index) const {
-
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND_V(!multimesh, Transform2D());
 	ERR_FAIL_INDEX_V(p_index, multimesh->instances, Transform2D());
@@ -2994,7 +2877,6 @@ Transform2D RasterizerStorageRD::multimesh_instance_get_transform_2d(RID p_multi
 	return t;
 }
 Color RasterizerStorageRD::multimesh_instance_get_color(RID p_multimesh, int p_index) const {
-
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND_V(!multimesh, Color());
 	ERR_FAIL_INDEX_V(p_index, multimesh->instances, Color());
@@ -3017,7 +2899,6 @@ Color RasterizerStorageRD::multimesh_instance_get_color(RID p_multimesh, int p_i
 	return c;
 }
 Color RasterizerStorageRD::multimesh_instance_get_custom_data(RID p_multimesh, int p_index) const {
-
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND_V(!multimesh, Color());
 	ERR_FAIL_INDEX_V(p_index, multimesh->instances, Color());
@@ -3097,7 +2978,6 @@ Vector<float> RasterizerStorageRD::multimesh_get_buffer(RID p_multimesh) const {
 }
 
 void RasterizerStorageRD::multimesh_set_visible_instances(RID p_multimesh, int p_visible) {
-
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
 	ERR_FAIL_COND(p_visible < -1 || p_visible > multimesh->instances);
@@ -3128,9 +3008,7 @@ AABB RasterizerStorageRD::multimesh_get_aabb(RID p_multimesh) const {
 }
 
 void RasterizerStorageRD::_update_dirty_multimeshes() {
-
 	while (multimesh_dirty_list) {
-
 		MultiMesh *multimesh = multimesh_dirty_list;
 
 		if (multimesh->data_cache.size()) { //may have been cleared, so only process if it exists
@@ -3139,7 +3017,6 @@ void RasterizerStorageRD::_update_dirty_multimeshes() {
 			uint32_t visible_instances = multimesh->visible_instances >= 0 ? multimesh->visible_instances : multimesh->instances;
 
 			if (multimesh->data_cache_used_dirty_regions) {
-
 				uint32_t data_cache_dirty_region_count = (multimesh->instances - 1) / MULTIMESH_DIRTY_REGION_SIZE + 1;
 				uint32_t visible_region_count = (visible_instances - 1) / MULTIMESH_DIRTY_REGION_SIZE + 1;
 
@@ -3188,12 +3065,10 @@ void RasterizerStorageRD::_update_dirty_multimeshes() {
 /* SKELETON API */
 
 RID RasterizerStorageRD::skeleton_create() {
-
 	return skeleton_owner.make_rid(Skeleton());
 }
 
 void RasterizerStorageRD::_skeleton_make_dirty(Skeleton *skeleton) {
-
 	if (!skeleton->dirty) {
 		skeleton->dirty = true;
 		skeleton->dirty_list = skeleton_dirty_list;
@@ -3202,7 +3077,6 @@ void RasterizerStorageRD::_skeleton_make_dirty(Skeleton *skeleton) {
 }
 
 void RasterizerStorageRD::skeleton_allocate(RID p_skeleton, int p_bones, bool p_2d_skeleton) {
-
 	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
 	ERR_FAIL_COND(!skeleton);
 	ERR_FAIL_COND(p_bones < 0);
@@ -3221,7 +3095,6 @@ void RasterizerStorageRD::skeleton_allocate(RID p_skeleton, int p_bones, bool p_
 	}
 
 	if (skeleton->size) {
-
 		skeleton->data.resize(skeleton->size * (skeleton->use_2d ? 8 : 12));
 		skeleton->buffer = RD::get_singleton()->storage_buffer_create(skeleton->data.size() * sizeof(float));
 		zeromem(skeleton->data.ptrw(), skeleton->data.size() * sizeof(float));
@@ -3230,7 +3103,6 @@ void RasterizerStorageRD::skeleton_allocate(RID p_skeleton, int p_bones, bool p_
 	}
 }
 int RasterizerStorageRD::skeleton_get_bone_count(RID p_skeleton) const {
-
 	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
 	ERR_FAIL_COND_V(!skeleton, 0);
 
@@ -3238,7 +3110,6 @@ int RasterizerStorageRD::skeleton_get_bone_count(RID p_skeleton) const {
 }
 
 void RasterizerStorageRD::skeleton_bone_set_transform(RID p_skeleton, int p_bone, const Transform &p_transform) {
-
 	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
 
 	ERR_FAIL_COND(!skeleton);
@@ -3264,7 +3135,6 @@ void RasterizerStorageRD::skeleton_bone_set_transform(RID p_skeleton, int p_bone
 }
 
 Transform RasterizerStorageRD::skeleton_bone_get_transform(RID p_skeleton, int p_bone) const {
-
 	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
 
 	ERR_FAIL_COND_V(!skeleton, Transform());
@@ -3291,7 +3161,6 @@ Transform RasterizerStorageRD::skeleton_bone_get_transform(RID p_skeleton, int p
 	return t;
 }
 void RasterizerStorageRD::skeleton_bone_set_transform_2d(RID p_skeleton, int p_bone, const Transform2D &p_transform) {
-
 	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
 
 	ERR_FAIL_COND(!skeleton);
@@ -3312,7 +3181,6 @@ void RasterizerStorageRD::skeleton_bone_set_transform_2d(RID p_skeleton, int p_b
 	_skeleton_make_dirty(skeleton);
 }
 Transform2D RasterizerStorageRD::skeleton_bone_get_transform_2d(RID p_skeleton, int p_bone) const {
-
 	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
 
 	ERR_FAIL_COND_V(!skeleton, Transform2D());
@@ -3333,7 +3201,6 @@ Transform2D RasterizerStorageRD::skeleton_bone_get_transform_2d(RID p_skeleton,
 }
 
 void RasterizerStorageRD::skeleton_set_base_transform_2d(RID p_skeleton, const Transform2D &p_base_transform) {
-
 	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
 
 	ERR_FAIL_COND(!skeleton->use_2d);
@@ -3342,13 +3209,10 @@ void RasterizerStorageRD::skeleton_set_base_transform_2d(RID p_skeleton, const T
 }
 
 void RasterizerStorageRD::_update_dirty_skeletons() {
-
 	while (skeleton_dirty_list) {
-
 		Skeleton *skeleton = skeleton_dirty_list;
 
 		if (skeleton->size) {
-
 			RD::get_singleton()->buffer_update(skeleton->buffer, 0, skeleton->data.size() * sizeof(float), skeleton->data.ptr(), false);
 		}
 
@@ -3366,7 +3230,6 @@ void RasterizerStorageRD::_update_dirty_skeletons() {
 /* LIGHT */
 
 RID RasterizerStorageRD::light_create(RS::LightType p_type) {
-
 	Light light;
 	light.type = p_type;
 
@@ -3390,14 +3253,12 @@ RID RasterizerStorageRD::light_create(RS::LightType p_type) {
 }
 
 void RasterizerStorageRD::light_set_color(RID p_light, const Color &p_color) {
-
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 
 	light->color = p_color;
 }
 void RasterizerStorageRD::light_set_param(RID p_light, RS::LightParam p_param, float p_value) {
-
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 	ERR_FAIL_INDEX(p_param, RS::LIGHT_PARAM_MAX);
@@ -3412,7 +3273,6 @@ void RasterizerStorageRD::light_set_param(RID p_light, RS::LightParam p_param, f
 		case RS::LIGHT_PARAM_SHADOW_NORMAL_BIAS:
 		case RS::LIGHT_PARAM_SHADOW_PANCAKE_SIZE:
 		case RS::LIGHT_PARAM_SHADOW_BIAS: {
-
 			light->version++;
 			light->instance_dependency.instance_notify_changed(true, false);
 		} break;
@@ -3423,7 +3283,6 @@ void RasterizerStorageRD::light_set_param(RID p_light, RS::LightParam p_param, f
 	light->param[p_param] = p_value;
 }
 void RasterizerStorageRD::light_set_shadow(RID p_light, bool p_enabled) {
-
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 	light->shadow = p_enabled;
@@ -3433,14 +3292,12 @@ void RasterizerStorageRD::light_set_shadow(RID p_light, bool p_enabled) {
 }
 
 void RasterizerStorageRD::light_set_shadow_color(RID p_light, const Color &p_color) {
-
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 	light->shadow_color = p_color;
 }
 
 void RasterizerStorageRD::light_set_projector(RID p_light, RID p_texture) {
-
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 
@@ -3460,14 +3317,12 @@ void RasterizerStorageRD::light_set_projector(RID p_light, RID p_texture) {
 }
 
 void RasterizerStorageRD::light_set_negative(RID p_light, bool p_enable) {
-
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 
 	light->negative = p_enable;
 }
 void RasterizerStorageRD::light_set_cull_mask(RID p_light, uint32_t p_mask) {
-
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 
@@ -3478,7 +3333,6 @@ void RasterizerStorageRD::light_set_cull_mask(RID p_light, uint32_t p_mask) {
 }
 
 void RasterizerStorageRD::light_set_reverse_cull_face_mode(RID p_light, bool p_enabled) {
-
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 
@@ -3498,7 +3352,6 @@ void RasterizerStorageRD::light_set_use_gi(RID p_light, bool p_enabled) {
 	light->instance_dependency.instance_notify_changed(true, false);
 }
 void RasterizerStorageRD::light_omni_set_shadow_mode(RID p_light, RS::LightOmniShadowMode p_mode) {
-
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 
@@ -3509,7 +3362,6 @@ void RasterizerStorageRD::light_omni_set_shadow_mode(RID p_light, RS::LightOmniS
 }
 
 RS::LightOmniShadowMode RasterizerStorageRD::light_omni_get_shadow_mode(RID p_light) {
-
 	const Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND_V(!light, RS::LIGHT_OMNI_SHADOW_CUBE);
 
@@ -3517,7 +3369,6 @@ RS::LightOmniShadowMode RasterizerStorageRD::light_omni_get_shadow_mode(RID p_li
 }
 
 void RasterizerStorageRD::light_directional_set_shadow_mode(RID p_light, RS::LightDirectionalShadowMode p_mode) {
-
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 
@@ -3527,7 +3378,6 @@ void RasterizerStorageRD::light_directional_set_shadow_mode(RID p_light, RS::Lig
 }
 
 void RasterizerStorageRD::light_directional_set_blend_splits(RID p_light, bool p_enable) {
-
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 
@@ -3537,7 +3387,6 @@ void RasterizerStorageRD::light_directional_set_blend_splits(RID p_light, bool p
 }
 
 bool RasterizerStorageRD::light_directional_get_blend_splits(RID p_light) const {
-
 	const Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND_V(!light, false);
 
@@ -3545,7 +3394,6 @@ bool RasterizerStorageRD::light_directional_get_blend_splits(RID p_light) const
 }
 
 RS::LightDirectionalShadowMode RasterizerStorageRD::light_directional_get_shadow_mode(RID p_light) {
-
 	const Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND_V(!light, RS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL);
 
@@ -3553,7 +3401,6 @@ RS::LightDirectionalShadowMode RasterizerStorageRD::light_directional_get_shadow
 }
 
 void RasterizerStorageRD::light_directional_set_shadow_depth_range_mode(RID p_light, RS::LightDirectionalShadowDepthRangeMode p_range_mode) {
-
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 
@@ -3561,7 +3408,6 @@ void RasterizerStorageRD::light_directional_set_shadow_depth_range_mode(RID p_li
 }
 
 RS::LightDirectionalShadowDepthRangeMode RasterizerStorageRD::light_directional_get_shadow_depth_range_mode(RID p_light) const {
-
 	const Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND_V(!light, RS::LIGHT_DIRECTIONAL_SHADOW_DEPTH_RANGE_STABLE);
 
@@ -3576,7 +3422,6 @@ bool RasterizerStorageRD::light_get_use_gi(RID p_light) {
 }
 
 uint64_t RasterizerStorageRD::light_get_version(RID p_light) const {
-
 	const Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND_V(!light, 0);
 
@@ -3584,25 +3429,20 @@ uint64_t RasterizerStorageRD::light_get_version(RID p_light) const {
 }
 
 AABB RasterizerStorageRD::light_get_aabb(RID p_light) const {
-
 	const Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND_V(!light, AABB());
 
 	switch (light->type) {
-
 		case RS::LIGHT_SPOT: {
-
 			float len = light->param[RS::LIGHT_PARAM_RANGE];
 			float size = Math::tan(Math::deg2rad(light->param[RS::LIGHT_PARAM_SPOT_ANGLE])) * len;
 			return AABB(Vector3(-size, -size, -len), Vector3(size * 2, size * 2, len));
 		};
 		case RS::LIGHT_OMNI: {
-
 			float r = light->param[RS::LIGHT_PARAM_RANGE];
 			return AABB(-Vector3(r, r, r), Vector3(r, r, r) * 2);
 		};
 		case RS::LIGHT_DIRECTIONAL: {
-
 			return AABB();
 		};
 	}
@@ -3613,12 +3453,10 @@ AABB RasterizerStorageRD::light_get_aabb(RID p_light) const {
 /* REFLECTION PROBE */
 
 RID RasterizerStorageRD::reflection_probe_create() {
-
 	return reflection_probe_owner.make_rid(ReflectionProbe());
 }
 
 void RasterizerStorageRD::reflection_probe_set_update_mode(RID p_probe, RS::ReflectionProbeUpdateMode p_mode) {
-
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
@@ -3627,7 +3465,6 @@ void RasterizerStorageRD::reflection_probe_set_update_mode(RID p_probe, RS::Refl
 }
 
 void RasterizerStorageRD::reflection_probe_set_intensity(RID p_probe, float p_intensity) {
-
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
@@ -3635,7 +3472,6 @@ void RasterizerStorageRD::reflection_probe_set_intensity(RID p_probe, float p_in
 }
 
 void RasterizerStorageRD::reflection_probe_set_interior_ambient(RID p_probe, const Color &p_ambient) {
-
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
@@ -3643,7 +3479,6 @@ void RasterizerStorageRD::reflection_probe_set_interior_ambient(RID p_probe, con
 }
 
 void RasterizerStorageRD::reflection_probe_set_interior_ambient_energy(RID p_probe, float p_energy) {
-
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
@@ -3651,7 +3486,6 @@ void RasterizerStorageRD::reflection_probe_set_interior_ambient_energy(RID p_pro
 }
 
 void RasterizerStorageRD::reflection_probe_set_interior_ambient_probe_contribution(RID p_probe, float p_contrib) {
-
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
@@ -3659,7 +3493,6 @@ void RasterizerStorageRD::reflection_probe_set_interior_ambient_probe_contributi
 }
 
 void RasterizerStorageRD::reflection_probe_set_max_distance(RID p_probe, float p_distance) {
-
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
@@ -3668,7 +3501,6 @@ void RasterizerStorageRD::reflection_probe_set_max_distance(RID p_probe, float p
 	reflection_probe->instance_dependency.instance_notify_changed(true, false);
 }
 void RasterizerStorageRD::reflection_probe_set_extents(RID p_probe, const Vector3 &p_extents) {
-
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
@@ -3676,7 +3508,6 @@ void RasterizerStorageRD::reflection_probe_set_extents(RID p_probe, const Vector
 	reflection_probe->instance_dependency.instance_notify_changed(true, false);
 }
 void RasterizerStorageRD::reflection_probe_set_origin_offset(RID p_probe, const Vector3 &p_offset) {
-
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
@@ -3685,7 +3516,6 @@ void RasterizerStorageRD::reflection_probe_set_origin_offset(RID p_probe, const
 }
 
 void RasterizerStorageRD::reflection_probe_set_as_interior(RID p_probe, bool p_enable) {
-
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
@@ -3693,7 +3523,6 @@ void RasterizerStorageRD::reflection_probe_set_as_interior(RID p_probe, bool p_e
 	reflection_probe->instance_dependency.instance_notify_changed(true, false);
 }
 void RasterizerStorageRD::reflection_probe_set_enable_box_projection(RID p_probe, bool p_enable) {
-
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
@@ -3701,7 +3530,6 @@ void RasterizerStorageRD::reflection_probe_set_enable_box_projection(RID p_probe
 }
 
 void RasterizerStorageRD::reflection_probe_set_enable_shadows(RID p_probe, bool p_enable) {
-
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
@@ -3709,7 +3537,6 @@ void RasterizerStorageRD::reflection_probe_set_enable_shadows(RID p_probe, bool
 	reflection_probe->instance_dependency.instance_notify_changed(true, false);
 }
 void RasterizerStorageRD::reflection_probe_set_cull_mask(RID p_probe, uint32_t p_layers) {
-
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
@@ -3718,7 +3545,6 @@ void RasterizerStorageRD::reflection_probe_set_cull_mask(RID p_probe, uint32_t p
 }
 
 void RasterizerStorageRD::reflection_probe_set_resolution(RID p_probe, int p_resolution) {
-
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 	ERR_FAIL_COND(p_resolution < 32);
@@ -3737,7 +3563,6 @@ AABB RasterizerStorageRD::reflection_probe_get_aabb(RID p_probe) const {
 	return aabb;
 }
 RS::ReflectionProbeUpdateMode RasterizerStorageRD::reflection_probe_get_update_mode(RID p_probe) const {
-
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, RS::REFLECTION_PROBE_UPDATE_ALWAYS);
 
@@ -3745,7 +3570,6 @@ RS::ReflectionProbeUpdateMode RasterizerStorageRD::reflection_probe_get_update_m
 }
 
 uint32_t RasterizerStorageRD::reflection_probe_get_cull_mask(RID p_probe) const {
-
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, 0);
 
@@ -3753,14 +3577,12 @@ uint32_t RasterizerStorageRD::reflection_probe_get_cull_mask(RID p_probe) const
 }
 
 Vector3 RasterizerStorageRD::reflection_probe_get_extents(RID p_probe) const {
-
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, Vector3());
 
 	return reflection_probe->extents;
 }
 Vector3 RasterizerStorageRD::reflection_probe_get_origin_offset(RID p_probe) const {
-
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, Vector3());
 
@@ -3768,7 +3590,6 @@ Vector3 RasterizerStorageRD::reflection_probe_get_origin_offset(RID p_probe) con
 }
 
 bool RasterizerStorageRD::reflection_probe_renders_shadows(RID p_probe) const {
-
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, false);
 
@@ -3776,7 +3597,6 @@ bool RasterizerStorageRD::reflection_probe_renders_shadows(RID p_probe) const {
 }
 
 float RasterizerStorageRD::reflection_probe_get_origin_max_distance(RID p_probe) const {
-
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, 0);
 
@@ -3784,7 +3604,6 @@ float RasterizerStorageRD::reflection_probe_get_origin_max_distance(RID p_probe)
 }
 
 int RasterizerStorageRD::reflection_probe_get_resolution(RID p_probe) const {
-
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, 0);
 
@@ -3792,21 +3611,18 @@ int RasterizerStorageRD::reflection_probe_get_resolution(RID p_probe) const {
 }
 
 float RasterizerStorageRD::reflection_probe_get_intensity(RID p_probe) const {
-
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, 0);
 
 	return reflection_probe->intensity;
 }
 bool RasterizerStorageRD::reflection_probe_is_interior(RID p_probe) const {
-
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, false);
 
 	return reflection_probe->interior;
 }
 bool RasterizerStorageRD::reflection_probe_is_box_projection(RID p_probe) const {
-
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, false);
 
@@ -3814,21 +3630,18 @@ bool RasterizerStorageRD::reflection_probe_is_box_projection(RID p_probe) const
 }
 
 Color RasterizerStorageRD::reflection_probe_get_interior_ambient(RID p_probe) const {
-
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, Color());
 
 	return reflection_probe->interior_ambient;
 }
 float RasterizerStorageRD::reflection_probe_get_interior_ambient_energy(RID p_probe) const {
-
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, 0);
 
 	return reflection_probe->interior_ambient_energy;
 }
 float RasterizerStorageRD::reflection_probe_get_interior_ambient_probe_contribution(RID p_probe) const {
-
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, 0);
 
@@ -3893,7 +3706,6 @@ void RasterizerStorageRD::decal_set_cull_mask(RID p_decal, uint32_t p_layers) {
 }
 
 void RasterizerStorageRD::decal_set_distance_fade(RID p_decal, bool p_enabled, float p_begin, float p_length) {
-
 	Decal *decal = decal_owner.getornull(p_decal);
 	ERR_FAIL_COND(!decal);
 	decal->distance_fade = p_enabled;
@@ -3902,7 +3714,6 @@ void RasterizerStorageRD::decal_set_distance_fade(RID p_decal, bool p_enabled, f
 }
 
 void RasterizerStorageRD::decal_set_fade(RID p_decal, float p_above, float p_below) {
-
 	Decal *decal = decal_owner.getornull(p_decal);
 	ERR_FAIL_COND(!decal);
 	decal->upper_fade = p_above;
@@ -3910,7 +3721,6 @@ void RasterizerStorageRD::decal_set_fade(RID p_decal, float p_above, float p_bel
 }
 
 void RasterizerStorageRD::decal_set_normal_fade(RID p_decal, float p_fade) {
-
 	Decal *decal = decal_owner.getornull(p_decal);
 	ERR_FAIL_COND(!decal);
 	decal->normal_fade = p_fade;
@@ -3924,7 +3734,6 @@ AABB RasterizerStorageRD::decal_get_aabb(RID p_decal) const {
 }
 
 RID RasterizerStorageRD::gi_probe_create() {
-
 	return gi_probe_owner.make_rid(GIProbe());
 }
 
@@ -4158,7 +3967,6 @@ float RasterizerStorageRD::gi_probe_get_ao(RID p_gi_probe) const {
 }
 
 void RasterizerStorageRD::gi_probe_set_ao_size(RID p_gi_probe, float p_strength) {
-
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND(!gi_probe);
 
@@ -4196,7 +4004,6 @@ float RasterizerStorageRD::gi_probe_get_normal_bias(RID p_gi_probe) const {
 }
 
 void RasterizerStorageRD::gi_probe_set_anisotropy_strength(RID p_gi_probe, float p_strength) {
-
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND(!gi_probe);
 
@@ -4249,13 +4056,11 @@ uint32_t RasterizerStorageRD::gi_probe_get_data_version(RID p_gi_probe) {
 }
 
 RID RasterizerStorageRD::gi_probe_get_octree_buffer(RID p_gi_probe) const {
-
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, RID());
 	return gi_probe->octree_buffer;
 }
 RID RasterizerStorageRD::gi_probe_get_data_buffer(RID p_gi_probe) const {
-
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, RID());
 	return gi_probe->data_buffer;
@@ -4274,7 +4079,6 @@ RID RasterizerStorageRD::lightmap_create() {
 }
 
 void RasterizerStorageRD::lightmap_set_textures(RID p_lightmap, RID p_light, bool p_uses_spherical_haromics) {
-
 	Lightmap *lm = lightmap_owner.getornull(p_lightmap);
 	ERR_FAIL_COND(!lm);
 
@@ -4294,7 +4098,6 @@ void RasterizerStorageRD::lightmap_set_textures(RID p_lightmap, RID p_light, boo
 
 	RID default_2d_array = default_rd_textures[DEFAULT_RD_TEXTURE_2D_ARRAY_WHITE];
 	if (!t) {
-
 		if (using_lightmap_array) {
 			if (lm->array_index >= 0) {
 				lightmap_textures.write[lm->array_index] = default_2d_array;
@@ -4330,14 +4133,12 @@ void RasterizerStorageRD::lightmap_set_probe_bounds(RID p_lightmap, const AABB &
 }
 
 void RasterizerStorageRD::lightmap_set_probe_interior(RID p_lightmap, bool p_interior) {
-
 	Lightmap *lm = lightmap_owner.getornull(p_lightmap);
 	ERR_FAIL_COND(!lm);
 	lm->interior = p_interior;
 }
 
 void RasterizerStorageRD::lightmap_set_probe_capture_data(RID p_lightmap, const PackedVector3Array &p_points, const PackedColorArray &p_point_sh, const PackedInt32Array &p_tetrahedra, const PackedInt32Array &p_bsp_tree) {
-
 	Lightmap *lm = lightmap_owner.getornull(p_lightmap);
 	ERR_FAIL_COND(!lm);
 
@@ -4354,7 +4155,6 @@ void RasterizerStorageRD::lightmap_set_probe_capture_data(RID p_lightmap, const
 }
 
 PackedVector3Array RasterizerStorageRD::lightmap_get_probe_capture_points(RID p_lightmap) const {
-
 	Lightmap *lm = lightmap_owner.getornull(p_lightmap);
 	ERR_FAIL_COND_V(!lm, PackedVector3Array());
 
@@ -4397,7 +4197,6 @@ void RasterizerStorageRD::lightmap_tap_sh_light(RID p_lightmap, const Vector3 &p
 	const Lightmap::BSP *bsp = (const Lightmap::BSP *)lm->bsp_tree.ptr();
 	int32_t node = 0;
 	while (node >= 0) {
-
 		if (Plane(bsp[node].plane[0], bsp[node].plane[1], bsp[node].plane[2], bsp[node].plane[3]).is_point_over(p_point)) {
 #ifdef DEBUG_ENABLED
 			ERR_FAIL_COND(bsp[node].over >= 0 && bsp[node].over < node);
@@ -4445,7 +4244,6 @@ AABB RasterizerStorageRD::lightmap_get_aabb(RID p_lightmap) const {
 /* RENDER TARGET API */
 
 void RasterizerStorageRD::_clear_render_target(RenderTarget *rt) {
-
 	//free in reverse dependency order
 	if (rt->framebuffer.is_valid()) {
 		RD::get_singleton()->free(rt->framebuffer);
@@ -4474,7 +4272,6 @@ void RasterizerStorageRD::_clear_render_target(RenderTarget *rt) {
 }
 
 void RasterizerStorageRD::_update_render_target(RenderTarget *rt) {
-
 	if (rt->texture.is_null()) {
 		//create a placeholder until updated
 		rt->texture = texture_2d_placeholder_create();
@@ -4579,7 +4376,6 @@ void RasterizerStorageRD::_create_render_target_backbuffer(RenderTarget *rt) {
 
 	//create mipmaps
 	for (uint32_t i = 1; i < mipmaps_required; i++) {
-
 		RenderTarget::BackbufferMipmap mm;
 		{
 			mm.mipmap = RD::get_singleton()->texture_create_shared_from_slice(RD::TextureView(), rt->backbuffer, 0, i);
@@ -4643,14 +4439,12 @@ void RasterizerStorageRD::render_target_set_flag(RID p_render_target, RenderTarg
 }
 
 bool RasterizerStorageRD::render_target_was_used(RID p_render_target) {
-
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND_V(!rt, false);
 	return rt->was_used;
 }
 
 void RasterizerStorageRD::render_target_set_as_unused(RID p_render_target) {
-
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND(!rt);
 	rt->was_used = false;
@@ -4689,21 +4483,18 @@ bool RasterizerStorageRD::render_target_is_clear_requested(RID p_render_target)
 }
 
 Color RasterizerStorageRD::render_target_get_clear_request_color(RID p_render_target) {
-
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND_V(!rt, Color());
 	return rt->clear_color;
 }
 
 void RasterizerStorageRD::render_target_disable_clear_request(RID p_render_target) {
-
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND(!rt);
 	rt->clear_requested = false;
 }
 
 void RasterizerStorageRD::render_target_do_clear_request(RID p_render_target) {
-
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND(!rt);
 	if (!rt->clear_requested) {
@@ -4778,7 +4569,6 @@ void RasterizerStorageRD::base_update_dependency(RID p_base, RasterizerScene::In
 		Mesh *mesh = mesh_owner.getornull(p_base);
 		p_instance->update_dependency(&mesh->instance_dependency);
 	} else if (multimesh_owner.owns(p_base)) {
-
 		MultiMesh *multimesh = multimesh_owner.getornull(p_base);
 		p_instance->update_dependency(&multimesh->instance_dependency);
 		if (multimesh->mesh.is_valid()) {
@@ -4803,7 +4593,6 @@ void RasterizerStorageRD::base_update_dependency(RID p_base, RasterizerScene::In
 }
 
 void RasterizerStorageRD::skeleton_update_dependency(RID p_skeleton, RasterizerScene::InstanceBase *p_instance) {
-
 	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
 	ERR_FAIL_COND(!skeleton);
 
@@ -4811,7 +4600,6 @@ void RasterizerStorageRD::skeleton_update_dependency(RID p_skeleton, RasterizerS
 }
 
 RS::InstanceType RasterizerStorageRD::get_base_type(RID p_rid) const {
-
 	if (mesh_owner.owns(p_rid)) {
 		return RS::INSTANCE_MESH;
 	}
@@ -4926,7 +4714,6 @@ void RasterizerStorageRD::_update_decal_atlas() {
 		int atlas_height = 0;
 
 		while (true) {
-
 			Vector<int> v_offsetsv;
 			v_offsetsv.resize(base_size);
 
@@ -4991,7 +4778,6 @@ void RasterizerStorageRD::_update_decal_atlas() {
 			t->uv_rect.size /= Size2(decal_atlas.size);
 		}
 	} else {
-
 		//use border as size, so it at least has enough mipmaps
 		decal_atlas.size.width = border;
 		decal_atlas.size.height = border;
@@ -5043,7 +4829,6 @@ void RasterizerStorageRD::_update_decal_atlas() {
 		Color clear_color(0, 0, 0, 0);
 
 		if (decal_atlas.textures.size()) {
-
 			if (i == 0) {
 				Vector<Color> cc;
 				cc.push_back(clear_color);
@@ -5061,7 +4846,6 @@ void RasterizerStorageRD::_update_decal_atlas() {
 
 				prev_texture = mm.texture;
 			} else {
-
 				effects.copy_to_fb_rect(prev_texture, mm.fb, Rect2i(Point2i(), mm.size));
 				prev_texture = mm.texture;
 			}
@@ -5072,7 +4856,6 @@ void RasterizerStorageRD::_update_decal_atlas() {
 }
 
 int32_t RasterizerStorageRD::_global_variable_allocate(uint32_t p_elements) {
-
 	int32_t idx = 0;
 	while (idx + p_elements <= global_variables.buffer_size) {
 		if (global_variables.buffer_usage[idx].elements == 0) {
@@ -5099,10 +4882,8 @@ int32_t RasterizerStorageRD::_global_variable_allocate(uint32_t p_elements) {
 }
 
 void RasterizerStorageRD::_global_variable_store_in_buffer(int32_t p_index, RS::GlobalVariableType p_type, const Variant &p_value) {
-
 	switch (p_type) {
 		case RS::GLOBAL_VAR_TYPE_BOOL: {
-
 			GlobalVariables::Value &bv = global_variables.buffer_values[p_index];
 			bool b = p_value;
 			bv.x = b ? 1.0 : 0.0;
@@ -5281,7 +5062,6 @@ void RasterizerStorageRD::_global_variable_store_in_buffer(int32_t p_index, RS::
 
 		} break;
 		case RS::GLOBAL_VAR_TYPE_MAT3: {
-
 			GlobalVariables::Value *bv = &global_variables.buffer_values[p_index];
 			Basis v = p_value;
 			bv[0].x = v.elements[0][0];
@@ -5301,7 +5081,6 @@ void RasterizerStorageRD::_global_variable_store_in_buffer(int32_t p_index, RS::
 
 		} break;
 		case RS::GLOBAL_VAR_TYPE_MAT4: {
-
 			GlobalVariables::Value *bv = &global_variables.buffer_values[p_index];
 
 			Vector<float> m2 = p_value;
@@ -5331,7 +5110,6 @@ void RasterizerStorageRD::_global_variable_store_in_buffer(int32_t p_index, RS::
 
 		} break;
 		case RS::GLOBAL_VAR_TYPE_TRANSFORM_2D: {
-
 			GlobalVariables::Value *bv = &global_variables.buffer_values[p_index];
 			Transform2D v = p_value;
 			bv[0].x = v.elements[0][0];
@@ -5351,7 +5129,6 @@ void RasterizerStorageRD::_global_variable_store_in_buffer(int32_t p_index, RS::
 
 		} break;
 		case RS::GLOBAL_VAR_TYPE_TRANSFORM: {
-
 			GlobalVariables::Value *bv = &global_variables.buffer_values[p_index];
 			Transform v = p_value;
 			bv[0].x = v.basis.elements[0][0];
@@ -5382,7 +5159,6 @@ void RasterizerStorageRD::_global_variable_store_in_buffer(int32_t p_index, RS::
 }
 
 void RasterizerStorageRD::_global_variable_mark_buffer_dirty(int32_t p_index, int32_t p_elements) {
-
 	int32_t prev_chunk = -1;
 
 	for (int32_t i = 0; i < p_elements; i++) {
@@ -5399,7 +5175,6 @@ void RasterizerStorageRD::_global_variable_mark_buffer_dirty(int32_t p_index, in
 }
 
 void RasterizerStorageRD::global_variable_add(const StringName &p_name, RS::GlobalVariableType p_type, const Variant &p_value) {
-
 	ERR_FAIL_COND(global_variables.variables.has(p_name));
 	GlobalVariables::Variable gv;
 	gv.type = p_type;
@@ -5410,7 +5185,6 @@ void RasterizerStorageRD::global_variable_add(const StringName &p_name, RS::Glob
 		//is texture
 		global_variables.must_update_texture_materials = true; //normally ther are no
 	} else {
-
 		gv.buffer_elements = 1;
 		if (p_type == RS::GLOBAL_VAR_TYPE_COLOR || p_type == RS::GLOBAL_VAR_TYPE_MAT2) {
 			//color needs to elements to store srgb and linear
@@ -5454,7 +5228,6 @@ void RasterizerStorageRD::global_variable_remove(const StringName &p_name) {
 	global_variables.variables.erase(p_name);
 }
 Vector<StringName> RasterizerStorageRD::global_variable_get_list() const {
-
 	if (!Engine::get_singleton()->is_editor_hint()) {
 		ERR_FAIL_V_MSG(Vector<StringName>(), "This function should never be used outside the editor, it can severely damage performance.");
 	}
@@ -5516,7 +5289,6 @@ void RasterizerStorageRD::global_variable_set_override(const StringName &p_name,
 }
 
 Variant RasterizerStorageRD::global_variable_get(const StringName &p_name) const {
-
 	if (!Engine::get_singleton()->is_editor_hint()) {
 		ERR_FAIL_V_MSG(Variant(), "This function should never be used outside the editor, it can severely damage performance.");
 	}
@@ -5529,7 +5301,6 @@ Variant RasterizerStorageRD::global_variable_get(const StringName &p_name) const
 }
 
 RS::GlobalVariableType RasterizerStorageRD::global_variable_get_type_internal(const StringName &p_name) const {
-
 	if (!global_variables.variables.has(p_name)) {
 		return RS::GLOBAL_VAR_TYPE_MAX;
 	}
@@ -5546,7 +5317,6 @@ RS::GlobalVariableType RasterizerStorageRD::global_variable_get_type(const Strin
 }
 
 void RasterizerStorageRD::global_variables_load_settings(bool p_load_textures) {
-
 	List<PropertyInfo> settings;
 	ProjectSettings::get_singleton()->get_property_list(&settings);
 
@@ -5653,7 +5423,6 @@ void RasterizerStorageRD::global_variables_instance_free(RID p_instance) {
 	global_variables.instance_buffer_pos.erase(p_instance);
 }
 void RasterizerStorageRD::global_variables_instance_update(RID p_instance, int p_index, const Variant &p_value) {
-
 	if (!global_variables.instance_buffer_pos.has(p_instance)) {
 		return; //just not allocated, ignore
 	}
@@ -5697,7 +5466,6 @@ void RasterizerStorageRD::global_variables_instance_update(RID p_instance, int p
 }
 
 void RasterizerStorageRD::_update_global_variables() {
-
 	if (global_variables.buffer_dirty_region_count > 0) {
 		uint32_t total_regions = global_variables.buffer_size / GlobalVariables::BUFFER_DIRTY_REGION_SIZE;
 		if (total_regions / global_variables.buffer_dirty_region_count <= 4) {
@@ -5709,7 +5477,6 @@ void RasterizerStorageRD::_update_global_variables() {
 
 			for (uint32_t i = 0; i < total_regions; i++) {
 				if (global_variables.buffer_dirty_regions[i]) {
-
 					RD::get_singleton()->buffer_update(global_variables.buffer, i * region_byte_size, region_byte_size, global_variables.buffer_values);
 
 					global_variables.buffer_dirty_regions[i] = false;
@@ -5757,7 +5524,6 @@ void RasterizerStorageRD::update_dirty_resources() {
 }
 
 bool RasterizerStorageRD::has_os_feature(const String &p_feature) const {
-
 	if (p_feature == "rgtc" && RD::get_singleton()->texture_is_format_supported_for_usage(RD::DATA_FORMAT_BC5_UNORM_BLOCK, RD::TEXTURE_USAGE_SAMPLING_BIT)) {
 		return true;
 	}
@@ -5781,7 +5547,6 @@ bool RasterizerStorageRD::has_os_feature(const String &p_feature) const {
 	return false;
 }
 bool RasterizerStorageRD::free(RID p_rid) {
-
 	if (texture_owner.owns(p_rid)) {
 		Texture *t = texture_owner.getornull(p_rid);
 
@@ -5878,7 +5643,6 @@ bool RasterizerStorageRD::free(RID p_rid) {
 		lightmap_owner.free(p_rid);
 
 	} else if (light_owner.owns(p_rid)) {
-
 		light_set_projector(p_rid, RID()); //clear projector
 		// delete the texture
 		Light *light = light_owner.getornull(p_rid);
@@ -5936,7 +5700,6 @@ String RasterizerStorageRD::get_captured_timestamp_name(uint32_t p_index) const
 RasterizerStorageRD *RasterizerStorageRD::base_singleton = nullptr;
 
 RasterizerStorageRD::RasterizerStorageRD() {
-
 	base_singleton = this;
 
 	for (int i = 0; i < SHADER_TYPE_MAX; i++) {
@@ -6151,7 +5914,6 @@ RasterizerStorageRD::RasterizerStorageRD() {
 					sampler_state.max_lod = 0;
 				} break;
 				case RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR: {
-
 					sampler_state.mag_filter = RD::SAMPLER_FILTER_LINEAR;
 					sampler_state.min_filter = RD::SAMPLER_FILTER_LINEAR;
 					sampler_state.max_lod = 0;
@@ -6187,7 +5949,6 @@ RasterizerStorageRD::RasterizerStorageRD() {
 			}
 			switch (j) {
 				case RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED: {
-
 					sampler_state.repeat_u = RD::SAMPLER_REPEAT_MODE_CLAMP_TO_EDGE;
 					sampler_state.repeat_v = RD::SAMPLER_REPEAT_MODE_CLAMP_TO_EDGE;
 
@@ -6210,10 +5971,8 @@ RasterizerStorageRD::RasterizerStorageRD() {
 
 	//default rd buffers
 	{
-
 		Vector<uint8_t> buffer;
 		{
-
 			buffer.resize(sizeof(float) * 3);
 			{
 				uint8_t *w = buffer.ptrw();
@@ -6323,7 +6082,6 @@ RasterizerStorageRD::RasterizerStorageRD() {
 
 	using_lightmap_array = true; // high end
 	if (using_lightmap_array) {
-
 		uint32_t textures_per_stage = RD::get_singleton()->limit_get(RD::LIMIT_MAX_TEXTURES_PER_SHADER_STAGE);
 
 		if (textures_per_stage <= 256) {
@@ -6341,7 +6099,6 @@ RasterizerStorageRD::RasterizerStorageRD() {
 }
 
 RasterizerStorageRD::~RasterizerStorageRD() {
-
 	memdelete_arr(global_variables.buffer_values);
 	memdelete_arr(global_variables.buffer_usage);
 	memdelete_arr(global_variables.buffer_dirty_regions);