Apply correct formatting to comments in the Vulkan driver

4 files changed, 471 insertions, 471 deletions

diff --git a/drivers/vulkan/rendering_device_vulkan.cpp b/drivers/vulkan/rendering_device_vulkan.cpp
index 5cbddb0eb9..bcb6092d87 100644
--- a/drivers/vulkan/rendering_device_vulkan.cpp
+++ b/drivers/vulkan/rendering_device_vulkan.cpp
@@ -46,7 +46,7 @@
 
 static const uint32_t SMALL_ALLOCATION_MAX_SIZE = 4096;
 
-// Get the Vulkan object information and possible stage access types (bitwise OR'd with incoming values)
+// Get the Vulkan object information and possible stage access types (bitwise OR'd with incoming values).
 RenderingDeviceVulkan::Buffer *RenderingDeviceVulkan::_get_buffer_from_owner(RID p_buffer, VkPipelineStageFlags &r_stage_mask, VkAccessFlags &r_access_mask, uint32_t p_post_barrier) {
 	Buffer *buffer = nullptr;
 	if (vertex_buffer_owner.owns(p_buffer)) {
@@ -108,8 +108,8 @@ RenderingDeviceVulkan::Buffer *RenderingDeviceVulkan::_get_buffer_from_owner(RID
 }
 
 static void update_external_dependency_for_store(VkSubpassDependency2KHR &dependency, bool is_sampled, bool is_storage, bool is_depth) {
-	// Transitioning from write to read, protect the shaders that may use this next
-	// Allow for copies/image layout transitions
+	// Transitioning from write to read, protect the shaders that may use this next.
+	// Allow for copies/image layout transitions.
 	dependency.dstStageMask |= VK_PIPELINE_STAGE_TRANSFER_BIT;
 	dependency.dstAccessMask |= VK_ACCESS_TRANSFER_READ_BIT;
 
@@ -125,7 +125,7 @@ static void update_external_dependency_for_store(VkSubpassDependency2KHR &depend
 	}
 
 	if (is_depth) {
-		// Depth resources have additional stages that may be interested in them
+		// Depth resources have additional stages that may be interested in them.
 		dependency.dstStageMask |= VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
 		dependency.dstAccessMask |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
 	}
@@ -146,7 +146,7 @@ void RenderingDeviceVulkan::_add_dependency(RID p_id, RID p_depends_on) {
 }
 
 void RenderingDeviceVulkan::_free_dependencies(RID p_id) {
-	//direct dependencies must be freed
+	// Direct dependencies must be freed.
 
 	HashMap<RID, HashSet<RID>>::Iterator E = dependency_map.find(p_id);
 	if (E) {
@@ -156,7 +156,7 @@ void RenderingDeviceVulkan::_free_dependencies(RID p_id) {
 		dependency_map.remove(E);
 	}
 
-	//reverse dependencies must be unreferenced
+	// Reverse dependencies must be unreferenced.
 	E = reverse_dependency_map.find(p_id);
 
 	if (E) {
@@ -860,7 +860,7 @@ uint32_t RenderingDeviceVulkan::get_image_format_pixel_size(DataFormat p_format)
 		case DATA_FORMAT_D24_UNORM_S8_UINT:
 			return 4;
 		case DATA_FORMAT_D32_SFLOAT_S8_UINT:
-			return 5; //?
+			return 5; // ?
 		case DATA_FORMAT_BC1_RGB_UNORM_BLOCK:
 		case DATA_FORMAT_BC1_RGB_SRGB_BLOCK:
 		case DATA_FORMAT_BC1_RGBA_UNORM_BLOCK:
@@ -995,7 +995,7 @@ void RenderingDeviceVulkan::get_compressed_image_format_block_dimensions(DataFor
 		case DATA_FORMAT_EAC_R11_SNORM_BLOCK:
 		case DATA_FORMAT_EAC_R11G11_UNORM_BLOCK:
 		case DATA_FORMAT_EAC_R11G11_SNORM_BLOCK:
-		case DATA_FORMAT_ASTC_4x4_UNORM_BLOCK: //again, not sure about astc
+		case DATA_FORMAT_ASTC_4x4_UNORM_BLOCK: // Again, not sure about astc.
 		case DATA_FORMAT_ASTC_4x4_SRGB_BLOCK:
 		case DATA_FORMAT_ASTC_5x4_UNORM_BLOCK:
 		case DATA_FORMAT_ASTC_5x4_SRGB_BLOCK:
@@ -1073,7 +1073,7 @@ uint32_t RenderingDeviceVulkan::get_compressed_image_format_block_byte_size(Data
 		case DATA_FORMAT_EAC_R11G11_UNORM_BLOCK:
 		case DATA_FORMAT_EAC_R11G11_SNORM_BLOCK:
 			return 16;
-		case DATA_FORMAT_ASTC_4x4_UNORM_BLOCK: //again, not sure about astc
+		case DATA_FORMAT_ASTC_4x4_UNORM_BLOCK: // Again, not sure about astc.
 		case DATA_FORMAT_ASTC_4x4_SRGB_BLOCK:
 		case DATA_FORMAT_ASTC_5x4_UNORM_BLOCK:
 		case DATA_FORMAT_ASTC_5x4_SRGB_BLOCK:
@@ -1101,7 +1101,7 @@ uint32_t RenderingDeviceVulkan::get_compressed_image_format_block_byte_size(Data
 		case DATA_FORMAT_ASTC_12x10_SRGB_BLOCK:
 		case DATA_FORMAT_ASTC_12x12_UNORM_BLOCK:
 		case DATA_FORMAT_ASTC_12x12_SRGB_BLOCK:
-			return 8; //wrong
+			return 8; // Wrong.
 		default: {
 		}
 	}
@@ -1110,7 +1110,7 @@ uint32_t RenderingDeviceVulkan::get_compressed_image_format_block_byte_size(Data
 
 uint32_t RenderingDeviceVulkan::get_compressed_image_format_pixel_rshift(DataFormat p_format) {
 	switch (p_format) {
-		case DATA_FORMAT_BC1_RGB_UNORM_BLOCK: //these formats are half byte size, so rshift is 1
+		case DATA_FORMAT_BC1_RGB_UNORM_BLOCK: // These formats are half byte size, so rshift is 1.
 		case DATA_FORMAT_BC1_RGB_SRGB_BLOCK:
 		case DATA_FORMAT_BC1_RGBA_UNORM_BLOCK:
 		case DATA_FORMAT_BC1_RGBA_SRGB_BLOCK:
@@ -1184,7 +1184,7 @@ uint32_t RenderingDeviceVulkan::get_image_format_required_size(DataFormat p_form
 }
 
 uint32_t RenderingDeviceVulkan::get_image_required_mipmaps(uint32_t p_width, uint32_t p_height, uint32_t p_depth) {
-	//formats and block size don't really matter here since they can all go down to 1px (even if block is larger)
+	// Formats and block size don't really matter here since they can all go down to 1px (even if block is larger).
 	uint32_t w = p_width;
 	uint32_t h = p_height;
 	uint32_t d = p_depth;
@@ -1402,16 +1402,16 @@ Error RenderingDeviceVulkan::_insert_staging_block() {
 }
 
 Error RenderingDeviceVulkan::_staging_buffer_allocate(uint32_t p_amount, uint32_t p_required_align, uint32_t &r_alloc_offset, uint32_t &r_alloc_size, bool p_can_segment) {
-	//determine a block to use
+	// Determine a block to use.
 
 	r_alloc_size = p_amount;
 
 	while (true) {
 		r_alloc_offset = 0;
 
-		//see if we can use current block
+		// See if we can use current block.
 		if (staging_buffer_blocks[staging_buffer_current].frame_used == frames_drawn) {
-			//we used this block this frame, let's see if there is still room
+			// We used this block this frame, let's see if there is still room.
 
 			uint32_t write_from = staging_buffer_blocks[staging_buffer_current].fill_amount;
 
@@ -1425,107 +1425,107 @@ Error RenderingDeviceVulkan::_staging_buffer_allocate(uint32_t p_amount, uint32_
 			int32_t available_bytes = int32_t(staging_buffer_block_size) - int32_t(write_from);
 
 			if ((int32_t)p_amount < available_bytes) {
-				//all is good, we should be ok, all will fit
+				// All is good, we should be ok, all will fit.
 				r_alloc_offset = write_from;
 			} else if (p_can_segment && available_bytes >= (int32_t)p_required_align) {
-				//ok all won't fit but at least we can fit a chunkie
-				//all is good, update what needs to be written to
+				// Ok all won't fit but at least we can fit a chunkie.
+				// All is good, update what needs to be written to.
 				r_alloc_offset = write_from;
 				r_alloc_size = available_bytes - (available_bytes % p_required_align);
 
 			} else {
-				//can't fit it into this buffer.
-				//will need to try next buffer
+				// Can't fit it into this buffer.
+				// Will need to try next buffer.
 
 				staging_buffer_current = (staging_buffer_current + 1) % staging_buffer_blocks.size();
 
-				// before doing anything, though, let's check that we didn't manage to fill all blocks
-				// possible in a single frame
+				// Before doing anything, though, let's check that we didn't manage to fill all blocks.
+				// Possible in a single frame.
 				if (staging_buffer_blocks[staging_buffer_current].frame_used == frames_drawn) {
-					//guess we did.. ok, let's see if we can insert a new block..
+					// Guess we did.. ok, let's see if we can insert a new block.
 					if ((uint64_t)staging_buffer_blocks.size() * staging_buffer_block_size < staging_buffer_max_size) {
-						//we can, so we are safe
+						// We can, so we are safe.
 						Error err = _insert_staging_block();
 						if (err) {
 							return err;
 						}
-						//claim for this frame
+						// Claim for this frame.
 						staging_buffer_blocks.write[staging_buffer_current].frame_used = frames_drawn;
 					} else {
 						// Ok, worst case scenario, all the staging buffers belong to this frame
 						// and this frame is not even done.
-						// If this is the main thread, it means the user is likely loading a lot of resources at once,
-						// otherwise, the thread should just be blocked until the next frame (currently unimplemented)
+						// If this is the main thread, it means the user is likely loading a lot of resources at once,.
+						// Otherwise, the thread should just be blocked until the next frame (currently unimplemented).
 
-						if (false) { //separate thread from render
+						if (false) { // Separate thread from render.
 
 							//block_until_next_frame()
 							continue;
 						} else {
-							//flush EVERYTHING including setup commands. IF not immediate, also need to flush the draw commands
+							// Flush EVERYTHING including setup commands. IF not immediate, also need to flush the draw commands.
 							_flush(true);
 
-							//clear the whole staging buffer
+							// Clear the whole staging buffer.
 							for (int i = 0; i < staging_buffer_blocks.size(); i++) {
 								staging_buffer_blocks.write[i].frame_used = 0;
 								staging_buffer_blocks.write[i].fill_amount = 0;
 							}
-							//claim current
+							// Claim current.
 							staging_buffer_blocks.write[staging_buffer_current].frame_used = frames_drawn;
 						}
 					}
 
 				} else {
-					//not from current frame, so continue and try again
+					// Not from current frame, so continue and try again.
 					continue;
 				}
 			}
 
 		} else if (staging_buffer_blocks[staging_buffer_current].frame_used <= frames_drawn - frame_count) {
-			//this is an old block, which was already processed, let's reuse
+			// This is an old block, which was already processed, let's reuse.
 			staging_buffer_blocks.write[staging_buffer_current].frame_used = frames_drawn;
 			staging_buffer_blocks.write[staging_buffer_current].fill_amount = 0;
 		} else {
-			//this block may still be in use, let's not touch it unless we have to, so.. can we create a new one?
+			// This block may still be in use, let's not touch it unless we have to, so.. can we create a new one?
 			if ((uint64_t)staging_buffer_blocks.size() * staging_buffer_block_size < staging_buffer_max_size) {
-				//we are still allowed to create a new block, so let's do that and insert it for current pos
+				// We are still allowed to create a new block, so let's do that and insert it for current pos.
 				Error err = _insert_staging_block();
 				if (err) {
 					return err;
 				}
-				//claim for this frame
+				// Claim for this frame.
 				staging_buffer_blocks.write[staging_buffer_current].frame_used = frames_drawn;
 			} else {
-				// oops, we are out of room and we can't create more.
-				// let's flush older frames.
+				// Oops, we are out of room and we can't create more.
+				// Let's flush older frames.
 				// The logic here is that if a game is loading a lot of data from the main thread, it will need to be stalled anyway.
 				// If loading from a separate thread, we can block that thread until next frame when more room is made (not currently implemented, though).
 
 				if (false) {
-					//separate thread from render
+					// Separate thread from render.
 					//block_until_next_frame()
-					continue; //and try again
+					continue; // And try again.
 				} else {
 					_flush(false);
 
 					for (int i = 0; i < staging_buffer_blocks.size(); i++) {
-						//clear all blocks but the ones from this frame
+						// Clear all blocks but the ones from this frame.
 						int block_idx = (i + staging_buffer_current) % staging_buffer_blocks.size();
 						if (staging_buffer_blocks[block_idx].frame_used == frames_drawn) {
-							break; //ok, we reached something from this frame, abort
+							break; // Ok, we reached something from this frame, abort.
 						}
 
 						staging_buffer_blocks.write[block_idx].frame_used = 0;
 						staging_buffer_blocks.write[block_idx].fill_amount = 0;
 					}
 
-					//claim for current frame
+					// Claim for current frame.
 					staging_buffer_blocks.write[staging_buffer_current].frame_used = frames_drawn;
 				}
 			}
 		}
 
-		//all was good, break
+		// All was good, break.
 		break;
 	}
 
@@ -1535,7 +1535,7 @@ Error RenderingDeviceVulkan::_staging_buffer_allocate(uint32_t p_amount, uint32_
 }
 
 Error RenderingDeviceVulkan::_buffer_update(Buffer *p_buffer, size_t p_offset, const uint8_t *p_data, size_t p_data_size, bool p_use_draw_command_buffer, uint32_t p_required_align) {
-	//submitting may get chunked for various reasons, so convert this to a task
+	// Submitting may get chunked for various reasons, so convert this to a task.
 	size_t to_submit = p_data_size;
 	size_t submit_from = 0;
 
@@ -1548,7 +1548,7 @@ Error RenderingDeviceVulkan::_buffer_update(Buffer *p_buffer, size_t p_offset, c
 			return err;
 		}
 
-		//map staging buffer (It's CPU and coherent)
+		// Map staging buffer (It's CPU and coherent).
 
 		void *data_ptr = nullptr;
 		{
@@ -1556,12 +1556,12 @@ Error RenderingDeviceVulkan::_buffer_update(Buffer *p_buffer, size_t p_offset, c
 			ERR_FAIL_COND_V_MSG(vkerr, ERR_CANT_CREATE, "vmaMapMemory failed with error " + itos(vkerr) + ".");
 		}
 
-		//copy to staging buffer
+		// Copy to staging buffer.
 		memcpy(((uint8_t *)data_ptr) + block_write_offset, p_data + submit_from, block_write_amount);
 
-		//unmap
+		// Unmap.
 		vmaUnmapMemory(allocator, staging_buffer_blocks[staging_buffer_current].allocation);
-		//insert a command to copy this
+		// Insert a command to copy this.
 
 		VkBufferCopy region;
 		region.srcOffset = block_write_offset;
@@ -1587,13 +1587,13 @@ void RenderingDeviceVulkan::_memory_barrier(VkPipelineStageFlags p_src_stage_mas
 	mem_barrier.dstAccessMask = p_dst_sccess;
 
 	if (p_src_stage_mask == 0 || p_dst_stage_mask == 0) {
-		return; //no barrier, since this is invalid
+		return; // No barrier, since this is invalid.
 	}
 	vkCmdPipelineBarrier(p_sync_with_draw ? frames[frame].draw_command_buffer : frames[frame].setup_command_buffer, p_src_stage_mask, p_dst_stage_mask, 0, 1, &mem_barrier, 0, nullptr, 0, nullptr);
 }
 
 void RenderingDeviceVulkan::_full_barrier(bool p_sync_with_draw) {
-	//used for debug
+	// Used for debug.
 	_memory_barrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
 			VK_ACCESS_INDIRECT_COMMAND_READ_BIT |
 					VK_ACCESS_INDEX_READ_BIT |
@@ -1662,8 +1662,8 @@ RID RenderingDeviceVulkan::texture_create(const TextureFormat &p_format, const T
 #ifndef ANDROID_ENABLED
 
 	// vkCreateImage fails with format list on Android (VK_ERROR_OUT_OF_HOST_MEMORY)
-	VkImageFormatListCreateInfoKHR format_list_create_info; //keep out of the if, needed for creation
-	Vector<VkFormat> allowed_formats; //keep out of the if, needed for creation
+	VkImageFormatListCreateInfoKHR format_list_create_info; // Keep out of the if, needed for creation.
+	Vector<VkFormat> allowed_formats; // Keep out of the if, needed for creation.
 #endif
 	if (p_format.shareable_formats.size()) {
 		image_create_info.flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
@@ -1736,7 +1736,7 @@ RID RenderingDeviceVulkan::texture_create(const TextureFormat &p_format, const T
 	image_create_info.samples = rasterization_sample_count[p_format.samples];
 	image_create_info.tiling = (p_format.usage_bits & TEXTURE_USAGE_CPU_READ_BIT) ? VK_IMAGE_TILING_LINEAR : VK_IMAGE_TILING_OPTIMAL;
 
-	//usage
+	// Usage.
 	image_create_info.usage = 0;
 
 	if (p_format.usage_bits & TEXTURE_USAGE_SAMPLING_BIT) {
@@ -1800,7 +1800,7 @@ RID RenderingDeviceVulkan::texture_create(const TextureFormat &p_format, const T
 	}
 
 	{
-		//validate that this image is supported for the intended use
+		// Validate that this image is supported for the intended use.
 		VkFormatProperties properties;
 		vkGetPhysicalDeviceFormatProperties(context->get_physical_device(), image_create_info.format, &properties);
 		VkFormatFeatureFlags flags;
@@ -1841,7 +1841,7 @@ RID RenderingDeviceVulkan::texture_create(const TextureFormat &p_format, const T
 		}
 	}
 
-	//some view validation
+	// Some view validation.
 
 	if (p_view.format_override != DATA_FORMAT_MAX) {
 		ERR_FAIL_INDEX_V(p_view.format_override, DATA_FORMAT_MAX, RID());
@@ -1851,7 +1851,7 @@ RID RenderingDeviceVulkan::texture_create(const TextureFormat &p_format, const T
 	ERR_FAIL_INDEX_V(p_view.swizzle_b, TEXTURE_SWIZZLE_MAX, RID());
 	ERR_FAIL_INDEX_V(p_view.swizzle_a, TEXTURE_SWIZZLE_MAX, RID());
 
-	//allocate memory
+	// Allocate memory.
 
 	uint32_t width, height;
 	uint32_t image_size = get_image_format_required_size(p_format.format, p_format.width, p_format.height, p_format.depth, p_format.mipmaps, &width, &height);
@@ -1888,19 +1888,19 @@ RID RenderingDeviceVulkan::texture_create(const TextureFormat &p_format, const T
 	texture.samples = p_format.samples;
 	texture.allowed_shared_formats = p_format.shareable_formats;
 
-	//set base layout based on usage priority
+	// Set base layout based on usage priority.
 
 	if (p_format.usage_bits & TEXTURE_USAGE_SAMPLING_BIT) {
-		//first priority, readable
+		// First priority, readable.
 		texture.layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 
 	} else if (p_format.usage_bits & TEXTURE_USAGE_STORAGE_BIT) {
-		//second priority, storage
+		// Second priority, storage.
 
 		texture.layout = VK_IMAGE_LAYOUT_GENERAL;
 
 	} else if (p_format.usage_bits & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT) {
-		//third priority, color or depth
+		// Third priority, color or depth.
 
 		texture.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 
@@ -1925,7 +1925,7 @@ RID RenderingDeviceVulkan::texture_create(const TextureFormat &p_format, const T
 
 	texture.bound = false;
 
-	//create view
+	// Create view.
 
 	VkImageViewCreateInfo image_view_create_info;
 	image_view_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
@@ -1982,7 +1982,7 @@ RID RenderingDeviceVulkan::texture_create(const TextureFormat &p_format, const T
 		ERR_FAIL_V_MSG(RID(), "vkCreateImageView failed with error " + itos(err) + ".");
 	}
 
-	//barrier to set layout
+	// Barrier to set layout.
 	{
 		VkImageMemoryBarrier image_memory_barrier;
 		image_memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
@@ -2022,13 +2022,13 @@ RID RenderingDeviceVulkan::texture_create_shared(const TextureView &p_view, RID
 	Texture *src_texture = texture_owner.get_or_null(p_with_texture);
 	ERR_FAIL_COND_V(!src_texture, RID());
 
-	if (src_texture->owner.is_valid()) { //ahh this is a share
+	if (src_texture->owner.is_valid()) { // Ahh this is a share.
 		p_with_texture = src_texture->owner;
 		src_texture = texture_owner.get_or_null(src_texture->owner);
-		ERR_FAIL_COND_V(!src_texture, RID()); //this is a bug
+		ERR_FAIL_COND_V(!src_texture, RID()); // This is a bug.
 	}
 
-	//create view
+	// Create view.
 
 	Texture texture = *src_texture;
 
@@ -2089,7 +2089,7 @@ RID RenderingDeviceVulkan::texture_create_shared(const TextureView &p_view, RID
 	usage_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO;
 	usage_info.pNext = nullptr;
 	if (p_view.format_override != DATA_FORMAT_MAX) {
-		//need to validate usage with vulkan
+		// Need to validate usage with vulkan.
 
 		usage_info.usage = 0;
 
@@ -2151,9 +2151,9 @@ RID RenderingDeviceVulkan::texture_create_from_extension(TextureType p_type, Dat
 
 	Texture texture;
 	texture.image = image;
-	// if we leave texture.allocation as a nullptr, would that be enough to detect we don't "own" the image?
-	// also leave texture.allocation_info alone
-	// we'll set texture.view later on
+	// If we leave texture.allocation as a nullptr, would that be enough to detect we don't "own" the image?
+	// Also leave texture.allocation_info alone.
+	// We'll set texture.view later on.
 	texture.type = p_type;
 	texture.format = p_format;
 	texture.samples = p_samples;
@@ -2161,14 +2161,14 @@ RID RenderingDeviceVulkan::texture_create_from_extension(TextureType p_type, Dat
 	texture.height = p_height;
 	texture.depth = p_depth;
 	texture.layers = p_layers;
-	texture.mipmaps = 0; // maybe make this settable too?
+	texture.mipmaps = 0; // Maybe make this settable too?
 	texture.usage_flags = p_flags;
 	texture.base_mipmap = 0;
 	texture.base_layer = 0;
 	texture.allowed_shared_formats.push_back(RD::DATA_FORMAT_R8G8B8A8_UNORM);
 	texture.allowed_shared_formats.push_back(RD::DATA_FORMAT_R8G8B8A8_SRGB);
 
-	// Do we need to do something with texture.layout ?
+	// Do we need to do something with texture.layout?
 
 	if (texture.usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {
 		texture.read_aspect_mask = VK_IMAGE_ASPECT_DEPTH_BIT;
@@ -2182,7 +2182,7 @@ RID RenderingDeviceVulkan::texture_create_from_extension(TextureType p_type, Dat
 		texture.barrier_aspect_mask = VK_IMAGE_ASPECT_COLOR_BIT;
 	}
 
-	// Create a view for us to use
+	// Create a view for us to use.
 
 	VkImageViewCreateInfo image_view_create_info;
 	image_view_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
@@ -2213,7 +2213,7 @@ RID RenderingDeviceVulkan::texture_create_from_extension(TextureType p_type, Dat
 		VK_COMPONENT_SWIZZLE_A
 	};
 
-	// hardcode for now, maybe make this settable from outside..
+	// Hardcode for now, maybe make this settable from outside.
 	image_view_create_info.components.r = component_swizzles[TEXTURE_SWIZZLE_R];
 	image_view_create_info.components.g = component_swizzles[TEXTURE_SWIZZLE_G];
 	image_view_create_info.components.b = component_swizzles[TEXTURE_SWIZZLE_B];
@@ -2236,7 +2236,7 @@ RID RenderingDeviceVulkan::texture_create_from_extension(TextureType p_type, Dat
 		ERR_FAIL_V_MSG(RID(), "vkCreateImageView failed with error " + itos(err) + ".");
 	}
 
-	//barrier to set layout
+	// Barrier to set layout.
 	{
 		VkImageMemoryBarrier image_memory_barrier;
 		image_memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
@@ -2271,10 +2271,10 @@ RID RenderingDeviceVulkan::texture_create_shared_from_slice(const TextureView &p
 	Texture *src_texture = texture_owner.get_or_null(p_with_texture);
 	ERR_FAIL_COND_V(!src_texture, RID());
 
-	if (src_texture->owner.is_valid()) { //ahh this is a share
+	if (src_texture->owner.is_valid()) { // Ahh this is a share.
 		p_with_texture = src_texture->owner;
 		src_texture = texture_owner.get_or_null(src_texture->owner);
-		ERR_FAIL_COND_V(!src_texture, RID()); //this is a bug
+		ERR_FAIL_COND_V(!src_texture, RID()); // This is a bug.
 	}
 
 	ERR_FAIL_COND_V_MSG(p_slice_type == TEXTURE_SLICE_CUBEMAP && (src_texture->type != TEXTURE_TYPE_CUBE && src_texture->type != TEXTURE_TYPE_CUBE_ARRAY), RID(),
@@ -2286,7 +2286,7 @@ RID RenderingDeviceVulkan::texture_create_shared_from_slice(const TextureView &p
 	ERR_FAIL_COND_V_MSG(p_slice_type == TEXTURE_SLICE_2D_ARRAY && (src_texture->type != TEXTURE_TYPE_2D_ARRAY), RID(),
 			"Can only create an array slice from a 2D array mipmap");
 
-	//create view
+	// Create view.
 
 	ERR_FAIL_UNSIGNED_INDEX_V(p_mipmap, src_texture->mipmaps, RID());
 	ERR_FAIL_COND_V(p_mipmap + p_mipmaps > src_texture->mipmaps, RID());
@@ -2426,7 +2426,7 @@ Error RenderingDeviceVulkan::_texture_update(RID p_texture, uint32_t p_layer, co
 	if (texture->owner != RID()) {
 		p_texture = texture->owner;
 		texture = texture_owner.get_or_null(texture->owner);
-		ERR_FAIL_COND_V(!texture, ERR_BUG); //this is a bug
+		ERR_FAIL_COND_V(!texture, ERR_BUG); // This is a bug.
 	}
 
 	ERR_FAIL_COND_V_MSG(texture->bound, ERR_CANT_ACQUIRE_RESOURCE,
@@ -2448,7 +2448,7 @@ Error RenderingDeviceVulkan::_texture_update(RID p_texture, uint32_t p_layer, co
 	if (required_align == 1) {
 		required_align = get_image_format_pixel_size(texture->format);
 	}
-	if ((required_align % 4) != 0) { //alignment rules are really strange
+	if ((required_align % 4) != 0) { // Alignment rules are really strange.
 		required_align *= 4;
 	}
 
@@ -2461,7 +2461,7 @@ Error RenderingDeviceVulkan::_texture_update(RID p_texture, uint32_t p_layer, co
 
 	VkCommandBuffer command_buffer = p_use_setup_queue ? frames[frame].setup_command_buffer : frames[frame].draw_command_buffer;
 
-	//barrier to transfer
+	// Barrier to transfer.
 	{
 		VkImageMemoryBarrier image_memory_barrier;
 		image_memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
@@ -2495,7 +2495,7 @@ Error RenderingDeviceVulkan::_texture_update(RID p_texture, uint32_t p_layer, co
 		const uint8_t *read_ptr_mipmap = r + mipmap_offset;
 		image_size = image_total - mipmap_offset;
 
-		for (uint32_t z = 0; z < depth; z++) { //for 3D textures, depth may be > 0
+		for (uint32_t z = 0; z < depth; z++) { // For 3D textures, depth may be > 0.
 
 			const uint8_t *read_ptr = read_ptr_mipmap + image_size * z / depth;
 
@@ -2517,7 +2517,7 @@ Error RenderingDeviceVulkan::_texture_update(RID p_texture, uint32_t p_layer, co
 
 					uint8_t *write_ptr;
 
-					{ //map
+					{ // Map.
 						void *data_ptr = nullptr;
 						VkResult vkerr = vmaMapMemory(allocator, staging_buffer_blocks[staging_buffer_current].allocation, &data_ptr);
 						ERR_FAIL_COND_V_MSG(vkerr, ERR_CANT_CREATE, "vmaMapMemory failed with error " + itos(vkerr) + ".");
@@ -2532,11 +2532,11 @@ Error RenderingDeviceVulkan::_texture_update(RID p_texture, uint32_t p_layer, co
 					ERR_FAIL_COND_V(region_h % block_h, ERR_BUG);
 
 					if (block_w != 1 || block_h != 1) {
-						//compressed image (blocks)
-						//must copy a block region
+						// Compressed image (blocks).
+						// Must copy a block region.
 
 						uint32_t block_size = get_compressed_image_format_block_byte_size(texture->format);
-						//re-create current variables in blocky format
+						// Re-create current variables in blocky format.
 						uint32_t xb = x / block_w;
 						uint32_t yb = y / block_h;
 						uint32_t wb = width / block_w;
@@ -2545,19 +2545,19 @@ Error RenderingDeviceVulkan::_texture_update(RID p_texture, uint32_t p_layer, co
 						uint32_t region_hb = region_h / block_h;
 						_copy_region(read_ptr, write_ptr, xb, yb, region_wb, region_hb, wb, block_size);
 					} else {
-						//regular image (pixels)
-						//must copy a pixel region
+						// Regular image (pixels).
+						// Must copy a pixel region.
 						_copy_region(read_ptr, write_ptr, x, y, region_w, region_h, width, pixel_size);
 					}
 
-					{ //unmap
+					{ // Unmap.
 						vmaUnmapMemory(allocator, staging_buffer_blocks[staging_buffer_current].allocation);
 					}
 
 					VkBufferImageCopy buffer_image_copy;
 					buffer_image_copy.bufferOffset = alloc_offset;
-					buffer_image_copy.bufferRowLength = 0; //tightly packed
-					buffer_image_copy.bufferImageHeight = 0; //tightly packed
+					buffer_image_copy.bufferRowLength = 0; // Tightly packed.
+					buffer_image_copy.bufferImageHeight = 0; // Tightly packed.
 
 					buffer_image_copy.imageSubresource.aspectMask = texture->read_aspect_mask;
 					buffer_image_copy.imageSubresource.mipLevel = mm_i;
@@ -2584,7 +2584,7 @@ Error RenderingDeviceVulkan::_texture_update(RID p_texture, uint32_t p_layer, co
 		logic_height = MAX(1u, logic_height >> 1);
 	}
 
-	//barrier to restore layout
+	// Barrier to restore layout.
 	{
 		uint32_t barrier_flags = 0;
 		uint32_t access_flags = 0;
@@ -2671,7 +2671,7 @@ Vector<uint8_t> RenderingDeviceVulkan::_texture_get_data_from_image(Texture *tex
 				const uint8_t *slice_read_ptr = ((uint8_t *)img_mem) + layout.offset + z * layout.depthPitch;
 
 				if (block_size > 1) {
-					//compressed
+					// Compressed.
 					uint32_t line_width = (block_size * (width / blockw));
 					for (uint32_t y = 0; y < height / blockh; y++) {
 						const uint8_t *rptr = slice_read_ptr + y * layout.rowPitch;
@@ -2681,7 +2681,7 @@ Vector<uint8_t> RenderingDeviceVulkan::_texture_get_data_from_image(Texture *tex
 					}
 
 				} else {
-					//uncompressed
+					// Uncompressed.
 					for (uint32_t y = 0; y < height; y++) {
 						const uint8_t *rptr = slice_read_ptr + y * layout.rowPitch;
 						uint8_t *wptr = write_ptr + y * pixel_size * width;
@@ -2717,19 +2717,19 @@ Vector<uint8_t> RenderingDeviceVulkan::texture_get_data(RID p_texture, uint32_t
 	ERR_FAIL_COND_V(p_layer >= layer_count, Vector<uint8_t>());
 
 	if (tex->usage_flags & TEXTURE_USAGE_CPU_READ_BIT) {
-		//does not need anything fancy, map and read.
+		// Does not need anything fancy, map and read.
 		return _texture_get_data_from_image(tex, tex->image, tex->allocation, p_layer);
 	} else {
-		//compute total image size
+		// Compute total image size.
 		uint32_t width, height, depth;
 		uint32_t buffer_size = get_image_format_required_size(tex->format, tex->width, tex->height, tex->depth, tex->mipmaps, &width, &height, &depth);
 
-		//allocate buffer
-		VkCommandBuffer command_buffer = frames[frame].draw_command_buffer; //makes more sense to retrieve
+		// Allocate buffer.
+		VkCommandBuffer command_buffer = frames[frame].draw_command_buffer; // Makes more sense to retrieve.
 		Buffer tmp_buffer;
 		_buffer_allocate(&tmp_buffer, buffer_size, VK_BUFFER_USAGE_TRANSFER_DST_BIT, VMA_MEMORY_USAGE_AUTO_PREFER_HOST, VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT);
 
-		{ //Source image barrier
+		{ // Source image barrier.
 			VkImageMemoryBarrier image_memory_barrier;
 			image_memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
 			image_memory_barrier.pNext = nullptr;
@@ -2785,7 +2785,7 @@ Vector<uint8_t> RenderingDeviceVulkan::texture_get_data(RID p_texture, uint32_t
 			offset += size;
 		}
 
-		{ //restore src
+		{ // Restore src.
 			VkImageMemoryBarrier image_memory_barrier;
 			image_memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
 			image_memory_barrier.pNext = nullptr;
@@ -2900,9 +2900,9 @@ Error RenderingDeviceVulkan::texture_copy(RID p_from_texture, RID p_to_texture,
 	VkCommandBuffer command_buffer = frames[frame].draw_command_buffer;
 
 	{
-		//PRE Copy the image
+		// PRE Copy the image.
 
-		{ //Source
+		{ // Source.
 			VkImageMemoryBarrier image_memory_barrier;
 			image_memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
 			image_memory_barrier.pNext = nullptr;
@@ -2922,7 +2922,7 @@ Error RenderingDeviceVulkan::texture_copy(RID p_from_texture, RID p_to_texture,
 
 			vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &image_memory_barrier);
 		}
-		{ //Dest
+		{ // Dest.
 			VkImageMemoryBarrier image_memory_barrier;
 			image_memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
 			image_memory_barrier.pNext = nullptr;
@@ -2943,7 +2943,7 @@ Error RenderingDeviceVulkan::texture_copy(RID p_from_texture, RID p_to_texture,
 			vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &image_memory_barrier);
 		}
 
-		//COPY
+		// COPY.
 
 		{
 			VkImageCopy image_copy_region;
@@ -2970,7 +2970,7 @@ Error RenderingDeviceVulkan::texture_copy(RID p_from_texture, RID p_to_texture,
 			vkCmdCopyImage(command_buffer, src_tex->image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dst_tex->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &image_copy_region);
 		}
 
-		// RESTORE LAYOUT for SRC and DST
+		// RESTORE LAYOUT for SRC and DST.
 
 		uint32_t barrier_flags = 0;
 		uint32_t access_flags = 0;
@@ -2991,7 +2991,7 @@ Error RenderingDeviceVulkan::texture_copy(RID p_from_texture, RID p_to_texture,
 			barrier_flags = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
 		}
 
-		{ //restore src
+		{ // Restore src.
 			VkImageMemoryBarrier image_memory_barrier;
 			image_memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
 			image_memory_barrier.pNext = nullptr;
@@ -3011,7 +3011,7 @@ Error RenderingDeviceVulkan::texture_copy(RID p_from_texture, RID p_to_texture,
 			vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, barrier_flags, 0, 0, nullptr, 0, nullptr, 1, &image_memory_barrier);
 		}
 
-		{ //make dst readable
+		{ // Make dst readable.
 
 			VkImageMemoryBarrier image_memory_barrier;
 			image_memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
@@ -3078,9 +3078,9 @@ Error RenderingDeviceVulkan::texture_resolve_multisample(RID p_from_texture, RID
 	VkCommandBuffer command_buffer = frames[frame].draw_command_buffer;
 
 	{
-		//PRE Copy the image
+		// PRE Copy the image.
 
-		{ //Source
+		{ // Source.
 			VkImageMemoryBarrier image_memory_barrier;
 			image_memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
 			image_memory_barrier.pNext = nullptr;
@@ -3100,7 +3100,7 @@ Error RenderingDeviceVulkan::texture_resolve_multisample(RID p_from_texture, RID
 
 			vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &image_memory_barrier);
 		}
-		{ //Dest
+		{ // Dest.
 			VkImageMemoryBarrier image_memory_barrier;
 			image_memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
 			image_memory_barrier.pNext = nullptr;
@@ -3121,7 +3121,7 @@ Error RenderingDeviceVulkan::texture_resolve_multisample(RID p_from_texture, RID
 			vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &image_memory_barrier);
 		}
 
-		//COPY
+		// COPY.
 
 		{
 			VkImageResolve image_copy_region;
@@ -3148,7 +3148,7 @@ Error RenderingDeviceVulkan::texture_resolve_multisample(RID p_from_texture, RID
 			vkCmdResolveImage(command_buffer, src_tex->image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dst_tex->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &image_copy_region);
 		}
 
-		// RESTORE LAYOUT for SRC and DST
+		// RESTORE LAYOUT for SRC and DST.
 
 		uint32_t barrier_flags = 0;
 		uint32_t access_flags = 0;
@@ -3169,7 +3169,7 @@ Error RenderingDeviceVulkan::texture_resolve_multisample(RID p_from_texture, RID
 			barrier_flags = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
 		}
 
-		{ //restore src
+		{ // Restore src.
 			VkImageMemoryBarrier image_memory_barrier;
 			image_memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
 			image_memory_barrier.pNext = nullptr;
@@ -3189,7 +3189,7 @@ Error RenderingDeviceVulkan::texture_resolve_multisample(RID p_from_texture, RID
 			vkCmdPipelineBarrier(command_buffer, VK_ACCESS_TRANSFER_WRITE_BIT, barrier_flags, 0, 0, nullptr, 0, nullptr, 1, &image_memory_barrier);
 		}
 
-		{ //make dst readable
+		{ // Make dst readable.
 
 			VkImageMemoryBarrier image_memory_barrier;
 			image_memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
@@ -3242,13 +3242,13 @@ Error RenderingDeviceVulkan::texture_clear(RID p_texture, const Color &p_color,
 
 	VkImageLayout clear_layout = (src_tex->layout == VK_IMAGE_LAYOUT_GENERAL) ? VK_IMAGE_LAYOUT_GENERAL : VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
 
-	// NOTE: Perhaps the valid stages/accesses for a given owner should be a property of the owner. (Here and places like _get_buffer_from_owner)
+	// NOTE: Perhaps the valid stages/accesses for a given owner should be a property of the owner. (Here and places like _get_buffer_from_owner.)
 	const VkPipelineStageFlags valid_texture_stages = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 	constexpr VkAccessFlags read_access = VK_ACCESS_SHADER_READ_BIT;
 	constexpr VkAccessFlags read_write_access = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
 	const VkAccessFlags valid_texture_access = (src_tex->usage_flags & TEXTURE_USAGE_STORAGE_BIT) ? read_write_access : read_access;
 
-	{ // Barrier from previous access with optional layout change (see clear_layout logic above)
+	{ // Barrier from previous access with optional layout change (see clear_layout logic above).
 		VkImageMemoryBarrier image_memory_barrier;
 		image_memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
 		image_memory_barrier.pNext = nullptr;
@@ -3284,7 +3284,7 @@ Error RenderingDeviceVulkan::texture_clear(RID p_texture, const Color &p_color,
 
 	vkCmdClearColorImage(command_buffer, src_tex->image, clear_layout, &clear_color, 1, &range);
 
-	{ // Barrier to post clear accesses (changing back the layout if needed)
+	{ // Barrier to post clear accesses (changing back the layout if needed).
 
 		uint32_t barrier_flags = 0;
 		uint32_t access_flags = 0;
@@ -3340,7 +3340,7 @@ bool RenderingDeviceVulkan::texture_is_format_supported_for_usage(DataFormat p_f
 
 	_THREAD_SAFE_METHOD_
 
-	//validate that this image is supported for the intended use
+	// Validate that this image is supported for the intended use.
 	VkFormatProperties properties;
 	vkGetPhysicalDeviceFormatProperties(context->get_physical_device(), vulkan_formats[p_format], &properties);
 	VkFormatFeatureFlags flags;
@@ -3384,12 +3384,12 @@ bool RenderingDeviceVulkan::texture_is_format_supported_for_usage(DataFormat p_f
 /********************/
 
 VkRenderPass RenderingDeviceVulkan::_render_pass_create(const Vector<AttachmentFormat> &p_attachments, const Vector<FramebufferPass> &p_passes, InitialAction p_initial_action, FinalAction p_final_action, InitialAction p_initial_depth_action, FinalAction p_final_depth_action, uint32_t p_view_count, Vector<TextureSamples> *r_samples) {
-	// Set up dependencies from/to external equivalent to the default (implicit) one, and then amend them
+	// Set up dependencies from/to external equivalent to the default (implicit) one, and then amend them.
 	const VkPipelineStageFlags default_access_mask = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT |
 			VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
 			VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
 			VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
-			VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | // From Section 7.1 of Vulkan API Spec v1.1.148
+			VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | // From Section 7.1 of Vulkan API Spec v1.1.148.
 			VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR;
 
 	VkPipelineStageFlags reading_stages = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT | VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_TRANSFER_BIT;
@@ -3432,20 +3432,20 @@ VkRenderPass RenderingDeviceVulkan::_render_pass_create(const Vector<AttachmentF
 		bool is_depth = p_attachments[i].usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
 
 		// We can setup a framebuffer where we write to our VRS texture to set it up.
-		// We make the assumption here that if our texture is actually used as our VRS attachment,
-		// it is used as such for each subpass. This is fairly certain seeing the restrictions on subpasses.
+		// We make the assumption here that if our texture is actually used as our VRS attachment.
+		// It is used as such for each subpass. This is fairly certain seeing the restrictions on subpasses.
 		bool is_vrs = p_attachments[i].usage_flags & TEXTURE_USAGE_VRS_ATTACHMENT_BIT && i == p_passes[0].vrs_attachment;
 
 		if (is_vrs) {
-			// For VRS we only read, there is no writing to this texture
+			// For VRS we only read, there is no writing to this texture.
 			description.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
 			description.initialLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 			description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
 		} else {
-			// For each UNDEFINED, assume the prior use was a *read*, as we'd be discarding the output of a write
-			// Also, each UNDEFINED will do an immediate layout transition (write), s.t. we must ensure execution synchronization vs.
+			// For each UNDEFINED, assume the prior use was a *read*, as we'd be discarding the output of a write.
+			// Also, each UNDEFINED will do an immediate layout transition (write), s.t. we must ensure execution synchronization vs
 			// the read. If this is a performance issue, one could track the actual last accessor of each resource, adding only that
-			// stage
+			// stage.
 
 			switch (is_depth ? p_initial_depth_action : p_initial_action) {
 				case INITIAL_ACTION_CLEAR_REGION:
@@ -3462,7 +3462,7 @@ VkRenderPass RenderingDeviceVulkan::_render_pass_create(const Vector<AttachmentF
 					} else {
 						description.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
 						description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
-						description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; //don't care what is there
+						description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; // Don't care what is there.
 						dependency_from_external.srcStageMask |= reading_stages;
 					}
 				} break;
@@ -3479,7 +3479,7 @@ VkRenderPass RenderingDeviceVulkan::_render_pass_create(const Vector<AttachmentF
 					} else {
 						description.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
 						description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
-						description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; //don't care what is there
+						description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; // Don't care what is there.
 						dependency_from_external.srcStageMask |= reading_stages;
 					}
 				} break;
@@ -3490,13 +3490,13 @@ VkRenderPass RenderingDeviceVulkan::_render_pass_create(const Vector<AttachmentF
 						description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
 					} else if (p_attachments[i].usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {
 						description.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
-						description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; //don't care what is there
+						description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; // Don't care what is there.
 						description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
 						dependency_from_external.srcStageMask |= reading_stages;
 					} else {
 						description.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
 						description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
-						description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; //don't care what is there
+						description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; // Don't care what is there.
 						dependency_from_external.srcStageMask |= reading_stages;
 					}
 				} break;
@@ -3513,12 +3513,12 @@ VkRenderPass RenderingDeviceVulkan::_render_pass_create(const Vector<AttachmentF
 					} else {
 						description.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
 						description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
-						description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; //don't care what is there
+						description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; // Don't care what is there.
 						dependency_from_external.srcStageMask |= reading_stages;
 					}
 				} break;
 				default: {
-					ERR_FAIL_V(VK_NULL_HANDLE); //should never reach here
+					ERR_FAIL_V(VK_NULL_HANDLE); // Should never reach here.
 				}
 			}
 		}
@@ -3529,7 +3529,7 @@ VkRenderPass RenderingDeviceVulkan::_render_pass_create(const Vector<AttachmentF
 			int last_pass = p_passes.size() - 1;
 
 			if (is_depth) {
-				//likely missing depth resolve?
+				// Likely missing depth resolve?
 				if (p_passes[last_pass].depth_attachment == i) {
 					used_last = true;
 				}
@@ -3539,7 +3539,7 @@ VkRenderPass RenderingDeviceVulkan::_render_pass_create(const Vector<AttachmentF
 				}
 			} else {
 				if (p_passes[last_pass].resolve_attachments.size()) {
-					//if using resolve attachments, check resolve attachments
+					// If using resolve attachments, check resolve attachments.
 					for (int j = 0; j < p_passes[last_pass].resolve_attachments.size(); j++) {
 						if (p_passes[last_pass].resolve_attachments[j] == i) {
 							used_last = true;
@@ -3579,13 +3579,13 @@ VkRenderPass RenderingDeviceVulkan::_render_pass_create(const Vector<AttachmentF
 		}
 
 		if (is_vrs) {
-			// We don't change our VRS texture during this process
+			// We don't change our VRS texture during this process.
 
 			description.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
 			description.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
 			description.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 
-			// TODO do we need to update our external dependency ?
+			// TODO: Do we need to update our external dependency?
 			// update_external_dependency_for_store(dependency_to_external, is_sampled, is_storage, false);
 		} else {
 			switch (is_depth ? final_depth_action : final_action) {
@@ -3603,8 +3603,8 @@ VkRenderPass RenderingDeviceVulkan::_render_pass_create(const Vector<AttachmentF
 					} else {
 						description.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
 						description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
-						description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; //don't care what is there
-						// TODO: What does this mean about the next usage (and thus appropriate dependency masks
+						description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; // Don't care what is there.
+						// TODO: What does this mean about the next usage (and thus appropriate dependency masks.
 					}
 				} break;
 				case FINAL_ACTION_DISCARD: {
@@ -3619,7 +3619,7 @@ VkRenderPass RenderingDeviceVulkan::_render_pass_create(const Vector<AttachmentF
 					} else {
 						description.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
 						description.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
-						description.finalLayout = VK_IMAGE_LAYOUT_UNDEFINED; //don't care what is there
+						description.finalLayout = VK_IMAGE_LAYOUT_UNDEFINED; // Don't care what is there.
 					}
 				} break;
 				case FINAL_ACTION_CONTINUE: {
@@ -3634,12 +3634,12 @@ VkRenderPass RenderingDeviceVulkan::_render_pass_create(const Vector<AttachmentF
 					} else {
 						description.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
 						description.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
-						description.finalLayout = VK_IMAGE_LAYOUT_UNDEFINED; //don't care what is there
+						description.finalLayout = VK_IMAGE_LAYOUT_UNDEFINED; // Don't care what is there.
 					}
 
 				} break;
 				default: {
-					ERR_FAIL_V(VK_NULL_HANDLE); //should never reach here
+					ERR_FAIL_V(VK_NULL_HANDLE); // Should never reach here.
 				}
 			}
 		}
@@ -3723,7 +3723,7 @@ VkRenderPass RenderingDeviceVulkan::_render_pass_create(const Vector<AttachmentF
 				reference.layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 				attachment_last_pass[attachment] = i;
 			}
-			reference.aspectMask = 0; // TODO we need to set this here, possibly VK_IMAGE_ASPECT_COLOR_BIT ??
+			reference.aspectMask = 0; // TODO: We need to set this here, possibly VK_IMAGE_ASPECT_COLOR_BIT?
 			input_references.push_back(reference);
 		}
 
@@ -3749,7 +3749,7 @@ VkRenderPass RenderingDeviceVulkan::_render_pass_create(const Vector<AttachmentF
 				bool multisample = p_attachments[attachment].samples > TEXTURE_SAMPLES_1;
 				ERR_FAIL_COND_V_MSG(multisample, VK_NULL_HANDLE, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), resolve attachments can't be multisample.");
 				reference.attachment = attachment_remap[attachment];
-				reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; // VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+				reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; // VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
 				attachment_last_pass[attachment] = i;
 			}
 			reference.aspectMask = 0;
@@ -3818,7 +3818,7 @@ VkRenderPass RenderingDeviceVulkan::_render_pass_create(const Vector<AttachmentF
 			ERR_FAIL_INDEX_V_MSG(attachment, p_attachments.size(), VK_NULL_HANDLE, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), preserve attachment (" + itos(j) + ").");
 
 			if (attachment_last_pass[attachment] != i) {
-				//preserve can still be used to keep depth or color from being discarded after use
+				// Preserve can still be used to keep depth or color from being discarded after use.
 				attachment_last_pass[attachment] = i;
 				preserve_references.push_back(attachment);
 			}
@@ -3887,14 +3887,14 @@ VkRenderPass RenderingDeviceVulkan::_render_pass_create(const Vector<AttachmentF
 			subpass_dependencies.push_back(dependency);
 		}
 		/*
-		// NOTE: Big Mallet Approach -- any layout transition causes a full barrier
+		// NOTE: Big Mallet Approach -- any layout transition causes a full barrier.
 		if (reference.layout != description.initialLayout) {
-			// NOTE: this should be smarter based on the texture's knowledge of its previous role
+			// NOTE: This should be smarter based on the texture's knowledge of its previous role.
 			dependency_from_external.srcStageMask |= VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
 			dependency_from_external.srcAccessMask |= VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT;
 		}
 		if (reference.layout != description.finalLayout) {
-			// NOTE: this should be smarter based on the texture's knowledge of its subsequent role
+			// NOTE: This should be smarter based on the texture's knowledge of its subsequent role.
 			dependency_to_external.dstStageMask |= VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
 			dependency_to_external.dstAccessMask |= VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT;
 		}
@@ -3935,7 +3935,7 @@ VkRenderPass RenderingDeviceVulkan::_render_pass_create(const Vector<AttachmentF
 	VkRenderPassMultiviewCreateInfo render_pass_multiview_create_info;
 
 	if (p_view_count > 1) {
-		// this may no longer be needed with the new settings already including this
+		// This may no longer be needed with the new settings already including this.
 
 		const VulkanContext::MultiviewCapabilities capabilities = context->get_multiview_capabilities();
 
@@ -3945,7 +3945,7 @@ VkRenderPass RenderingDeviceVulkan::_render_pass_create(const Vector<AttachmentF
 		// Make sure we limit this to the number of views we support.
 		ERR_FAIL_COND_V_MSG(p_view_count > capabilities.max_view_count, VK_NULL_HANDLE, "Hardware does not support requested number of views for Multiview render pass");
 
-		// Set view masks for each subpass
+		// Set view masks for each subpass.
 		for (uint32_t i = 0; i < subpasses.size(); i++) {
 			view_masks.push_back(view_mask);
 		}
@@ -3993,14 +3993,14 @@ RenderingDevice::FramebufferFormatID RenderingDeviceVulkan::framebuffer_format_c
 
 	const RBMap<FramebufferFormatKey, FramebufferFormatID>::Element *E = framebuffer_format_cache.find(key);
 	if (E) {
-		//exists, return
+		// Exists, return.
 		return E->get();
 	}
 
 	Vector<TextureSamples> samples;
-	VkRenderPass render_pass = _render_pass_create(p_attachments, p_passes, INITIAL_ACTION_CLEAR, FINAL_ACTION_READ, INITIAL_ACTION_CLEAR, FINAL_ACTION_READ, p_view_count, &samples); //actions don't matter for this use case
+	VkRenderPass render_pass = _render_pass_create(p_attachments, p_passes, INITIAL_ACTION_CLEAR, FINAL_ACTION_READ, INITIAL_ACTION_CLEAR, FINAL_ACTION_READ, p_view_count, &samples); // Actions don't matter for this use case.
 
-	if (render_pass == VK_NULL_HANDLE) { //was likely invalid
+	if (render_pass == VK_NULL_HANDLE) { // Was likely invalid.
 		return INVALID_ID;
 	}
 	FramebufferFormatID id = FramebufferFormatID(framebuffer_format_cache.size()) | (FramebufferFormatID(ID_TYPE_FRAMEBUFFER_FORMAT) << FramebufferFormatID(ID_BASE_SHIFT));
@@ -4021,7 +4021,7 @@ RenderingDevice::FramebufferFormatID RenderingDeviceVulkan::framebuffer_format_c
 
 	const RBMap<FramebufferFormatKey, FramebufferFormatID>::Element *E = framebuffer_format_cache.find(key);
 	if (E) {
-		//exists, return
+		// Exists, return.
 		return E->get();
 	}
 
@@ -4031,7 +4031,7 @@ RenderingDevice::FramebufferFormatID RenderingDeviceVulkan::framebuffer_format_c
 	subpass.flags = 0;
 	subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
 	subpass.viewMask = 0;
-	subpass.inputAttachmentCount = 0; //unsupported for now
+	subpass.inputAttachmentCount = 0; // Unsupported for now.
 	subpass.pInputAttachments = nullptr;
 	subpass.colorAttachmentCount = 0;
 	subpass.pColorAttachments = nullptr;
@@ -4058,7 +4058,7 @@ RenderingDevice::FramebufferFormatID RenderingDeviceVulkan::framebuffer_format_c
 
 	ERR_FAIL_COND_V_MSG(res, 0, "vkCreateRenderPass2KHR for empty fb failed with error " + itos(res) + ".");
 
-	if (render_pass == VK_NULL_HANDLE) { //was likely invalid
+	if (render_pass == VK_NULL_HANDLE) { // Was likely invalid.
 		return INVALID_ID;
 	}
 
@@ -4146,9 +4146,9 @@ RID RenderingDeviceVulkan::framebuffer_create_multipass(const Vector<RID> &p_tex
 				size.height = texture->height;
 				size_set = true;
 			} else if (texture->usage_flags & TEXTURE_USAGE_VRS_ATTACHMENT_BIT) {
-				// If this is not the first attachement we assume this is used as the VRS attachment
-				// in this case this texture will be 1/16th the size of the color attachement.
-				// So we skip the size check
+				// If this is not the first attachement we assume this is used as the VRS attachment.
+				// In this case this texture will be 1/16th the size of the color attachement.
+				// So we skip the size check.
 			} else {
 				ERR_FAIL_COND_V_MSG((uint32_t)size.width != texture->width || (uint32_t)size.height != texture->height, RID(),
 						"All textures in a framebuffer should be the same size.");
@@ -4298,7 +4298,7 @@ RID RenderingDeviceVulkan::vertex_buffer_create(uint32_t p_size_bytes, const Vec
 	return id;
 }
 
-// Internally reference counted, this ID is warranted to be unique for the same description, but needs to be freed as many times as it was allocated
+// Internally reference counted, this ID is warranted to be unique for the same description, but needs to be freed as many times as it was allocated.
 RenderingDevice::VertexFormatID RenderingDeviceVulkan::vertex_format_create(const Vector<VertexAttribute> &p_vertex_formats) {
 	_THREAD_SAFE_METHOD_
 
@@ -4310,7 +4310,7 @@ RenderingDevice::VertexFormatID RenderingDeviceVulkan::vertex_format_create(cons
 		return *idptr;
 	}
 
-	//does not exist, create one and cache it
+	// Does not exist, create one and cache it.
 	VertexDescriptionCache vdcache;
 	vdcache.bindings = memnew_arr(VkVertexInputBindingDescription, p_vertex_formats.size());
 	vdcache.attributes = memnew_arr(VkVertexInputAttributeDescription, p_vertex_formats.size());
@@ -4366,25 +4366,25 @@ RID RenderingDeviceVulkan::vertex_array_create(uint32_t p_vertex_count, VertexFo
 
 	vertex_array.vertex_count = p_vertex_count;
 	vertex_array.description = p_vertex_format;
-	vertex_array.max_instances_allowed = 0xFFFFFFFF; //by default as many as you want
+	vertex_array.max_instances_allowed = 0xFFFFFFFF; // By default as many as you want.
 	for (int i = 0; i < p_src_buffers.size(); i++) {
 		Buffer *buffer = vertex_buffer_owner.get_or_null(p_src_buffers[i]);
 
-		//validate with buffer
+		// Validate with buffer.
 		{
 			const VertexAttribute &atf = vd.vertex_formats[i];
 
 			uint32_t element_size = get_format_vertex_size(atf.format);
-			ERR_FAIL_COND_V(element_size == 0, RID()); //should never happens since this was prevalidated
+			ERR_FAIL_COND_V(element_size == 0, RID()); // Should never happens since this was prevalidated.
 
 			if (atf.frequency == VERTEX_FREQUENCY_VERTEX) {
-				//validate size for regular drawing
+				// Validate size for regular drawing.
 				uint64_t total_size = uint64_t(atf.stride) * (p_vertex_count - 1) + atf.offset + element_size;
 				ERR_FAIL_COND_V_MSG(total_size > buffer->size, RID(),
 						"Attachment (" + itos(i) + ") will read past the end of the buffer.");
 
 			} else {
-				//validate size for instances drawing
+				// Validate size for instances drawing.
 				uint64_t available = buffer->size - atf.offset;
 				ERR_FAIL_COND_V_MSG(available < element_size, RID(),
 						"Attachment (" + itos(i) + ") uses instancing, but it's just too small.");
@@ -4395,7 +4395,7 @@ RID RenderingDeviceVulkan::vertex_array_create(uint32_t p_vertex_count, VertexFo
 		}
 
 		vertex_array.buffers.push_back(buffer->buffer);
-		vertex_array.offsets.push_back(0); //offset unused, but passing anyway
+		vertex_array.offsets.push_back(0); // Offset unused, but passing anyway.
 	}
 
 	RID id = vertex_array_owner.make_rid(vertex_array);
@@ -4430,7 +4430,7 @@ RID RenderingDeviceVulkan::index_buffer_create(uint32_t p_index_count, IndexBuff
 			const uint16_t *index16 = (const uint16_t *)r;
 			for (uint32_t i = 0; i < p_index_count; i++) {
 				if (p_use_restart_indices && index16[i] == 0xFFFF) {
-					continue; //restart index, ignore
+					continue; // Restart index, ignore.
 				}
 				index_buffer.max_index = MAX(index16[i], index_buffer.max_index);
 			}
@@ -4438,7 +4438,7 @@ RID RenderingDeviceVulkan::index_buffer_create(uint32_t p_index_count, IndexBuff
 			const uint32_t *index32 = (const uint32_t *)r;
 			for (uint32_t i = 0; i < p_index_count; i++) {
 				if (p_use_restart_indices && index32[i] == 0xFFFFFFFF) {
-					continue; //restart index, ignore
+					continue; // Restart index, ignore.
 				}
 				index_buffer.max_index = MAX(index32[i], index_buffer.max_index);
 			}
@@ -4537,7 +4537,7 @@ bool RenderingDeviceVulkan::_uniform_add_binding(Vector<Vector<VkDescriptorSetLa
 		case glslang::EbtSampler: {
 			//print_line("DEBUG: IsSampler");
 			if (reflection.getType()->getSampler().dim == glslang::EsdBuffer) {
-				//texture buffers
+				// Texture buffers.
 				if (reflection.getType()->getSampler().isCombined()) {
 					layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
 					info.type = UNIFORM_TYPE_SAMPLER_WITH_TEXTURE_BUFFER;
@@ -4637,7 +4637,7 @@ bool RenderingDeviceVulkan::_uniform_add_binding(Vector<Vector<VkDescriptorSetLa
 		} break;*/
 		default: {
 			if (reflection.getType()->getQualifier().hasOffset() || reflection.name.find(".") != std::string::npos) {
-				//member of uniform block?
+				// Member of uniform block?
 				return true;
 			}
 
@@ -4674,10 +4674,10 @@ bool RenderingDeviceVulkan::_uniform_add_binding(Vector<Vector<VkDescriptorSetLa
 	uint32_t binding = reflection.getType()->getQualifier().layoutBinding;
 
 	if (set < (uint32_t)bindings.size()) {
-		//check if this already exists
+		// Check if this already exists.
 		for (int i = 0; i < bindings[set].size(); i++) {
 			if (bindings[set][i].binding == binding) {
-				//already exists, verify that it's the same type
+				// Already exists, verify that it's the same type.
 				if (bindings[set][i].descriptorType != layout_binding.descriptorType) {
 					if (r_error) {
 						*r_error = "On shader stage '" + String(shader_stage_names[p_stage]) + "', uniform '" + reflection.name + "' trying to re-use location for set=" + itos(set) + ", binding=" + itos(binding) + " with different uniform type.";
@@ -4685,7 +4685,7 @@ bool RenderingDeviceVulkan::_uniform_add_binding(Vector<Vector<VkDescriptorSetLa
 					return false;
 				}
 
-				//also, verify that it's the same size
+				// Also, verify that it's the same size.
 				if (bindings[set][i].descriptorCount != layout_binding.descriptorCount || uniform_infos[set][i].length != info.length) {
 					if (r_error) {
 						*r_error = "On shader stage '" + String(shader_stage_names[p_stage]) + "', uniform '" + reflection.name + "' trying to re-use location for set=" + itos(set) + ", binding=" + itos(binding) + " with different uniform size.";
@@ -4693,7 +4693,7 @@ bool RenderingDeviceVulkan::_uniform_add_binding(Vector<Vector<VkDescriptorSetLa
 					return false;
 				}
 
-				//just append stage mask and return
+				// Just append stage mask and return.
 				bindings.write[set].write[i].stageFlags |= shader_stage_masks[p_stage];
 				uniform_infos.write[set].write[i].stages |= 1 << p_stage;
 				return true;
@@ -4702,7 +4702,7 @@ bool RenderingDeviceVulkan::_uniform_add_binding(Vector<Vector<VkDescriptorSetLa
 	}
 	layout_binding.binding = binding;
 	layout_binding.stageFlags = shader_stage_masks[p_stage];
-	layout_binding.pImmutableSamplers = nullptr; //no support for this yet
+	layout_binding.pImmutableSamplers = nullptr; // No support for this yet.
 
 	info.stages = 1 << p_stage;
 	info.binding = binding;
@@ -4721,9 +4721,9 @@ bool RenderingDeviceVulkan::_uniform_add_binding(Vector<Vector<VkDescriptorSetLa
 }
 #endif
 
-//version 1: initial
-//version 2: Added shader name
-//version 3: Added writable
+// Version 1: initial.
+// Version 2: Added shader name.
+// Version 3: Added writable.
 
 #define SHADER_BINARY_VERSION 3
 
@@ -4735,7 +4735,7 @@ struct RenderingDeviceVulkanShaderBinaryDataBinding {
 	uint32_t type;
 	uint32_t binding;
 	uint32_t stages;
-	uint32_t length; //size of arrays (in total elements), or ubos (in bytes * total elements)
+	uint32_t length; // Size of arrays (in total elements), or ubos (in bytes * total elements).
 	uint32_t writable;
 };
 
@@ -4776,7 +4776,7 @@ Vector<uint8_t> RenderingDeviceVulkan::shader_compile_binary_from_spirv(const Ve
 	binary_data.push_constant_size = 0;
 	binary_data.push_constants_vk_stage = 0;
 
-	Vector<Vector<RenderingDeviceVulkanShaderBinaryDataBinding>> uniform_info; //set bindings
+	Vector<Vector<RenderingDeviceVulkanShaderBinaryDataBinding>> uniform_info; // Set bindings.
 	Vector<RenderingDeviceVulkanShaderBinarySpecializationConstant> specialization_constants;
 
 	uint32_t stages_processed = 0;
@@ -4810,7 +4810,7 @@ Vector<uint8_t> RenderingDeviceVulkan::shader_compile_binary_from_spirv(const Ve
 			uint32_t stage = p_spirv[i].shader_stage;
 
 			if (binding_count > 0) {
-				//Parse bindings
+				// Parse bindings.
 
 				Vector<SpvReflectDescriptorBinding *> bindings;
 				bindings.resize(binding_count);
@@ -4917,23 +4917,23 @@ Vector<uint8_t> RenderingDeviceVulkan::shader_compile_binary_from_spirv(const Ve
 							"On shader stage '" + String(shader_stage_names[stage]) + "', uniform '" + binding.name + "' uses a set (" + itos(set) + ") index larger than what is supported by the hardware (" + itos(limits.maxBoundDescriptorSets) + ").");
 
 					if (set < (uint32_t)uniform_info.size()) {
-						//check if this already exists
+						// Check if this already exists.
 						bool exists = false;
 						for (int k = 0; k < uniform_info[set].size(); k++) {
 							if (uniform_info[set][k].binding == (uint32_t)info.binding) {
-								//already exists, verify that it's the same type
+								// Already exists, verify that it's the same type.
 								ERR_FAIL_COND_V_MSG(uniform_info[set][k].type != info.type, Vector<uint8_t>(),
 										"On shader stage '" + String(shader_stage_names[stage]) + "', uniform '" + binding.name + "' trying to re-use location for set=" + itos(set) + ", binding=" + itos(info.binding) + " with different uniform type.");
 
-								//also, verify that it's the same size
+								// Also, verify that it's the same size.
 								ERR_FAIL_COND_V_MSG(uniform_info[set][k].length != info.length, Vector<uint8_t>(),
 										"On shader stage '" + String(shader_stage_names[stage]) + "', uniform '" + binding.name + "' trying to re-use location for set=" + itos(set) + ", binding=" + itos(info.binding) + " with different uniform size.");
 
-								//also, verify that it has the same writability
+								// Also, verify that it has the same writability.
 								ERR_FAIL_COND_V_MSG(uniform_info[set][k].writable != info.writable, Vector<uint8_t>(),
 										"On shader stage '" + String(shader_stage_names[stage]) + "', uniform '" + binding.name + "' trying to re-use location for set=" + itos(set) + ", binding=" + itos(info.binding) + " with different writability.");
 
-								//just append stage mask and return
+								// Just append stage mask and return.
 								uniform_info.write[set].write[k].stages |= 1 << stage;
 								exists = true;
 								break;
@@ -4941,7 +4941,7 @@ Vector<uint8_t> RenderingDeviceVulkan::shader_compile_binary_from_spirv(const Ve
 						}
 
 						if (exists) {
-							continue; //merged
+							continue; // Merged.
 						}
 					}
 
@@ -4956,7 +4956,7 @@ Vector<uint8_t> RenderingDeviceVulkan::shader_compile_binary_from_spirv(const Ve
 			}
 
 			{
-				//specialization constants
+				// Specialization constants.
 
 				uint32_t sc_count = 0;
 				result = spvReflectEnumerateSpecializationConstants(&module, &sc_count, nullptr);
@@ -4977,7 +4977,7 @@ Vector<uint8_t> RenderingDeviceVulkan::shader_compile_binary_from_spirv(const Ve
 						SpvReflectSpecializationConstant *spc = spec_constants[j];
 
 						sconst.constant_id = spc->constant_id;
-						sconst.int_value = 0.0; // clear previous value JIC
+						sconst.int_value = 0.0; // Clear previous value JIC.
 						switch (spc->constant_type) {
 							case SPV_REFLECT_SPECIALIZATION_CONSTANT_BOOL: {
 								sconst.type = PIPELINE_SPECIALIZATION_CONSTANT_TYPE_BOOL;
@@ -5027,7 +5027,7 @@ Vector<uint8_t> RenderingDeviceVulkan::shader_compile_binary_from_spirv(const Ve
 							"Reflection of SPIR-V shader stage '" + String(shader_stage_names[p_spirv[i].shader_stage]) + "' failed obtaining input variables.");
 
 					for (uint32_t j = 0; j < iv_count; j++) {
-						if (input_vars[j] && input_vars[j]->decoration_flags == 0) { //regular input
+						if (input_vars[j] && input_vars[j]->decoration_flags == 0) { // Regular input.
 							binary_data.vertex_input_mask |= (1 << uint32_t(input_vars[j]->location));
 						}
 					}
@@ -5096,7 +5096,7 @@ Vector<uint8_t> RenderingDeviceVulkan::shader_compile_binary_from_spirv(const Ve
 
 	Vector<Vector<uint8_t>> compressed_stages;
 	Vector<uint32_t> smolv_size;
-	Vector<uint32_t> zstd_size; //if 0, stdno t used
+	Vector<uint32_t> zstd_size; // If 0, zstd not used.
 
 	uint32_t stages_binary_size = 0;
 
@@ -5108,7 +5108,7 @@ Vector<uint8_t> RenderingDeviceVulkan::shader_compile_binary_from_spirv(const Ve
 			ERR_FAIL_V_MSG(Vector<uint8_t>(), "Error compressing shader stage :" + String(shader_stage_names[p_spirv[i].shader_stage]));
 		} else {
 			smolv_size.push_back(smolv.size());
-			{ //zstd
+			{ // zstd.
 				Vector<uint8_t> zstd;
 				zstd.resize(Compression::get_max_compressed_buffer_size(smolv.size(), Compression::MODE_ZSTD));
 				int dst_size = Compression::compress(zstd.ptrw(), &smolv[0], smolv.size(), Compression::MODE_ZSTD);
@@ -5121,7 +5121,7 @@ Vector<uint8_t> RenderingDeviceVulkan::shader_compile_binary_from_spirv(const Ve
 					Vector<uint8_t> smv;
 					smv.resize(smolv.size());
 					memcpy(smv.ptrw(), &smolv[0], smolv.size());
-					zstd_size.push_back(0); //not using zstd
+					zstd_size.push_back(0); // Not using zstd.
 					compressed_stages.push_back(smv);
 				}
 			}
@@ -5141,12 +5141,12 @@ Vector<uint8_t> RenderingDeviceVulkan::shader_compile_binary_from_spirv(const Ve
 
 	binary_data.shader_name_len = shader_name_utf.length();
 
-	uint32_t total_size = sizeof(uint32_t) * 3; //header + version + main datasize;
+	uint32_t total_size = sizeof(uint32_t) * 3; // Header + version + main datasize;.
 	total_size += sizeof(RenderingDeviceVulkanShaderBinaryData);
 
 	total_size += binary_data.shader_name_len;
 
-	if ((binary_data.shader_name_len % 4) != 0) { //alignment rules are really strange
+	if ((binary_data.shader_name_len % 4) != 0) { // Alignment rules are really strange.
 		total_size += 4 - (binary_data.shader_name_len % 4);
 	}
 
@@ -5157,7 +5157,7 @@ Vector<uint8_t> RenderingDeviceVulkan::shader_compile_binary_from_spirv(const Ve
 
 	total_size += sizeof(RenderingDeviceVulkanShaderBinarySpecializationConstant) * specialization_constants.size();
 
-	total_size += compressed_stages.size() * sizeof(uint32_t) * 3; //sizes
+	total_size += compressed_stages.size() * sizeof(uint32_t) * 3; // Sizes.
 	total_size += stages_binary_size;
 
 	Vector<uint8_t> ret;
@@ -5168,7 +5168,7 @@ Vector<uint8_t> RenderingDeviceVulkan::shader_compile_binary_from_spirv(const Ve
 		binptr[0] = 'G';
 		binptr[1] = 'V';
 		binptr[2] = 'B';
-		binptr[3] = 'D'; //godot vulkan binary data
+		binptr[3] = 'D'; // Godot vulkan binary data.
 		offset += 4;
 		encode_uint32(SHADER_BINARY_VERSION, binptr + offset);
 		offset += sizeof(uint32_t);
@@ -5179,7 +5179,7 @@ Vector<uint8_t> RenderingDeviceVulkan::shader_compile_binary_from_spirv(const Ve
 		memcpy(binptr + offset, shader_name_utf.ptr(), binary_data.shader_name_len);
 		offset += binary_data.shader_name_len;
 
-		if ((binary_data.shader_name_len % 4) != 0) { //alignment rules are really strange
+		if ((binary_data.shader_name_len % 4) != 0) { // Alignment rules are really strange.
 			offset += 4 - (binary_data.shader_name_len % 4);
 		}
 
@@ -5227,7 +5227,7 @@ RID RenderingDeviceVulkan::shader_create_from_bytecode(const Vector<uint8_t> &p_
 	uint32_t binsize = p_shader_binary.size();
 
 	uint32_t read_offset = 0;
-	//consistency check
+	// Consistency check.
 	ERR_FAIL_COND_V(binsize < sizeof(uint32_t) * 3 + sizeof(RenderingDeviceVulkanShaderBinaryData), RID());
 	ERR_FAIL_COND_V(binptr[0] != 'G' || binptr[1] != 'V' || binptr[2] != 'B' || binptr[3] != 'D', RID());
 
@@ -5257,7 +5257,7 @@ RID RenderingDeviceVulkan::shader_create_from_bytecode(const Vector<uint8_t> &p_
 	if (binary_data.shader_name_len) {
 		name.parse_utf8((const char *)(binptr + read_offset), binary_data.shader_name_len);
 		read_offset += binary_data.shader_name_len;
-		if ((binary_data.shader_name_len % 4) != 0) { //alignment rules are really strange
+		if ((binary_data.shader_name_len % 4) != 0) { // Alignment rules are really strange.
 			read_offset += 4 - (binary_data.shader_name_len % 4);
 		}
 	}
@@ -5374,7 +5374,7 @@ RID RenderingDeviceVulkan::shader_create_from_bytecode(const Vector<uint8_t> &p_
 		const uint8_t *src_smolv = nullptr;
 
 		if (zstd_size > 0) {
-			//decompress to smolv
+			// Decompress to smolv.
 			smolv.resize(smolv_size);
 			int dec_smolv_size = Compression::decompress(smolv.ptrw(), smolv.size(), binptr + read_offset, zstd_size, Compression::MODE_ZSTD);
 			ERR_FAIL_COND_V(dec_smolv_size != (int32_t)smolv_size, RID());
@@ -5403,7 +5403,7 @@ RID RenderingDeviceVulkan::shader_create_from_bytecode(const Vector<uint8_t> &p_
 
 	ERR_FAIL_COND_V(read_offset != binsize, RID());
 
-	//all good, let's create modules
+	// All good, let's create modules.
 
 	_THREAD_SAFE_METHOD_
 
@@ -5459,11 +5459,11 @@ RID RenderingDeviceVulkan::shader_create_from_bytecode(const Vector<uint8_t> &p_
 
 		shader.pipeline_stages.push_back(shader_stage);
 	}
-	//proceed to create descriptor sets
+	// Proceed to create descriptor sets.
 
 	if (success) {
 		for (int i = 0; i < set_bindings.size(); i++) {
-			//empty ones are fine if they were not used according to spec (binding count will be 0)
+			// Empty ones are fine if they were not used according to spec (binding count will be 0).
 			VkDescriptorSetLayoutCreateInfo layout_create_info;
 			layout_create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
 			layout_create_info.pNext = nullptr;
@@ -5482,13 +5482,13 @@ RID RenderingDeviceVulkan::shader_create_from_bytecode(const Vector<uint8_t> &p_
 			Shader::Set set;
 			set.descriptor_set_layout = layout;
 			set.uniform_info = uniform_info[i];
-			//sort and hash
+			// Sort and hash.
 			set.uniform_info.sort();
 
-			uint32_t format = 0; //no format, default
+			uint32_t format = 0; // No format, default.
 
 			if (set.uniform_info.size()) {
-				//has data, needs an actual format;
+				// Has data, needs an actual format.
 				UniformSetFormat usformat;
 				usformat.uniform_info = set.uniform_info;
 				RBMap<UniformSetFormat, uint32_t>::Element *E = uniform_set_format_cache.find(usformat);
@@ -5506,7 +5506,7 @@ RID RenderingDeviceVulkan::shader_create_from_bytecode(const Vector<uint8_t> &p_
 	}
 
 	if (success) {
-		//create pipeline layout
+		// Create pipeline layout.
 		VkPipelineLayoutCreateInfo pipeline_layout_create_info;
 		pipeline_layout_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
 		pipeline_layout_create_info.pNext = nullptr;
@@ -5545,7 +5545,7 @@ RID RenderingDeviceVulkan::shader_create_from_bytecode(const Vector<uint8_t> &p_
 	}
 
 	if (!success) {
-		//clean up if failed
+		// Clean up if failed.
 		for (int i = 0; i < shader.pipeline_stages.size(); i++) {
 			vkDestroyShaderModule(device, shader.pipeline_stages[i].module, nullptr);
 		}
@@ -5668,7 +5668,7 @@ RID RenderingDeviceVulkan::texture_buffer_create(uint32_t p_size_elements, DataF
 		ERR_FAIL_V_MSG(RID(), "Unable to create buffer view, error " + itos(res) + ".");
 	}
 
-	//allocate the view
+	// Allocate the view.
 	RID id = texture_buffer_owner.make_rid(texture_buffer);
 #ifdef DEV_ENABLED
 	set_resource_name(id, "RID:" + itos(id.get_id()));
@@ -5691,17 +5691,17 @@ RenderingDeviceVulkan::DescriptorPool *RenderingDeviceVulkan::_descriptor_pool_a
 	}
 
 	if (!pool) {
-		//create a new one
+		// Create a new one.
 		pool = memnew(DescriptorPool);
 		pool->usage = 0;
 
 		VkDescriptorPoolCreateInfo descriptor_pool_create_info;
 		descriptor_pool_create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
 		descriptor_pool_create_info.pNext = nullptr;
-		descriptor_pool_create_info.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT; // can't think how somebody may NOT need this flag..
+		descriptor_pool_create_info.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT; // Can't think how somebody may NOT need this flag.
 		descriptor_pool_create_info.maxSets = max_descriptors_per_pool;
 		Vector<VkDescriptorPoolSize> sizes;
-		//here comes more vulkan API strangeness
+		// Here comes more vulkan API strangeness.
 
 		if (p_key.uniform_type[UNIFORM_TYPE_SAMPLER]) {
 			VkDescriptorPoolSize s;
@@ -5801,7 +5801,7 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 
 	ERR_FAIL_COND_V_MSG(p_shader_set >= (uint32_t)shader->sets.size() || shader->sets[p_shader_set].uniform_info.size() == 0, RID(),
 			"Desired set (" + itos(p_shader_set) + ") not used by shader.");
-	//see that all sets in shader are satisfied
+	// See that all sets in shader are satisfied.
 
 	const Shader::Set &set = shader->sets[p_shader_set];
 
@@ -5814,11 +5814,11 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 	Vector<VkWriteDescriptorSet> writes;
 	DescriptorPoolKey pool_key;
 
-	//to keep them alive until update call
+	// To keep them alive until update call.
 	List<Vector<VkDescriptorBufferInfo>> buffer_infos;
 	List<Vector<VkBufferView>> buffer_views;
 	List<Vector<VkDescriptorImageInfo>> image_infos;
-	//used for verification to make sure a uniform set does not use a framebuffer bound texture
+	// Used for verification to make sure a uniform set does not use a framebuffer bound texture.
 	LocalVector<UniformSet::AttachableTexture> attachable_textures;
 	Vector<Texture *> mutable_sampled_textures;
 	Vector<Texture *> mutable_storage_textures;
@@ -5839,14 +5839,14 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 		ERR_FAIL_COND_V_MSG(uniform.uniform_type != set_uniform.type, RID(),
 				"Mismatch uniform type for binding (" + itos(set_uniform.binding) + "), set (" + itos(p_shader_set) + "). Expected '" + shader_uniform_names[set_uniform.type] + "', supplied: '" + shader_uniform_names[uniform.uniform_type] + "'.");
 
-		VkWriteDescriptorSet write; //common header
+		VkWriteDescriptorSet write; // Common header.
 		write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
 		write.pNext = nullptr;
-		write.dstSet = VK_NULL_HANDLE; //will assign afterwards when everything is valid
+		write.dstSet = VK_NULL_HANDLE; // Will assign afterwards when everything is valid.
 		write.dstBinding = set_uniform.binding;
 		write.dstArrayElement = 0;
 		write.descriptorCount = 0;
-		write.descriptorType = VK_DESCRIPTOR_TYPE_MAX_ENUM; //Invalid value.
+		write.descriptorType = VK_DESCRIPTOR_TYPE_MAX_ENUM; // Invalid value.
 		write.pImageInfo = nullptr;
 		write.pBufferInfo = nullptr;
 		write.pTexelBufferView = nullptr;
@@ -5919,12 +5919,12 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 					}
 
 					if (texture->usage_flags & TEXTURE_USAGE_STORAGE_BIT) {
-						//can also be used as storage, add to mutable sampled
+						// Can also be used as storage, add to mutable sampled.
 						mutable_sampled_textures.push_back(texture);
 					}
 					if (texture->owner.is_valid()) {
 						texture = texture_owner.get_or_null(texture->owner);
-						ERR_FAIL_COND_V(!texture, RID()); //bug, should never happen
+						ERR_FAIL_COND_V(!texture, RID()); // Bug, should never happen.
 					}
 
 					img_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
@@ -5972,13 +5972,13 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 					}
 
 					if (texture->usage_flags & TEXTURE_USAGE_STORAGE_BIT) {
-						//can also be used as storage, add to mutable sampled
+						// Can also be used as storage, add to mutable sampled.
 						mutable_sampled_textures.push_back(texture);
 					}
 
 					if (texture->owner.is_valid()) {
 						texture = texture_owner.get_or_null(texture->owner);
-						ERR_FAIL_COND_V(!texture, RID()); //bug, should never happen
+						ERR_FAIL_COND_V(!texture, RID()); // Bug, should never happen.
 					}
 
 					img_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
@@ -6020,13 +6020,13 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 					img_info.imageView = texture->view;
 
 					if (texture->usage_flags & TEXTURE_USAGE_SAMPLING_BIT) {
-						//can also be used as storage, add to mutable sampled
+						// Can also be used as storage, add to mutable sampled.
 						mutable_storage_textures.push_back(texture);
 					}
 
 					if (texture->owner.is_valid()) {
 						texture = texture_owner.get_or_null(texture->owner);
-						ERR_FAIL_COND_V(!texture, RID()); //bug, should never happen
+						ERR_FAIL_COND_V(!texture, RID()); // Bug, should never happen.
 					}
 
 					img_info.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
@@ -6116,7 +6116,7 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 				type_size = uniform.get_id_count() / 2;
 			} break;
 			case UNIFORM_TYPE_IMAGE_BUFFER: {
-				//todo
+				// Todo.
 
 			} break;
 			case UNIFORM_TYPE_UNIFORM_BUFFER: {
@@ -6152,7 +6152,7 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 				}
 				ERR_FAIL_COND_V_MSG(!buffer, RID(), "Storage buffer supplied (binding: " + itos(uniform.binding) + ") is invalid.");
 
-				//if 0, then it's sized on link time
+				// If 0, then it's sized on link time.
 				ERR_FAIL_COND_V_MSG(set_uniform.length > 0 && buffer->size != (uint32_t)set_uniform.length, RID(),
 						"Storage buffer supplied (binding: " + itos(uniform.binding) + ") size (" + itos(buffer->size) + " does not match size of shader uniform: (" + itos(set_uniform.length) + ").");
 
@@ -6191,7 +6191,7 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 
 					if (texture->owner.is_valid()) {
 						texture = texture_owner.get_or_null(texture->owner);
-						ERR_FAIL_COND_V(!texture, RID()); //bug, should never happen
+						ERR_FAIL_COND_V(!texture, RID()); // Bug, should never happen.
 					}
 
 					img_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
@@ -6219,7 +6219,7 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 		pool_key.uniform_type[set_uniform.type] += type_size;
 	}
 
-	//need a descriptor pool
+	// Need a descriptor pool.
 	DescriptorPool *pool = _descriptor_pool_allocate(pool_key);
 
 	ERR_FAIL_COND_V(!pool, RID());
@@ -6236,7 +6236,7 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 
 	VkResult res = vkAllocateDescriptorSets(device, &descriptor_set_allocate_info, &descriptor_set);
 	if (res) {
-		_descriptor_pool_free(pool_key, pool); // meh
+		_descriptor_pool_free(pool_key, pool); // Meh.
 		ERR_FAIL_V_MSG(RID(), "Cannot allocate descriptor sets, error " + itos(res) + ".");
 	}
 
@@ -6255,7 +6255,7 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 #ifdef DEV_ENABLED
 	set_resource_name(id, "RID:" + itos(id.get_id()));
 #endif
-	//add dependencies
+	// Add dependencies.
 	_add_dependency(id, p_shader);
 	for (uint32_t i = 0; i < uniform_count; i++) {
 		const Uniform &uniform = uniforms[i];
@@ -6265,7 +6265,7 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 		}
 	}
 
-	//write the contents
+	// Write the contents.
 	if (writes.size()) {
 		for (int i = 0; i < writes.size(); i++) {
 			writes.write[i].dstSet = descriptor_set;
@@ -6298,7 +6298,7 @@ Error RenderingDeviceVulkan::buffer_update(RID p_buffer, uint32_t p_offset, uint
 	VkPipelineStageFlags dst_stage_mask = 0;
 	VkAccessFlags dst_access = 0;
 	if (p_post_barrier & BARRIER_MASK_TRANSFER) {
-		// Protect subsequent updates...
+		// Protect subsequent updates.
 		dst_stage_mask = VK_PIPELINE_STAGE_TRANSFER_BIT;
 		dst_access = VK_ACCESS_TRANSFER_WRITE_BIT;
 	}
@@ -6310,7 +6310,7 @@ Error RenderingDeviceVulkan::buffer_update(RID p_buffer, uint32_t p_offset, uint
 	ERR_FAIL_COND_V_MSG(p_offset + p_size > buffer->size, ERR_INVALID_PARAMETER,
 			"Attempted to write buffer (" + itos((p_offset + p_size) - buffer->size) + " bytes) past the end.");
 
-	// no barrier should be needed here
+	// No barrier should be needed here.
 	// _buffer_memory_barrier(buffer->buffer, p_offset, p_size, dst_stage_mask, VK_PIPELINE_STAGE_TRANSFER_BIT, dst_access, VK_ACCESS_TRANSFER_WRITE_BIT, true);
 
 	Error err = _buffer_update(buffer, p_offset, (uint8_t *)p_data, p_size, p_post_barrier);
@@ -6346,7 +6346,7 @@ Error RenderingDeviceVulkan::buffer_clear(RID p_buffer, uint32_t p_offset, uint3
 	VkPipelineStageFlags dst_stage_mask = 0;
 	VkAccessFlags dst_access = 0;
 	if (p_post_barrier & BARRIER_MASK_TRANSFER) {
-		// Protect subsequent updates...
+		// Protect subsequent updates.
 		dst_stage_mask = VK_PIPELINE_STAGE_TRANSFER_BIT;
 		dst_access = VK_ACCESS_TRANSFER_WRITE_BIT;
 	}
@@ -6359,7 +6359,7 @@ Error RenderingDeviceVulkan::buffer_clear(RID p_buffer, uint32_t p_offset, uint3
 	ERR_FAIL_COND_V_MSG(p_offset + p_size > buffer->size, ERR_INVALID_PARAMETER,
 			"Attempted to write buffer (" + itos((p_offset + p_size) - buffer->size) + " bytes) past the end.");
 
-	// should not be needed
+	// Should not be needed.
 	// _buffer_memory_barrier(buffer->buffer, p_offset, p_size, dst_stage_mask, VK_PIPELINE_STAGE_TRANSFER_BIT, dst_access, VK_ACCESS_TRANSFER_WRITE_BIT, p_post_barrier);
 
 	vkCmdFillBuffer(frames[frame].draw_command_buffer, buffer->buffer, p_offset, p_size, 0);
@@ -6380,10 +6380,10 @@ Error RenderingDeviceVulkan::buffer_clear(RID p_buffer, uint32_t p_offset, uint3
 Vector<uint8_t> RenderingDeviceVulkan::buffer_get_data(RID p_buffer) {
 	_THREAD_SAFE_METHOD_
 
-	// It could be this buffer was just created
+	// It could be this buffer was just created.
 	VkPipelineShaderStageCreateFlags src_stage_mask = VK_PIPELINE_STAGE_TRANSFER_BIT;
 	VkAccessFlags src_access_mask = VK_ACCESS_TRANSFER_WRITE_BIT;
-	// Get the vulkan buffer and the potential stage/access possible
+	// Get the vulkan buffer and the potential stage/access possible.
 	Buffer *buffer = _get_buffer_from_owner(p_buffer, src_stage_mask, src_access_mask, BARRIER_MASK_ALL);
 	if (!buffer) {
 		ERR_FAIL_V_MSG(Vector<uint8_t>(), "Buffer is either invalid or this type of buffer can't be retrieved. Only Index and Vertex buffers allow retrieving.");
@@ -6400,8 +6400,8 @@ Vector<uint8_t> RenderingDeviceVulkan::buffer_get_data(RID p_buffer) {
 	region.srcOffset = 0;
 	region.dstOffset = 0;
 	region.size = buffer->size;
-	vkCmdCopyBuffer(command_buffer, buffer->buffer, tmp_buffer.buffer, 1, &region); //dst buffer is in CPU, but I wonder if src buffer needs a barrier for this..
-	//flush everything so memory can be safely mapped
+	vkCmdCopyBuffer(command_buffer, buffer->buffer, tmp_buffer.buffer, 1, &region); // Dst buffer is in CPU, but I wonder if src buffer needs a barrier for this.
+	// Flush everything so memory can be safely mapped.
 	_flush(true);
 
 	void *buffer_mem;
@@ -6429,7 +6429,7 @@ Vector<uint8_t> RenderingDeviceVulkan::buffer_get_data(RID p_buffer) {
 RID RenderingDeviceVulkan::render_pipeline_create(RID p_shader, FramebufferFormatID p_framebuffer_format, VertexFormatID p_vertex_format, RenderPrimitive p_render_primitive, const PipelineRasterizationState &p_rasterization_state, const PipelineMultisampleState &p_multisample_state, const PipelineDepthStencilState &p_depth_stencil_state, const PipelineColorBlendState &p_blend_state, int p_dynamic_state_flags, uint32_t p_for_render_pass, const Vector<PipelineSpecializationConstant> &p_specialization_constants) {
 	_THREAD_SAFE_METHOD_
 
-	//needs a shader
+	// Needs a shader.
 	Shader *shader = shader_owner.get_or_null(p_shader);
 	ERR_FAIL_COND_V(!shader, RID());
 
@@ -6437,13 +6437,13 @@ RID RenderingDeviceVulkan::render_pipeline_create(RID p_shader, FramebufferForma
 			"Compute shaders can't be used in render pipelines");
 
 	if (p_framebuffer_format == INVALID_ID) {
-		//if nothing provided, use an empty one (no attachments)
+		// If nothing provided, use an empty one (no attachments).
 		p_framebuffer_format = framebuffer_format_create(Vector<AttachmentFormat>());
 	}
 	ERR_FAIL_COND_V(!framebuffer_formats.has(p_framebuffer_format), RID());
 	const FramebufferFormat &fb_format = framebuffer_formats[p_framebuffer_format];
 
-	{ //validate shader vs framebuffer
+	{ // Validate shader vs framebuffer.
 
 		ERR_FAIL_COND_V_MSG(p_for_render_pass >= uint32_t(fb_format.E->key().passes.size()), RID(), "Render pass requested for pipeline creation (" + itos(p_for_render_pass) + ") is out of bounds");
 		const FramebufferPass &pass = fb_format.E->key().passes[p_for_render_pass];
@@ -6456,17 +6456,17 @@ RID RenderingDeviceVulkan::render_pipeline_create(RID p_shader, FramebufferForma
 		ERR_FAIL_COND_V_MSG(shader->fragment_output_mask != output_mask, RID(),
 				"Mismatch fragment shader output mask (" + itos(shader->fragment_output_mask) + ") and framebuffer color output mask (" + itos(output_mask) + ") when binding both in render pipeline.");
 	}
-	//vertex
+	// Vertex.
 	VkPipelineVertexInputStateCreateInfo pipeline_vertex_input_state_create_info;
 
 	if (p_vertex_format != INVALID_ID) {
-		//uses vertices, else it does not
+		// Uses vertices, else it does not.
 		ERR_FAIL_COND_V(!vertex_formats.has(p_vertex_format), RID());
 		const VertexDescriptionCache &vd = vertex_formats[p_vertex_format];
 
 		pipeline_vertex_input_state_create_info = vd.create_info;
 
-		//validate with inputs
+		// Validate with inputs.
 		for (uint32_t i = 0; i < 32; i++) {
 			if (!(shader->vertex_input_mask & (1UL << i))) {
 				continue;
@@ -6483,7 +6483,7 @@ RID RenderingDeviceVulkan::render_pipeline_create(RID p_shader, FramebufferForma
 		}
 
 	} else {
-		//does not use vertices
+		// Does not use vertices.
 		pipeline_vertex_input_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
 		pipeline_vertex_input_state_create_info.pNext = nullptr;
 		pipeline_vertex_input_state_create_info.flags = 0;
@@ -6495,7 +6495,7 @@ RID RenderingDeviceVulkan::render_pipeline_create(RID p_shader, FramebufferForma
 		ERR_FAIL_COND_V_MSG(shader->vertex_input_mask != 0, RID(),
 				"Shader contains vertex inputs, but no vertex input description was provided for pipeline creation.");
 	}
-	//input assembly
+	// Input assembly.
 
 	ERR_FAIL_INDEX_V(p_render_primitive, RENDER_PRIMITIVE_MAX, RID());
 
@@ -6521,7 +6521,7 @@ RID RenderingDeviceVulkan::render_pipeline_create(RID p_shader, FramebufferForma
 	input_assembly_create_info.topology = topology_list[p_render_primitive];
 	input_assembly_create_info.primitiveRestartEnable = (p_render_primitive == RENDER_PRIMITIVE_TRIANGLE_STRIPS_WITH_RESTART_INDEX);
 
-	//tessellation
+	// Tessellation.
 	VkPipelineTessellationStateCreateInfo tessellation_create_info;
 	tessellation_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO;
 	tessellation_create_info.pNext = nullptr;
@@ -6533,12 +6533,12 @@ RID RenderingDeviceVulkan::render_pipeline_create(RID p_shader, FramebufferForma
 	viewport_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
 	viewport_state_create_info.pNext = nullptr;
 	viewport_state_create_info.flags = 0;
-	viewport_state_create_info.viewportCount = 1; //if VR extensions are supported at some point, this will have to be customizable in the framebuffer format
+	viewport_state_create_info.viewportCount = 1; // If VR extensions are supported at some point, this will have to be customizable in the framebuffer format.
 	viewport_state_create_info.pViewports = nullptr;
 	viewport_state_create_info.scissorCount = 1;
 	viewport_state_create_info.pScissors = nullptr;
 
-	//rasterization
+	// Rasterization.
 	VkPipelineRasterizationStateCreateInfo rasterization_state_create_info;
 	rasterization_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
 	rasterization_state_create_info.pNext = nullptr;
@@ -6561,7 +6561,7 @@ RID RenderingDeviceVulkan::render_pipeline_create(RID p_shader, FramebufferForma
 	rasterization_state_create_info.depthBiasSlopeFactor = p_rasterization_state.depth_bias_slope_factor;
 	rasterization_state_create_info.lineWidth = p_rasterization_state.line_width;
 
-	//multisample
+	// Multisample.
 	VkPipelineMultisampleStateCreateInfo multisample_state_create_info;
 	multisample_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
 	multisample_state_create_info.pNext = nullptr;
@@ -6572,7 +6572,7 @@ RID RenderingDeviceVulkan::render_pipeline_create(RID p_shader, FramebufferForma
 	multisample_state_create_info.minSampleShading = p_multisample_state.min_sample_shading;
 	Vector<VkSampleMask> sample_mask;
 	if (p_multisample_state.sample_mask.size()) {
-		//use sample mask
+		// Use sample mask.
 		const int rasterization_sample_mask_expected_size[TEXTURE_SAMPLES_MAX] = {
 			1, 2, 4, 8, 16, 32, 64
 		};
@@ -6590,7 +6590,7 @@ RID RenderingDeviceVulkan::render_pipeline_create(RID p_shader, FramebufferForma
 	multisample_state_create_info.alphaToCoverageEnable = p_multisample_state.enable_alpha_to_coverage;
 	multisample_state_create_info.alphaToOneEnable = p_multisample_state.enable_alpha_to_one;
 
-	//depth stencil
+	// Depth stencil.
 
 	VkPipelineDepthStencilStateCreateInfo depth_stencil_state_create_info;
 	depth_stencil_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
@@ -6630,7 +6630,7 @@ RID RenderingDeviceVulkan::render_pipeline_create(RID p_shader, FramebufferForma
 	depth_stencil_state_create_info.minDepthBounds = p_depth_stencil_state.depth_range_min;
 	depth_stencil_state_create_info.maxDepthBounds = p_depth_stencil_state.depth_range_max;
 
-	//blend state
+	// Blend state.
 	VkPipelineColorBlendStateCreateInfo color_blend_state_create_info;
 	color_blend_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
 	color_blend_state_create_info.pNext = nullptr;
@@ -6701,15 +6701,15 @@ RID RenderingDeviceVulkan::render_pipeline_create(RID p_shader, FramebufferForma
 	color_blend_state_create_info.blendConstants[2] = p_blend_state.blend_constant.b;
 	color_blend_state_create_info.blendConstants[3] = p_blend_state.blend_constant.a;
 
-	//dynamic state
+	// Dynamic state.
 
 	VkPipelineDynamicStateCreateInfo dynamic_state_create_info;
 	dynamic_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
 	dynamic_state_create_info.pNext = nullptr;
 	dynamic_state_create_info.flags = 0;
-	Vector<VkDynamicState> dynamic_states; //vulkan is weird..
+	Vector<VkDynamicState> dynamic_states; // Vulkan is weird.
 
-	dynamic_states.push_back(VK_DYNAMIC_STATE_VIEWPORT); //viewport and scissor are always dynamic
+	dynamic_states.push_back(VK_DYNAMIC_STATE_VIEWPORT); // Viewport and scissor are always dynamic.
 	dynamic_states.push_back(VK_DYNAMIC_STATE_SCISSOR);
 
 	if (p_dynamic_state_flags & DYNAMIC_STATE_LINE_WIDTH) {
@@ -6748,19 +6748,19 @@ RID RenderingDeviceVulkan::render_pipeline_create(RID p_shader, FramebufferForma
 	VkPipelineFragmentShadingRateStateCreateInfoKHR vrs_create_info;
 	if (context->get_vrs_capabilities().attachment_vrs_supported) {
 		// If VRS is used, this defines how the different VRS types are combined.
-		// combinerOps[0] decides how we use the output of pipeline and primitive (drawcall) VRS
-		// combinerOps[1] decides how we use the output of combinerOps[0] and our attachment VRS
+		// combinerOps[0] decides how we use the output of pipeline and primitive (drawcall) VRS.
+		// combinerOps[1] decides how we use the output of combinerOps[0] and our attachment VRS.
 
 		vrs_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR;
 		vrs_create_info.pNext = nullptr;
 		vrs_create_info.fragmentSize = { 4, 4 };
-		vrs_create_info.combinerOps[0] = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR; // We don't use pipeline/primitive VRS so this really doesn't matter
-		vrs_create_info.combinerOps[1] = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR; // always use the outcome of attachment VRS if enabled
+		vrs_create_info.combinerOps[0] = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR; // We don't use pipeline/primitive VRS so this really doesn't matter.
+		vrs_create_info.combinerOps[1] = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR; // Always use the outcome of attachment VRS if enabled.
 
 		graphics_pipeline_nextptr = &vrs_create_info;
 	}
 
-	//finally, pipeline create info
+	// Finally, pipeline create info.
 	VkGraphicsPipelineCreateInfo graphics_pipeline_create_info;
 
 	graphics_pipeline_create_info.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
@@ -6778,9 +6778,9 @@ RID RenderingDeviceVulkan::render_pipeline_create(RID p_shader, FramebufferForma
 		specialization_info.resize(pipeline_stages.size());
 		specialization_map_entries.resize(pipeline_stages.size());
 		for (int i = 0; i < shader->specialization_constants.size(); i++) {
-			//see if overridden
+			// See if overridden.
 			const Shader::SpecializationConstant &sc = shader->specialization_constants[i];
-			data_ptr[i] = sc.constant.int_value; //just copy the 32 bits
+			data_ptr[i] = sc.constant.int_value; // Just copy the 32 bits.
 
 			for (int j = 0; j < p_specialization_constants.size(); j++) {
 				const PipelineSpecializationConstant &psc = p_specialization_constants[j];
@@ -6875,12 +6875,12 @@ RID RenderingDeviceVulkan::render_pipeline_create(RID p_shader, FramebufferForma
 	};
 	pipeline.validation.primitive_minimum = primitive_minimum[p_render_primitive];
 #endif
-	//create ID to associate with this pipeline
+	// Create ID to associate with this pipeline.
 	RID id = render_pipeline_owner.make_rid(pipeline);
 #ifdef DEV_ENABLED
 	set_resource_name(id, "RID:" + itos(id.get_id()));
 #endif
-	//now add all the dependencies
+	// Now add all the dependencies.
 	_add_dependency(id, p_shader);
 	return id;
 }
@@ -6897,14 +6897,14 @@ bool RenderingDeviceVulkan::render_pipeline_is_valid(RID p_pipeline) {
 RID RenderingDeviceVulkan::compute_pipeline_create(RID p_shader, const Vector<PipelineSpecializationConstant> &p_specialization_constants) {
 	_THREAD_SAFE_METHOD_
 
-	//needs a shader
+	// Needs a shader.
 	Shader *shader = shader_owner.get_or_null(p_shader);
 	ERR_FAIL_COND_V(!shader, RID());
 
 	ERR_FAIL_COND_V_MSG(!shader->is_compute, RID(),
 			"Non-compute shaders can't be used in compute pipelines");
 
-	//finally, pipeline create info
+	// Finally, pipeline create info.
 	VkComputePipelineCreateInfo compute_pipeline_create_info;
 
 	compute_pipeline_create_info.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
@@ -6924,9 +6924,9 @@ RID RenderingDeviceVulkan::compute_pipeline_create(RID p_shader, const Vector<Pi
 		specialization_constant_data.resize(shader->specialization_constants.size());
 		uint32_t *data_ptr = specialization_constant_data.ptrw();
 		for (int i = 0; i < shader->specialization_constants.size(); i++) {
-			//see if overridden
+			// See if overridden.
 			const Shader::SpecializationConstant &sc = shader->specialization_constants[i];
-			data_ptr[i] = sc.constant.int_value; //just copy the 32 bits
+			data_ptr[i] = sc.constant.int_value; // Just copy the 32 bits.
 
 			for (int j = 0; j < p_specialization_constants.size(); j++) {
 				const PipelineSpecializationConstant &psc = p_specialization_constants[j];
@@ -6967,12 +6967,12 @@ RID RenderingDeviceVulkan::compute_pipeline_create(RID p_shader, const Vector<Pi
 	pipeline.local_group_size[1] = shader->compute_local_size[1];
 	pipeline.local_group_size[2] = shader->compute_local_size[2];
 
-	//create ID to associate with this pipeline
+	// Create ID to associate with this pipeline.
 	RID id = compute_pipeline_owner.make_rid(pipeline);
 #ifdef DEV_ENABLED
 	set_resource_name(id, "RID:" + itos(id.get_id()));
 #endif
-	//now add all the dependencies
+	// Now add all the dependencies.
 	_add_dependency(id, p_shader);
 	return id;
 }
@@ -7002,7 +7002,7 @@ RenderingDevice::FramebufferFormatID RenderingDeviceVulkan::screen_get_framebuff
 	_THREAD_SAFE_METHOD_
 	ERR_FAIL_COND_V_MSG(local_device.is_valid(), INVALID_ID, "Local devices have no screen");
 
-	//very hacky, but not used often per frame so I guess ok
+	// Very hacky, but not used often per frame so I guess ok.
 	VkFormat vkformat = context->get_screen_format();
 	DataFormat format = DATA_FORMAT_MAX;
 	for (int i = 0; i < DATA_FORMAT_MAX; i++) {
@@ -7104,7 +7104,7 @@ Error RenderingDeviceVulkan::_draw_list_setup_framebuffer(Framebuffer *p_framebu
 	vk.view_count = p_framebuffer->view_count;
 
 	if (!p_framebuffer->framebuffers.has(vk)) {
-		//need to create this version
+		// Need to create this version.
 		Framebuffer::Version version;
 
 		version.render_pass = _render_pass_create(framebuffer_formats[p_framebuffer->format_id].E->key().attachments, framebuffer_formats[p_framebuffer->format_id].E->key().passes, p_initial_color_action, p_final_color_action, p_initial_depth_action, p_final_depth_action, p_framebuffer->view_count);
@@ -7180,7 +7180,7 @@ Error RenderingDeviceVulkan::_draw_list_render_pass_begin(Framebuffer *framebuff
 			}
 
 			if (color_index < p_clear_colors.size() && texture->usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT) {
-				ERR_FAIL_INDEX_V(color_index, p_clear_colors.size(), ERR_BUG); //a bug
+				ERR_FAIL_INDEX_V(color_index, p_clear_colors.size(), ERR_BUG); // A bug.
 				Color clear_color = p_clear_colors[color_index];
 				clear_value.color.float32[0] = clear_color.r;
 				clear_value.color.float32[1] = clear_color.g;
@@ -7211,7 +7211,7 @@ Error RenderingDeviceVulkan::_draw_list_render_pass_begin(Framebuffer *framebuff
 		ERR_CONTINUE_MSG(!(texture->usage_flags & TEXTURE_USAGE_STORAGE_BIT), "Supplied storage texture " + itos(i) + " for draw list is not set to be used for storage.");
 
 		if (texture->usage_flags & TEXTURE_USAGE_SAMPLING_BIT) {
-			//must change layout to general
+			// Must change layout to general.
 			VkImageMemoryBarrier image_memory_barrier;
 			image_memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
 			image_memory_barrier.pNext = nullptr;
@@ -7239,7 +7239,7 @@ Error RenderingDeviceVulkan::_draw_list_render_pass_begin(Framebuffer *framebuff
 
 	vkCmdBeginRenderPass(command_buffer, &render_pass_begin, subpass_contents);
 
-	//mark textures as bound
+	// Mark textures as bound.
 	draw_list_bound_textures.clear();
 	draw_list_unbind_color_textures = p_final_color_action != FINAL_ACTION_CONTINUE;
 	draw_list_unbind_depth_textures = p_final_depth_action != FINAL_ACTION_CONTINUE;
@@ -7316,7 +7316,7 @@ RenderingDevice::DrawListID RenderingDeviceVulkan::draw_list_begin(RID p_framebu
 	bool needs_clear_color = false;
 	bool needs_clear_depth = false;
 
-	if (p_region != Rect2() && p_region != Rect2(Vector2(), viewport_size)) { //check custom region
+	if (p_region != Rect2() && p_region != Rect2(Vector2(), viewport_size)) { // Check custom region.
 		Rect2i viewport(viewport_offset, viewport_size);
 		Rect2i regioni = p_region;
 		if (!(regioni.position.x >= viewport.position.x) && (regioni.position.y >= viewport.position.y) &&
@@ -7345,13 +7345,13 @@ RenderingDevice::DrawListID RenderingDeviceVulkan::draw_list_begin(RID p_framebu
 		}
 	}
 
-	if (p_initial_color_action == INITIAL_ACTION_CLEAR || needs_clear_color) { //check clear values
+	if (p_initial_color_action == INITIAL_ACTION_CLEAR || needs_clear_color) { // Check clear values.
 		int color_count = 0;
 		for (int i = 0; i < framebuffer->texture_ids.size(); i++) {
 			Texture *texture = texture_owner.get_or_null(framebuffer->texture_ids[i]);
 			// We only check for our VRS usage bit if this is not the first texture id.
 			// If it is the first we're likely populating our VRS texture.
-			// Bit dirty but..
+			// Bit dirty but...
 			if (!texture || (!(texture->usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) && !(i != 0 && texture->usage_flags & TEXTURE_USAGE_VRS_ATTACHMENT_BIT))) {
 				color_count++;
 			}
@@ -7423,7 +7423,7 @@ Error RenderingDeviceVulkan::draw_list_begin_split(RID p_framebuffer, uint32_t p
 	bool needs_clear_color = false;
 	bool needs_clear_depth = false;
 
-	if (p_region != Rect2() && p_region != Rect2(Vector2(), viewport_size)) { //check custom region
+	if (p_region != Rect2() && p_region != Rect2(Vector2(), viewport_size)) { // Check custom region.
 		Rect2i viewport(viewport_offset, viewport_size);
 		Rect2i regioni = p_region;
 		if (!(regioni.position.x >= viewport.position.x) && (regioni.position.y >= viewport.position.y) &&
@@ -7445,7 +7445,7 @@ Error RenderingDeviceVulkan::draw_list_begin_split(RID p_framebuffer, uint32_t p
 		}
 	}
 
-	if (p_initial_color_action == INITIAL_ACTION_CLEAR || needs_clear_color) { //check clear values
+	if (p_initial_color_action == INITIAL_ACTION_CLEAR || needs_clear_color) { // Check clear values.
 
 		int color_count = 0;
 		for (int i = 0; i < framebuffer->texture_ids.size(); i++) {
@@ -7531,7 +7531,7 @@ RenderingDeviceVulkan::DrawList *RenderingDeviceVulkan::_get_draw_list_ptr(DrawL
 			return nullptr;
 		}
 
-		uint64_t index = p_id & ((DrawListID(1) << DrawListID(ID_BASE_SHIFT)) - 1); //mask
+		uint64_t index = p_id & ((DrawListID(1) << DrawListID(ID_BASE_SHIFT)) - 1); // Mask.
 
 		if (index >= draw_list_count) {
 			return nullptr;
@@ -7557,7 +7557,7 @@ void RenderingDeviceVulkan::draw_list_bind_render_pipeline(DrawListID p_list, RI
 #endif
 
 	if (p_render_pipeline == dl->state.pipeline) {
-		return; //redundant state, return.
+		return; // Redundant state, return.
 	}
 
 	dl->state.pipeline = p_render_pipeline;
@@ -7566,17 +7566,17 @@ void RenderingDeviceVulkan::draw_list_bind_render_pipeline(DrawListID p_list, RI
 	vkCmdBindPipeline(dl->command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->pipeline);
 
 	if (dl->state.pipeline_shader != pipeline->shader) {
-		// shader changed, so descriptor sets may become incompatible.
+		// Shader changed, so descriptor sets may become incompatible.
 
-		//go through ALL sets, and unbind them (and all those above) if the format is different
+		// Go through ALL sets, and unbind them (and all those above) if the format is different.
 
-		uint32_t pcount = pipeline->set_formats.size(); //formats count in this pipeline
+		uint32_t pcount = pipeline->set_formats.size(); // Formats count in this pipeline.
 		dl->state.set_count = MAX(dl->state.set_count, pcount);
-		const uint32_t *pformats = pipeline->set_formats.ptr(); //pipeline set formats
+		const uint32_t *pformats = pipeline->set_formats.ptr(); // Pipeline set formats.
 
-		bool sets_valid = true; //once invalid, all above become invalid
+		bool sets_valid = true; // Once invalid, all above become invalid.
 		for (uint32_t i = 0; i < pcount; i++) {
-			//if a part of the format is different, invalidate it (and the rest)
+			// If a part of the format is different, invalidate it (and the rest).
 			if (!sets_valid || dl->state.sets[i].pipeline_expected_format != pformats[i]) {
 				dl->state.sets[i].bound = false;
 				dl->state.sets[i].pipeline_expected_format = pformats[i];
@@ -7585,11 +7585,11 @@ void RenderingDeviceVulkan::draw_list_bind_render_pipeline(DrawListID p_list, RI
 		}
 
 		for (uint32_t i = pcount; i < dl->state.set_count; i++) {
-			//unbind the ones above (not used) if exist
+			// Unbind the ones above (not used) if exist.
 			dl->state.sets[i].bound = false;
 		}
 
-		dl->state.set_count = pcount; //update set count
+		dl->state.set_count = pcount; // Update set count.
 
 		if (pipeline->push_constant_size) {
 			dl->state.pipeline_push_constant_stages = pipeline->push_constant_stages;
@@ -7602,7 +7602,7 @@ void RenderingDeviceVulkan::draw_list_bind_render_pipeline(DrawListID p_list, RI
 	}
 
 #ifdef DEBUG_ENABLED
-	//update render pass pipeline info
+	// Update render pass pipeline info.
 	dl->validation.pipeline_active = true;
 	dl->validation.pipeline_dynamic_state = pipeline->validation.dynamic_state;
 	dl->validation.pipeline_vertex_format = pipeline->validation.vertex_format;
@@ -7632,8 +7632,8 @@ void RenderingDeviceVulkan::draw_list_bind_uniform_set(DrawListID p_list, RID p_
 		dl->state.set_count = p_index;
 	}
 
-	dl->state.sets[p_index].descriptor_set = uniform_set->descriptor_set; //update set pointer
-	dl->state.sets[p_index].bound = false; //needs rebind
+	dl->state.sets[p_index].descriptor_set = uniform_set->descriptor_set; // Update set pointer.
+	dl->state.sets[p_index].bound = false; // Needs rebind.
 	dl->state.sets[p_index].uniform_set_format = uniform_set->format;
 	dl->state.sets[p_index].uniform_set = p_uniform_set;
 
@@ -7651,7 +7651,7 @@ void RenderingDeviceVulkan::draw_list_bind_uniform_set(DrawListID p_list, RID p_
 	}
 
 #ifdef DEBUG_ENABLED
-	{ //validate that textures bound are not attached as framebuffer bindings
+	{ // Validate that textures bound are not attached as framebuffer bindings.
 		uint32_t attachable_count = uniform_set->attachable_textures.size();
 		const UniformSet::AttachableTexture *attachable_ptr = uniform_set->attachable_textures.ptr();
 		uint32_t bound_count = draw_list_bound_textures.size();
@@ -7677,7 +7677,7 @@ void RenderingDeviceVulkan::draw_list_bind_vertex_array(DrawListID p_list, RID p
 	ERR_FAIL_COND(!vertex_array);
 
 	if (dl->state.vertex_array == p_vertex_array) {
-		return; //already set
+		return; // Already set.
 	}
 
 	dl->state.vertex_array = p_vertex_array;
@@ -7701,7 +7701,7 @@ void RenderingDeviceVulkan::draw_list_bind_index_array(DrawListID p_list, RID p_
 	ERR_FAIL_COND(!index_array);
 
 	if (dl->state.index_array == p_index_array) {
-		return; //already set
+		return; // Already set.
 	}
 
 	dl->state.index_array = p_index_array;
@@ -7753,30 +7753,30 @@ void RenderingDeviceVulkan::draw_list_draw(DrawListID p_list, bool p_use_indices
 	ERR_FAIL_COND_MSG(!dl->validation.pipeline_active,
 			"No render pipeline was set before attempting to draw.");
 	if (dl->validation.pipeline_vertex_format != INVALID_ID) {
-		//pipeline uses vertices, validate format
+		// Pipeline uses vertices, validate format.
 		ERR_FAIL_COND_MSG(dl->validation.vertex_format == INVALID_ID,
 				"No vertex array was bound, and render pipeline expects vertices.");
-		//make sure format is right
+		// Make sure format is right.
 		ERR_FAIL_COND_MSG(dl->validation.pipeline_vertex_format != dl->validation.vertex_format,
 				"The vertex format used to create the pipeline does not match the vertex format bound.");
-		//make sure number of instances is valid
+		// Make sure number of instances is valid.
 		ERR_FAIL_COND_MSG(p_instances > dl->validation.vertex_max_instances_allowed,
 				"Number of instances requested (" + itos(p_instances) + " is larger than the maximum number supported by the bound vertex array (" + itos(dl->validation.vertex_max_instances_allowed) + ").");
 	}
 
 	if (dl->validation.pipeline_push_constant_size > 0) {
-		//using push constants, check that they were supplied
+		// Using push constants, check that they were supplied.
 		ERR_FAIL_COND_MSG(!dl->validation.pipeline_push_constant_supplied,
 				"The shader in this pipeline requires a push constant to be set before drawing, but it's not present.");
 	}
 
 #endif
 
-	//Bind descriptor sets
+	// Bind descriptor sets.
 
 	for (uint32_t i = 0; i < dl->state.set_count; i++) {
 		if (dl->state.sets[i].pipeline_expected_format == 0) {
-			continue; //nothing expected by this pipeline
+			continue; // Nothing expected by this pipeline.
 		}
 #ifdef DEBUG_ENABLED
 		if (dl->state.sets[i].pipeline_expected_format != dl->state.sets[i].uniform_set_format) {
@@ -7791,7 +7791,7 @@ void RenderingDeviceVulkan::draw_list_draw(DrawListID p_list, bool p_use_indices
 		}
 #endif
 		if (!dl->state.sets[i].bound) {
-			//All good, see if this requires re-binding
+			// All good, see if this requires re-binding.
 			vkCmdBindDescriptorSets(dl->command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, dl->state.pipeline_layout, i, 1, &dl->state.sets[i].descriptor_set, 0, nullptr);
 			dl->state.sets[i].bound = true;
 		}
@@ -7806,7 +7806,7 @@ void RenderingDeviceVulkan::draw_list_draw(DrawListID p_list, bool p_use_indices
 				"Draw command requested indices, but no index buffer was set.");
 
 		if (dl->validation.pipeline_vertex_format != INVALID_ID) {
-			//uses vertices, do some vertex validations
+			// Uses vertices, do some vertex validations.
 			ERR_FAIL_COND_MSG(dl->validation.vertex_array_size < dl->validation.index_array_max_index,
 					"Index array references (max index: " + itos(dl->validation.index_array_max_index) + ") indices beyond the vertex array size (" + itos(dl->validation.vertex_array_size) + ").");
 		}
@@ -7932,7 +7932,7 @@ Error RenderingDeviceVulkan::draw_list_switch_to_next_pass_split(uint32_t p_spli
 }
 
 Error RenderingDeviceVulkan::_draw_list_allocate(const Rect2i &p_viewport, uint32_t p_splits, uint32_t p_subpass) {
-	// Lock while draw_list is active
+	// Lock while draw_list is active.
 	_THREAD_SAFE_LOCK_
 
 	if (p_splits == 0) {
@@ -7959,7 +7959,7 @@ Error RenderingDeviceVulkan::_draw_list_allocate(const Rect2i &p_viewport, uint3
 					VkCommandBuffer command_buffer;
 
 					VkCommandBufferAllocateInfo cmdbuf;
-					//no command buffer exists, create it.
+					// No command buffer exists, create it.
 					cmdbuf.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
 					cmdbuf.pNext = nullptr;
 					cmdbuf.commandPool = split_draw_list_allocators[i].command_pool;
@@ -7978,7 +7978,7 @@ Error RenderingDeviceVulkan::_draw_list_allocate(const Rect2i &p_viewport, uint3
 		draw_list_split = true;
 
 		for (uint32_t i = 0; i < p_splits; i++) {
-			//take a command buffer and initialize it
+			// Take a command buffer and initialize it.
 			VkCommandBuffer command_buffer = split_draw_list_allocators[i].command_buffers[frame];
 
 			VkCommandBufferInheritanceInfo inheritance_info;
@@ -7988,7 +7988,7 @@ Error RenderingDeviceVulkan::_draw_list_allocate(const Rect2i &p_viewport, uint3
 			inheritance_info.subpass = p_subpass;
 			inheritance_info.framebuffer = draw_list_vkframebuffer;
 			inheritance_info.occlusionQueryEnable = false;
-			inheritance_info.queryFlags = 0; //?
+			inheritance_info.queryFlags = 0; // ?
 			inheritance_info.pipelineStatistics = 0;
 
 			VkCommandBufferBeginInfo cmdbuf_begin;
@@ -8021,7 +8021,7 @@ Error RenderingDeviceVulkan::_draw_list_allocate(const Rect2i &p_viewport, uint3
 
 void RenderingDeviceVulkan::_draw_list_free(Rect2i *r_last_viewport) {
 	if (draw_list_split) {
-		//send all command buffers
+		// Send all command buffers.
 		VkCommandBuffer *command_buffers = (VkCommandBuffer *)alloca(sizeof(VkCommandBuffer) * draw_list_count);
 		for (uint32_t i = 0; i < draw_list_count; i++) {
 			vkEndCommandBuffer(draw_list[i].command_buffer);
@@ -8041,12 +8041,12 @@ void RenderingDeviceVulkan::_draw_list_free(Rect2i *r_last_viewport) {
 		if (r_last_viewport) {
 			*r_last_viewport = draw_list->viewport;
 		}
-		//just end the list
+		// Just end the list.
 		memdelete(draw_list);
 		draw_list = nullptr;
 	}
 
-	// draw_list is no longer active
+	// Draw_list is no longer active.
 	_THREAD_SAFE_UNLOCK_
 }
 
@@ -8061,7 +8061,7 @@ void RenderingDeviceVulkan::draw_list_end(uint32_t p_post_barrier) {
 
 	for (int i = 0; i < draw_list_bound_textures.size(); i++) {
 		Texture *texture = texture_owner.get_or_null(draw_list_bound_textures[i]);
-		ERR_CONTINUE(!texture); //wtf
+		ERR_CONTINUE(!texture); // Wtf.
 		if (draw_list_unbind_color_textures && (texture->usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT)) {
 			texture->bound = false;
 		}
@@ -8133,8 +8133,8 @@ void RenderingDeviceVulkan::draw_list_end(uint32_t p_post_barrier) {
 	draw_list_storage_textures.clear();
 
 	// To ensure proper synchronization, we must make sure rendering is done before:
-	//  * Some buffer is copied
-	//  * Another render pass happens (since we may be done)
+	// * Some buffer is copied.
+	// * Another render pass happens (since we may be done).
 
 	VkMemoryBarrier mem_barrier;
 	mem_barrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
@@ -8159,7 +8159,7 @@ RenderingDevice::ComputeListID RenderingDeviceVulkan::compute_list_begin(bool p_
 	ERR_FAIL_COND_V_MSG(!p_allow_draw_overlap && draw_list != nullptr, INVALID_ID, "Only one draw list can be active at the same time.");
 	ERR_FAIL_COND_V_MSG(compute_list != nullptr, INVALID_ID, "Only one draw/compute list can be active at the same time.");
 
-	// Lock while compute_list is active
+	// Lock while compute_list is active.
 	_THREAD_SAFE_LOCK_
 
 	compute_list = memnew(ComputeList);
@@ -8179,7 +8179,7 @@ void RenderingDeviceVulkan::compute_list_bind_compute_pipeline(ComputeListID p_l
 	ERR_FAIL_COND(!pipeline);
 
 	if (p_compute_pipeline == cl->state.pipeline) {
-		return; //redundant state, return.
+		return; // Redundant state, return.
 	}
 
 	cl->state.pipeline = p_compute_pipeline;
@@ -8188,17 +8188,17 @@ void RenderingDeviceVulkan::compute_list_bind_compute_pipeline(ComputeListID p_l
 	vkCmdBindPipeline(cl->command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline->pipeline);
 
 	if (cl->state.pipeline_shader != pipeline->shader) {
-		// shader changed, so descriptor sets may become incompatible.
+		// Shader changed, so descriptor sets may become incompatible.
 
-		//go through ALL sets, and unbind them (and all those above) if the format is different
+		// Go through ALL sets, and unbind them (and all those above) if the format is different.
 
-		uint32_t pcount = pipeline->set_formats.size(); //formats count in this pipeline
+		uint32_t pcount = pipeline->set_formats.size(); // Formats count in this pipeline.
 		cl->state.set_count = MAX(cl->state.set_count, pcount);
-		const uint32_t *pformats = pipeline->set_formats.ptr(); //pipeline set formats
+		const uint32_t *pformats = pipeline->set_formats.ptr(); // Pipeline set formats.
 
-		bool sets_valid = true; //once invalid, all above become invalid
+		bool sets_valid = true; // Once invalid, all above become invalid.
 		for (uint32_t i = 0; i < pcount; i++) {
-			//if a part of the format is different, invalidate it (and the rest)
+			// If a part of the format is different, invalidate it (and the rest).
 			if (!sets_valid || cl->state.sets[i].pipeline_expected_format != pformats[i]) {
 				cl->state.sets[i].bound = false;
 				cl->state.sets[i].pipeline_expected_format = pformats[i];
@@ -8207,11 +8207,11 @@ void RenderingDeviceVulkan::compute_list_bind_compute_pipeline(ComputeListID p_l
 		}
 
 		for (uint32_t i = pcount; i < cl->state.set_count; i++) {
-			//unbind the ones above (not used) if exist
+			// Unbind the ones above (not used) if exist.
 			cl->state.sets[i].bound = false;
 		}
 
-		cl->state.set_count = pcount; //update set count
+		cl->state.set_count = pcount; // Update set count.
 
 		if (pipeline->push_constant_size) {
 			cl->state.pipeline_push_constant_stages = pipeline->push_constant_stages;
@@ -8227,7 +8227,7 @@ void RenderingDeviceVulkan::compute_list_bind_compute_pipeline(ComputeListID p_l
 	}
 
 #ifdef DEBUG_ENABLED
-	//update compute pass pipeline info
+	// Update compute pass pipeline info.
 	cl->validation.pipeline_active = true;
 	cl->validation.pipeline_push_constant_size = pipeline->push_constant_size;
 #endif
@@ -8255,8 +8255,8 @@ void RenderingDeviceVulkan::compute_list_bind_uniform_set(ComputeListID p_list,
 		cl->state.set_count = p_index;
 	}
 
-	cl->state.sets[p_index].descriptor_set = uniform_set->descriptor_set; //update set pointer
-	cl->state.sets[p_index].bound = false; //needs rebind
+	cl->state.sets[p_index].descriptor_set = uniform_set->descriptor_set; // Update set pointer.
+	cl->state.sets[p_index].bound = false; // Needs rebind.
 	cl->state.sets[p_index].uniform_set_format = uniform_set->format;
 	cl->state.sets[p_index].uniform_set = p_uniform_set;
 
@@ -8359,7 +8359,7 @@ void RenderingDeviceVulkan::compute_list_bind_uniform_set(ComputeListID p_list,
 
 			textures_to_storage[i]->layout = VK_IMAGE_LAYOUT_GENERAL;
 
-			cl->state.textures_to_sampled_layout.insert(textures_to_storage[i]); //needs to go back to sampled layout afterwards
+			cl->state.textures_to_sampled_layout.insert(textures_to_storage[i]); // Needs to go back to sampled layout afterwards.
 		}
 	}
 
@@ -8372,7 +8372,7 @@ void RenderingDeviceVulkan::compute_list_bind_uniform_set(ComputeListID p_list,
 	}
 
 #if 0
-	{ //validate that textures bound are not attached as framebuffer bindings
+	{ // Validate that textures bound are not attached as framebuffer bindings.
 		uint32_t attachable_count = uniform_set->attachable_textures.size();
 		const RID *attachable_ptr = uniform_set->attachable_textures.ptr();
 		uint32_t bound_count = draw_list_bound_textures.size();
@@ -8432,18 +8432,18 @@ void RenderingDeviceVulkan::compute_list_dispatch(ComputeListID p_list, uint32_t
 	ERR_FAIL_COND_MSG(!cl->validation.pipeline_active, "No compute pipeline was set before attempting to draw.");
 
 	if (cl->validation.pipeline_push_constant_size > 0) {
-		//using push constants, check that they were supplied
+		// Using push constants, check that they were supplied.
 		ERR_FAIL_COND_MSG(!cl->validation.pipeline_push_constant_supplied,
 				"The shader in this pipeline requires a push constant to be set before drawing, but it's not present.");
 	}
 
 #endif
 
-	//Bind descriptor sets
+	// Bind descriptor sets.
 
 	for (uint32_t i = 0; i < cl->state.set_count; i++) {
 		if (cl->state.sets[i].pipeline_expected_format == 0) {
-			continue; //nothing expected by this pipeline
+			continue; // Nothing expected by this pipeline.
 		}
 #ifdef DEBUG_ENABLED
 		if (cl->state.sets[i].pipeline_expected_format != cl->state.sets[i].uniform_set_format) {
@@ -8458,7 +8458,7 @@ void RenderingDeviceVulkan::compute_list_dispatch(ComputeListID p_list, uint32_t
 		}
 #endif
 		if (!cl->state.sets[i].bound) {
-			//All good, see if this requires re-binding
+			// All good, see if this requires re-binding.
 			vkCmdBindDescriptorSets(cl->command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, cl->state.pipeline_layout, i, 1, &cl->state.sets[i].descriptor_set, 0, nullptr);
 			cl->state.sets[i].bound = true;
 		}
@@ -8484,7 +8484,7 @@ void RenderingDeviceVulkan::compute_list_dispatch_threads(ComputeListID p_list,
 	ERR_FAIL_COND_MSG(!cl->validation.pipeline_active, "No compute pipeline was set before attempting to draw.");
 
 	if (cl->validation.pipeline_push_constant_size > 0) {
-		//using push constants, check that they were supplied
+		// Using push constants, check that they were supplied.
 		ERR_FAIL_COND_MSG(!cl->validation.pipeline_push_constant_supplied,
 				"The shader in this pipeline requires a push constant to be set before drawing, but it's not present.");
 	}
@@ -8515,18 +8515,18 @@ void RenderingDeviceVulkan::compute_list_dispatch_indirect(ComputeListID p_list,
 	ERR_FAIL_COND_MSG(!cl->validation.pipeline_active, "No compute pipeline was set before attempting to draw.");
 
 	if (cl->validation.pipeline_push_constant_size > 0) {
-		//using push constants, check that they were supplied
+		// Using push constants, check that they were supplied.
 		ERR_FAIL_COND_MSG(!cl->validation.pipeline_push_constant_supplied,
 				"The shader in this pipeline requires a push constant to be set before drawing, but it's not present.");
 	}
 
 #endif
 
-	//Bind descriptor sets
+	// Bind descriptor sets.
 
 	for (uint32_t i = 0; i < cl->state.set_count; i++) {
 		if (cl->state.sets[i].pipeline_expected_format == 0) {
-			continue; //nothing expected by this pipeline
+			continue; // Nothing expected by this pipeline.
 		}
 #ifdef DEBUG_ENABLED
 		if (cl->state.sets[i].pipeline_expected_format != cl->state.sets[i].uniform_set_format) {
@@ -8541,7 +8541,7 @@ void RenderingDeviceVulkan::compute_list_dispatch_indirect(ComputeListID p_list,
 		}
 #endif
 		if (!cl->state.sets[i].bound) {
-			//All good, see if this requires re-binding
+			// All good, see if this requires re-binding.
 			vkCmdBindDescriptorSets(cl->command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, cl->state.pipeline_layout, i, 1, &cl->state.sets[i].descriptor_set, 0, nullptr);
 			cl->state.sets[i].bound = true;
 		}
@@ -8635,7 +8635,7 @@ void RenderingDeviceVulkan::compute_list_end(uint32_t p_post_barrier) {
 	memdelete(compute_list);
 	compute_list = nullptr;
 
-	// compute_list is no longer active
+	// Compute_list is no longer active.
 	_THREAD_SAFE_UNLOCK_
 }
 
@@ -8728,7 +8728,7 @@ void RenderingDeviceVulkan::draw_list_render_secondary_to_framebuffer(ID p_frame
 					"Draw list index (" + itos(i) + ") is created with a framebuffer format incompatible with this render pass.");
 
 			if (dl->validation.active) {
-				//needs to be closed, so close it.
+				// Needs to be closed, so close it.
 				vkEndCommandBuffer(dl->command_buffer);
 				dl->validation.active = false;
 			}
@@ -8753,7 +8753,7 @@ void RenderingDeviceVulkan::_free_internal(RID p_id) {
 	}
 #endif
 
-	//push everything so it's disposed of next time this frame index is processed (means, it's safe to do it)
+	// Push everything so it's disposed of next time this frame index is processed (means, it's safe to do it).
 	if (texture_owner.owns(p_id)) {
 		Texture *texture = texture_owner.get_or_null(p_id);
 		frames[frame].textures_to_dispose_of.push_back(*texture);
@@ -8833,23 +8833,23 @@ void RenderingDeviceVulkan::_free_internal(RID p_id) {
 void RenderingDeviceVulkan::free(RID p_id) {
 	_THREAD_SAFE_METHOD_
 
-	_free_dependencies(p_id); //recursively erase dependencies first, to avoid potential API problems
+	_free_dependencies(p_id); // Recursively erase dependencies first, to avoid potential API problems.
 	_free_internal(p_id);
 }
 
-// The full list of resources that can be named is in the VkObjectType enum
+// The full list of resources that can be named is in the VkObjectType enum.
 // We just expose the resources that are owned and can be accessed easily.
 void RenderingDeviceVulkan::set_resource_name(RID p_id, const String p_name) {
 	if (texture_owner.owns(p_id)) {
 		Texture *texture = texture_owner.get_or_null(p_id);
 		if (texture->owner.is_null()) {
-			// Don't set the source texture's name when calling on a texture view
+			// Don't set the source texture's name when calling on a texture view.
 			context->set_object_name(VK_OBJECT_TYPE_IMAGE, uint64_t(texture->image), p_name);
 		}
 		context->set_object_name(VK_OBJECT_TYPE_IMAGE_VIEW, uint64_t(texture->view), p_name + " View");
 	} else if (framebuffer_owner.owns(p_id)) {
 		//Framebuffer *framebuffer = framebuffer_owner.get_or_null(p_id);
-		// Not implemented for now as the relationship between Framebuffer and RenderPass is very complex
+		// Not implemented for now as the relationship between Framebuffer and RenderPass is very complex.
 	} else if (sampler_owner.owns(p_id)) {
 		VkSampler *sampler = sampler_owner.get_or_null(p_id);
 		context->set_object_name(VK_OBJECT_TYPE_SAMPLER, uint64_t(*sampler), p_name);
@@ -8936,17 +8936,17 @@ void RenderingDeviceVulkan::_finalize_command_bufers() {
 		ERR_PRINT("Found open compute list at the end of the frame, this should never happen (further compute will likely not work).");
 	}
 
-	{ //complete the setup buffer (that needs to be processed before anything else)
+	{ // Complete the setup buffer (that needs to be processed before anything else).
 		vkEndCommandBuffer(frames[frame].setup_command_buffer);
 		vkEndCommandBuffer(frames[frame].draw_command_buffer);
 	}
 }
 
 void RenderingDeviceVulkan::_begin_frame() {
-	//erase pending resources
+	// Erase pending resources.
 	_free_pending_resources(frame);
 
-	//create setup command buffer and set as the setup buffer
+	// Create setup command buffer and set as the setup buffer.
 
 	{
 		VkCommandBufferBeginInfo cmdbuf_begin;
@@ -8965,13 +8965,13 @@ void RenderingDeviceVulkan::_begin_frame() {
 
 		if (local_device.is_null()) {
 			context->append_command_buffer(frames[frame].draw_command_buffer);
-			context->set_setup_buffer(frames[frame].setup_command_buffer); //append now so it's added before everything else
+			context->set_setup_buffer(frames[frame].setup_command_buffer); // Append now so it's added before everything else.
 		}
 	}
 
-	//advance current frame
+	// Advance current frame.
 	frames_drawn++;
-	//advance staging buffer if used
+	// Advance staging buffer if used.
 	if (staging_buffer_used) {
 		staging_buffer_current = (staging_buffer_current + 1) % staging_buffer_blocks.size();
 		staging_buffer_used = false;
@@ -8996,7 +8996,7 @@ void RenderingDeviceVulkan::swap_buffers() {
 	_finalize_command_bufers();
 
 	screen_prepared = false;
-	//swap buffers
+	// Swap buffers.
 	context->swap_buffers();
 
 	frame = (frame + 1) % frame_count;
@@ -9042,15 +9042,15 @@ VmaPool RenderingDeviceVulkan::_find_or_create_small_allocs_pool(uint32_t p_mem_
 	pci.pMemoryAllocateNext = nullptr;
 	VmaPool pool = VK_NULL_HANDLE;
 	VkResult res = vmaCreatePool(allocator, &pci, &pool);
-	small_allocs_pools[p_mem_type_index] = pool; // Don't try to create it again if failed the first time
+	small_allocs_pools[p_mem_type_index] = pool; // Don't try to create it again if failed the first time.
 	ERR_FAIL_COND_V_MSG(res, pool, "vmaCreatePool failed with error " + itos(res) + ".");
 
 	return pool;
 }
 
 void RenderingDeviceVulkan::_free_pending_resources(int p_frame) {
-	//free in dependency usage order, so nothing weird happens
-	//pipelines
+	// Free in dependency usage order, so nothing weird happens.
+	// Pipelines.
 	while (frames[p_frame].render_pipelines_to_dispose_of.front()) {
 		RenderPipeline *pipeline = &frames[p_frame].render_pipelines_to_dispose_of.front()->get();
 
@@ -9067,7 +9067,7 @@ void RenderingDeviceVulkan::_free_pending_resources(int p_frame) {
 		frames[p_frame].compute_pipelines_to_dispose_of.pop_front();
 	}
 
-	//uniform sets
+	// Uniform sets.
 	while (frames[p_frame].uniform_sets_to_dispose_of.front()) {
 		UniformSet *uniform_set = &frames[p_frame].uniform_sets_to_dispose_of.front()->get();
 
@@ -9077,7 +9077,7 @@ void RenderingDeviceVulkan::_free_pending_resources(int p_frame) {
 		frames[p_frame].uniform_sets_to_dispose_of.pop_front();
 	}
 
-	//buffer views
+	// Buffer views.
 	while (frames[p_frame].buffer_views_to_dispose_of.front()) {
 		VkBufferView buffer_view = frames[p_frame].buffer_views_to_dispose_of.front()->get();
 
@@ -9086,19 +9086,19 @@ void RenderingDeviceVulkan::_free_pending_resources(int p_frame) {
 		frames[p_frame].buffer_views_to_dispose_of.pop_front();
 	}
 
-	//shaders
+	// Shaders.
 	while (frames[p_frame].shaders_to_dispose_of.front()) {
 		Shader *shader = &frames[p_frame].shaders_to_dispose_of.front()->get();
 
-		//descriptor set layout for each set
+		// Descriptor set layout for each set.
 		for (int i = 0; i < shader->sets.size(); i++) {
 			vkDestroyDescriptorSetLayout(device, shader->sets[i].descriptor_set_layout, nullptr);
 		}
 
-		//pipeline layout
+		// Pipeline layout.
 		vkDestroyPipelineLayout(device, shader->pipeline_layout, nullptr);
 
-		//shaders themselves
+		// Shaders themselves.
 		for (int i = 0; i < shader->pipeline_stages.size(); i++) {
 			vkDestroyShaderModule(device, shader->pipeline_stages[i].module, nullptr);
 		}
@@ -9106,7 +9106,7 @@ void RenderingDeviceVulkan::_free_pending_resources(int p_frame) {
 		frames[p_frame].shaders_to_dispose_of.pop_front();
 	}
 
-	//samplers
+	// Samplers.
 	while (frames[p_frame].samplers_to_dispose_of.front()) {
 		VkSampler sampler = frames[p_frame].samplers_to_dispose_of.front()->get();
 
@@ -9115,12 +9115,12 @@ void RenderingDeviceVulkan::_free_pending_resources(int p_frame) {
 		frames[p_frame].samplers_to_dispose_of.pop_front();
 	}
 
-	//framebuffers
+	// Framebuffers.
 	while (frames[p_frame].framebuffers_to_dispose_of.front()) {
 		Framebuffer *framebuffer = &frames[p_frame].framebuffers_to_dispose_of.front()->get();
 
 		for (const KeyValue<Framebuffer::VersionKey, Framebuffer::Version> &E : framebuffer->framebuffers) {
-			//first framebuffer, then render pass because it depends on it
+			// First framebuffer, then render pass because it depends on it.
 			vkDestroyFramebuffer(device, E.value.framebuffer, nullptr);
 			vkDestroyRenderPass(device, E.value.render_pass, nullptr);
 		}
@@ -9128,7 +9128,7 @@ void RenderingDeviceVulkan::_free_pending_resources(int p_frame) {
 		frames[p_frame].framebuffers_to_dispose_of.pop_front();
 	}
 
-	//textures
+	// Textures.
 	while (frames[p_frame].textures_to_dispose_of.front()) {
 		Texture *texture = &frames[p_frame].textures_to_dispose_of.front()->get();
 
@@ -9137,14 +9137,14 @@ void RenderingDeviceVulkan::_free_pending_resources(int p_frame) {
 		}
 		vkDestroyImageView(device, texture->view, nullptr);
 		if (texture->owner.is_null()) {
-			//actually owns the image and the allocation too
+			// Actually owns the image and the allocation too.
 			image_memory -= texture->allocation_info.size;
 			vmaDestroyImage(allocator, texture->image, texture->allocation);
 		}
 		frames[p_frame].textures_to_dispose_of.pop_front();
 	}
 
-	//buffers
+	// Buffers.
 	while (frames[p_frame].buffers_to_dispose_of.front()) {
 		_buffer_free(&frames[p_frame].buffers_to_dispose_of.front()->get());
 
@@ -9176,9 +9176,9 @@ uint64_t RenderingDeviceVulkan::get_memory_usage(MemoryType p_type) const {
 
 void RenderingDeviceVulkan::_flush(bool p_current_frame) {
 	if (local_device.is_valid() && !p_current_frame) {
-		return; //flushing previous frames has no effect with local device
+		return; // Flushing previous frames has no effect with local device.
 	}
-	//not doing this crashes RADV (undefined behavior)
+	// Not doing this crashes RADV (undefined behavior).
 	if (p_current_frame) {
 		vkEndCommandBuffer(frames[frame].setup_command_buffer);
 		vkEndCommandBuffer(frames[frame].draw_command_buffer);
@@ -9202,7 +9202,7 @@ void RenderingDeviceVulkan::_flush(bool p_current_frame) {
 
 	} else {
 		context->flush(p_current_frame, p_current_frame);
-		//re-create the setup command
+		// Re-create the setup command.
 		if (p_current_frame) {
 			VkCommandBufferBeginInfo cmdbuf_begin;
 			cmdbuf_begin.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
@@ -9212,7 +9212,7 @@ void RenderingDeviceVulkan::_flush(bool p_current_frame) {
 
 			VkResult err = vkBeginCommandBuffer(frames[frame].setup_command_buffer, &cmdbuf_begin);
 			ERR_FAIL_COND_MSG(err, "vkBeginCommandBuffer failed with error " + itos(err) + ".");
-			context->set_setup_buffer(frames[frame].setup_command_buffer); //append now so it's added before everything else
+			context->set_setup_buffer(frames[frame].setup_command_buffer); // Append now so it's added before everything else.
 		}
 
 		if (p_current_frame) {
@@ -9230,7 +9230,7 @@ void RenderingDeviceVulkan::_flush(bool p_current_frame) {
 }
 
 void RenderingDeviceVulkan::initialize(VulkanContext *p_context, bool p_local_device) {
-	// get our device capabilities
+	// Get our device capabilities.
 	{
 		device_capabilities.version_major = p_context->get_vulkan_major();
 		device_capabilities.version_minor = p_context->get_vulkan_minor();
@@ -9243,12 +9243,12 @@ void RenderingDeviceVulkan::initialize(VulkanContext *p_context, bool p_local_de
 		local_device = p_context->local_device_create();
 		device = p_context->local_device_get_vk_device(local_device);
 	} else {
-		frame_count = p_context->get_swapchain_image_count() + 1; //always need one extra to ensure it's unused at any time, without having to use a fence for this.
+		frame_count = p_context->get_swapchain_image_count() + 1; // Always need one extra to ensure it's unused at any time, without having to use a fence for this.
 	}
 	limits = p_context->get_device_limits();
 	max_timestamp_query_elements = 256;
 
-	{ //initialize allocator
+	{ // Initialize allocator.
 
 		VmaAllocatorCreateInfo allocatorInfo;
 		memset(&allocatorInfo, 0, sizeof(VmaAllocatorCreateInfo));
@@ -9260,11 +9260,11 @@ void RenderingDeviceVulkan::initialize(VulkanContext *p_context, bool p_local_de
 
 	frames.resize(frame_count);
 	frame = 0;
-	//create setup and frame buffers
+	// Create setup and frame buffers.
 	for (int i = 0; i < frame_count; i++) {
 		frames[i].index = 0;
 
-		{ //create command pool, one per frame is recommended
+		{ // Create command pool, one per frame is recommended.
 			VkCommandPoolCreateInfo cmd_pool_info;
 			cmd_pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
 			cmd_pool_info.pNext = nullptr;
@@ -9275,10 +9275,10 @@ void RenderingDeviceVulkan::initialize(VulkanContext *p_context, bool p_local_de
 			ERR_FAIL_COND_MSG(res, "vkCreateCommandPool failed with error " + itos(res) + ".");
 		}
 
-		{ //create command buffers
+		{ // Create command buffers.
 
 			VkCommandBufferAllocateInfo cmdbuf;
-			//no command buffer exists, create it.
+			// No command buffer exists, create it.
 			cmdbuf.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
 			cmdbuf.pNext = nullptr;
 			cmdbuf.commandPool = frames[i].command_pool;
@@ -9293,7 +9293,7 @@ void RenderingDeviceVulkan::initialize(VulkanContext *p_context, bool p_local_de
 		}
 
 		{
-			//create query pool
+			// Create query pool.
 			VkQueryPoolCreateInfo query_pool_create_info;
 			query_pool_create_info.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
 			query_pool_create_info.flags = 0;
@@ -9315,8 +9315,8 @@ void RenderingDeviceVulkan::initialize(VulkanContext *p_context, bool p_local_de
 	}
 
 	{
-		//begin the first command buffer for the first frame, so
-		//setting up things can be done in the meantime until swap_buffers(), which is called before advance.
+		// Begin the first command buffer for the first frame, so
+		// setting up things can be done in the meantime until swap_buffers(), which is called before advance.
 		VkCommandBufferBeginInfo cmdbuf_begin;
 		cmdbuf_begin.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
 		cmdbuf_begin.pNext = nullptr;
@@ -9329,42 +9329,42 @@ void RenderingDeviceVulkan::initialize(VulkanContext *p_context, bool p_local_de
 		err = vkBeginCommandBuffer(frames[0].draw_command_buffer, &cmdbuf_begin);
 		ERR_FAIL_COND_MSG(err, "vkBeginCommandBuffer failed with error " + itos(err) + ".");
 		if (local_device.is_null()) {
-			context->set_setup_buffer(frames[0].setup_command_buffer); //append now so it's added before everything else
+			context->set_setup_buffer(frames[0].setup_command_buffer); // Append now so it's added before everything else.
 			context->append_command_buffer(frames[0].draw_command_buffer);
 		}
 	}
 
-	// Note: If adding new project settings here, also duplicate their definition in
+	// NOTE: If adding new project settings here, also duplicate their definition in
 	// rendering_server.cpp for headless doctool.
 	staging_buffer_block_size = GLOBAL_DEF("rendering/vulkan/staging_buffer/block_size_kb", 256);
 	staging_buffer_block_size = MAX(4u, staging_buffer_block_size);
-	staging_buffer_block_size *= 1024; //kb -> bytes
+	staging_buffer_block_size *= 1024; // Kb -> bytes.
 	staging_buffer_max_size = GLOBAL_DEF("rendering/vulkan/staging_buffer/max_size_mb", 128);
 	staging_buffer_max_size = MAX(1u, staging_buffer_max_size);
 	staging_buffer_max_size *= 1024 * 1024;
 
 	if (staging_buffer_max_size < staging_buffer_block_size * 4) {
-		//validate enough blocks
+		// Validate enough blocks.
 		staging_buffer_max_size = staging_buffer_block_size * 4;
 	}
 	texture_upload_region_size_px = GLOBAL_DEF("rendering/vulkan/staging_buffer/texture_upload_region_size_px", 64);
 	texture_upload_region_size_px = nearest_power_of_2_templated(texture_upload_region_size_px);
 
-	frames_drawn = frame_count; //start from frame count, so everything else is immediately old
+	frames_drawn = frame_count; // Start from frame count, so everything else is immediately old.
 
-	//ensure current staging block is valid and at least one per frame exists
+	// Ensure current staging block is valid and at least one per frame exists.
 	staging_buffer_current = 0;
 	staging_buffer_used = false;
 
 	for (int i = 0; i < frame_count; i++) {
-		//staging was never used, create a block
+		// Staging was never used, create a block.
 		Error err = _insert_staging_block();
 		ERR_CONTINUE(err != OK);
 	}
 
 	max_descriptors_per_pool = GLOBAL_DEF("rendering/vulkan/descriptor_pools/max_descriptors_per_pool", 64);
 
-	//check to make sure DescriptorPoolKey is good
+	// Check to make sure DescriptorPoolKey is good.
 	static_assert(sizeof(uint64_t) * 3 >= UNIFORM_TYPE_MAX * sizeof(uint16_t));
 
 	draw_list = nullptr;
@@ -9399,7 +9399,7 @@ void RenderingDeviceVulkan::capture_timestamp(const String &p_name) {
 	ERR_FAIL_COND_MSG(draw_list != nullptr, "Capturing timestamps during draw list creation is not allowed. Offending timestamp was: " + p_name);
 	ERR_FAIL_COND(frames[frame].timestamp_count >= max_timestamp_query_elements);
 
-	//this should be optional for profiling, else it will slow things down
+	// This should be optional for profiling, else it will slow things down.
 	{
 		VkMemoryBarrier memoryBarrier;
 
@@ -9525,7 +9525,7 @@ uint64_t RenderingDeviceVulkan::get_driver_resource(DriverResource p_resource, R
 			return uint64_t(render_pipeline->pipeline);
 		} break;
 		default: {
-			// not supported for this driver
+			// Not supported for this driver.
 			return 0;
 		} break;
 	}
@@ -9562,9 +9562,9 @@ static void mult64to128(uint64_t u, uint64_t v, uint64_t &h, uint64_t &l) {
 uint64_t RenderingDeviceVulkan::get_captured_timestamp_gpu_time(uint32_t p_index) const {
 	ERR_FAIL_UNSIGNED_INDEX_V(p_index, frames[frame].timestamp_result_count, 0);
 
-	// this sucks because timestampPeriod multiplier is a float, while the timestamp is 64 bits nanosecs.
-	// so, in cases like nvidia which give you enormous numbers and 1 as multiplier, multiplying is next to impossible
-	// need to do 128 bits fixed point multiplication to get the right value
+	// This sucks because timestampPeriod multiplier is a float, while the timestamp is 64 bits nanosecs.
+	// So, in cases like nvidia which give you enormous numbers and 1 as multiplier, multiplying is next to impossible.
+	// Need to do 128 bits fixed point multiplication to get the right value.
 
 	uint64_t shift_bits = 16;
 
@@ -9677,7 +9677,7 @@ uint64_t RenderingDeviceVulkan::limit_get(Limit p_limit) const {
 }
 
 void RenderingDeviceVulkan::finalize() {
-	//free all resources
+	// Free all resources.
 
 	_flush(false);
 
@@ -9695,7 +9695,7 @@ void RenderingDeviceVulkan::finalize() {
 	_free_rids(framebuffer_owner, "Framebuffer");
 	_free_rids(sampler_owner, "Sampler");
 	{
-		//for textures it's a bit more difficult because they may be shared
+		// For textures it's a bit more difficult because they may be shared.
 		List<RID> owned;
 		texture_owner.get_owned_list(&owned);
 		if (owned.size()) {
@@ -9704,7 +9704,7 @@ void RenderingDeviceVulkan::finalize() {
 			} else {
 				WARN_PRINT(vformat("%d RIDs of type \"Texture\" were leaked.", owned.size()));
 			}
-			//free shared first
+			// Free shared first.
 			for (List<RID>::Element *E = owned.front(); E;) {
 				List<RID>::Element *N = E->next();
 				if (texture_is_shared(E->get())) {
@@ -9718,7 +9718,7 @@ void RenderingDeviceVulkan::finalize() {
 				}
 				E = N;
 			}
-			//free non shared second, this will avoid an error trying to free unexisting textures due to dependencies.
+			// Free non shared second, this will avoid an error trying to free unexisting textures due to dependencies.
 			for (const RID &E : owned) {
 #ifdef DEV_ENABLED
 				if (resource_names.has(E)) {
@@ -9730,7 +9730,7 @@ void RenderingDeviceVulkan::finalize() {
 		}
 	}
 
-	//free everything pending
+	// Free everything pending.
 	for (int i = 0; i < frame_count; i++) {
 		int f = (frame + i) % frame_count;
 		_free_pending_resources(f);
@@ -9766,7 +9766,7 @@ void RenderingDeviceVulkan::finalize() {
 	}
 	framebuffer_formats.clear();
 
-	//all these should be clear at this point
+	// All these should be clear at this point.
 	ERR_FAIL_COND(descriptor_pools.size());
 	ERR_FAIL_COND(dependency_map.size());
 	ERR_FAIL_COND(reverse_dependency_map.size());
diff --git a/drivers/vulkan/rendering_device_vulkan.h b/drivers/vulkan/rendering_device_vulkan.h
index 6d26d45a83..6572de7c52 100644
--- a/drivers/vulkan/rendering_device_vulkan.h
+++ b/drivers/vulkan/rendering_device_vulkan.h
@@ -96,13 +96,13 @@ class RenderingDeviceVulkan : public RenderingDevice {
 		ID_TYPE_SPLIT_DRAW_LIST,
 		ID_TYPE_COMPUTE_LIST,
 		ID_TYPE_MAX,
-		ID_BASE_SHIFT = 58 //5 bits for ID types
+		ID_BASE_SHIFT = 58 // 5 bits for ID types.
 	};
 
 	VkDevice device = VK_NULL_HANDLE;
 
-	HashMap<RID, HashSet<RID>> dependency_map; //IDs to IDs that depend on it
-	HashMap<RID, HashSet<RID>> reverse_dependency_map; //same as above, but in reverse
+	HashMap<RID, HashSet<RID>> dependency_map; // IDs to IDs that depend on it.
+	HashMap<RID, HashSet<RID>> reverse_dependency_map; // Same as above, but in reverse.
 
 	void _add_dependency(RID p_id, RID p_depends_on);
 	void _free_dependencies(RID p_id);
@@ -152,7 +152,7 @@ class RenderingDeviceVulkan : public RenderingDevice {
 
 		uint32_t read_aspect_mask = 0;
 		uint32_t barrier_aspect_mask = 0;
-		bool bound = false; //bound to framebffer
+		bool bound = false; // Bound to framebffer.
 		RID owner;
 	};
 
@@ -214,7 +214,7 @@ class RenderingDeviceVulkan : public RenderingDevice {
 		uint32_t usage = 0;
 		VkBuffer buffer = VK_NULL_HANDLE;
 		VmaAllocation allocation = nullptr;
-		VkDescriptorBufferInfo buffer_info; //used for binding
+		VkDescriptorBufferInfo buffer_info; // Used for binding.
 		Buffer() {
 		}
 	};
@@ -256,7 +256,7 @@ class RenderingDeviceVulkan : public RenderingDevice {
 			const FramebufferPass *key_pass_ptr = p_key.passes.ptr();
 
 			for (uint32_t i = 0; i < pass_size; i++) {
-				{ //compare color attachments
+				{ // Compare color attachments.
 					uint32_t attachment_size = pass_ptr[i].color_attachments.size();
 					uint32_t key_attachment_size = key_pass_ptr[i].color_attachments.size();
 					if (attachment_size != key_attachment_size) {
@@ -271,7 +271,7 @@ class RenderingDeviceVulkan : public RenderingDevice {
 						}
 					}
 				}
-				{ //compare input attachments
+				{ // Compare input attachments.
 					uint32_t attachment_size = pass_ptr[i].input_attachments.size();
 					uint32_t key_attachment_size = key_pass_ptr[i].input_attachments.size();
 					if (attachment_size != key_attachment_size) {
@@ -286,7 +286,7 @@ class RenderingDeviceVulkan : public RenderingDevice {
 						}
 					}
 				}
-				{ //compare resolve attachments
+				{ // Compare resolve attachments.
 					uint32_t attachment_size = pass_ptr[i].resolve_attachments.size();
 					uint32_t key_attachment_size = key_pass_ptr[i].resolve_attachments.size();
 					if (attachment_size != key_attachment_size) {
@@ -301,7 +301,7 @@ class RenderingDeviceVulkan : public RenderingDevice {
 						}
 					}
 				}
-				{ //compare preserve attachments
+				{ // Compare preserve attachments.
 					uint32_t attachment_size = pass_ptr[i].preserve_attachments.size();
 					uint32_t key_attachment_size = key_pass_ptr[i].preserve_attachments.size();
 					if (attachment_size != key_attachment_size) {
@@ -343,7 +343,7 @@ class RenderingDeviceVulkan : public RenderingDevice {
 				}
 			}
 
-			return false; //equal
+			return false; // Equal.
 		}
 	};
 
@@ -353,9 +353,9 @@ class RenderingDeviceVulkan : public RenderingDevice {
 	RBMap<FramebufferFormatKey, FramebufferFormatID> framebuffer_format_cache;
 	struct FramebufferFormat {
 		const RBMap<FramebufferFormatKey, FramebufferFormatID>::Element *E;
-		VkRenderPass render_pass = VK_NULL_HANDLE; //here for constructing shaders, never used, see section (7.2. Render Pass Compatibility from Vulkan spec)
+		VkRenderPass render_pass = VK_NULL_HANDLE; // Here for constructing shaders, never used, see section (7.2. Render Pass Compatibility from Vulkan spec).
 		Vector<TextureSamples> pass_samples;
-		uint32_t view_count = 1; // number of views
+		uint32_t view_count = 1; // Number of views.
 	};
 
 	HashMap<FramebufferFormatID, FramebufferFormat> framebuffer_formats;
@@ -397,7 +397,7 @@ class RenderingDeviceVulkan : public RenderingDevice {
 
 		struct Version {
 			VkFramebuffer framebuffer = VK_NULL_HANDLE;
-			VkRenderPass render_pass = VK_NULL_HANDLE; //this one is owned
+			VkRenderPass render_pass = VK_NULL_HANDLE; // This one is owned.
 			uint32_t subpass_count = 1;
 		};
 
@@ -454,7 +454,7 @@ class RenderingDeviceVulkan : public RenderingDevice {
 						return false;
 					}
 				}
-				return true; //they are equal
+				return true; // They are equal.
 			}
 		}
 
@@ -499,14 +499,14 @@ class RenderingDeviceVulkan : public RenderingDevice {
 		int vertex_count = 0;
 		uint32_t max_instances_allowed = 0;
 
-		Vector<VkBuffer> buffers; //not owned, just referenced
+		Vector<VkBuffer> buffers; // Not owned, just referenced.
 		Vector<VkDeviceSize> offsets;
 	};
 
 	RID_Owner<VertexArray, true> vertex_array_owner;
 
 	struct IndexBuffer : public Buffer {
-		uint32_t max_index = 0; //used for validation
+		uint32_t max_index = 0; // Used for validation.
 		uint32_t index_count = 0;
 		VkIndexType index_type = VK_INDEX_TYPE_NONE_NV;
 		bool supports_restart_indices = false;
@@ -515,8 +515,8 @@ class RenderingDeviceVulkan : public RenderingDevice {
 	RID_Owner<IndexBuffer, true> index_buffer_owner;
 
 	struct IndexArray {
-		uint32_t max_index = 0; //remember the maximum index here too, for validation
-		VkBuffer buffer; //not owned, inherited from index buffer
+		uint32_t max_index = 0; // Remember the maximum index here too, for validation.
+		VkBuffer buffer; // Not owned, inherited from index buffer.
 		uint32_t offset = 0;
 		uint32_t indices = 0;
 		VkIndexType index_type = VK_INDEX_TYPE_NONE_NV;
@@ -550,7 +550,7 @@ class RenderingDeviceVulkan : public RenderingDevice {
 		bool writable = false;
 		int binding = 0;
 		uint32_t stages = 0;
-		int length = 0; //size of arrays (in total elements), or ubos (in bytes * total elements)
+		int length = 0; // Size of arrays (in total elements), or ubos (in bytes * total elements).
 
 		bool operator!=(const UniformInfo &p_info) const {
 			return (binding != p_info.binding || type != p_info.type || writable != p_info.writable || stages != p_info.stages || length != p_info.length);
@@ -622,7 +622,7 @@ class RenderingDeviceVulkan : public RenderingDevice {
 			VkDescriptorSetLayout descriptor_set_layout = VK_NULL_HANDLE;
 		};
 
-		uint32_t vertex_input_mask = 0; //inputs used, this is mostly for validation
+		uint32_t vertex_input_mask = 0; // Inputs used, this is mostly for validation.
 		uint32_t fragment_output_mask = 0;
 
 		struct PushConstant {
@@ -645,7 +645,7 @@ class RenderingDeviceVulkan : public RenderingDevice {
 		Vector<VkPipelineShaderStageCreateInfo> pipeline_stages;
 		Vector<SpecializationConstant> specialization_constants;
 		VkPipelineLayout pipeline_layout = VK_NULL_HANDLE;
-		String name; //used for debug
+		String name; // Used for debug.
 	};
 
 	String _shader_uniform_debug(RID p_shader, int p_set = -1);
@@ -717,7 +717,7 @@ class RenderingDeviceVulkan : public RenderingDevice {
 	RID_Owner<Buffer, true> uniform_buffer_owner;
 	RID_Owner<Buffer, true> storage_buffer_owner;
 
-	//texture buffer needs a view
+	// Texture buffer needs a view.
 	struct TextureBuffer {
 		Buffer buffer;
 		VkBufferView view = VK_NULL_HANDLE;
@@ -740,15 +740,15 @@ class RenderingDeviceVulkan : public RenderingDevice {
 		DescriptorPool *pool = nullptr;
 		DescriptorPoolKey pool_key;
 		VkDescriptorSet descriptor_set = VK_NULL_HANDLE;
-		//VkPipelineLayout pipeline_layout; //not owned, inherited from shader
+		//VkPipelineLayout pipeline_layout; // Not owned, inherited from shader.
 		struct AttachableTexture {
 			uint32_t bind;
 			RID texture;
 		};
 
-		LocalVector<AttachableTexture> attachable_textures; //used for validation
-		Vector<Texture *> mutable_sampled_textures; //used for layout change
-		Vector<Texture *> mutable_storage_textures; //used for layout change
+		LocalVector<AttachableTexture> attachable_textures; // Used for validation.
+		Vector<Texture *> mutable_sampled_textures; // Used for layout change.
+		Vector<Texture *> mutable_storage_textures; // Used for layout change.
 		InvalidationCallback invalidated_callback = nullptr;
 		void *invalidated_callback_userdata = nullptr;
 	};
@@ -771,7 +771,7 @@ class RenderingDeviceVulkan : public RenderingDevice {
 	// was not supplied as intended.
 
 	struct RenderPipeline {
-		//Cached values for validation
+		// Cached values for validation.
 #ifdef DEBUG_ENABLED
 		struct Validation {
 			FramebufferFormatID framebuffer_format = 0;
@@ -783,10 +783,10 @@ class RenderingDeviceVulkan : public RenderingDevice {
 			uint32_t primitive_divisor = 0;
 		} validation;
 #endif
-		//Actual pipeline
+		// Actual pipeline.
 		RID shader;
 		Vector<uint32_t> set_formats;
-		VkPipelineLayout pipeline_layout = VK_NULL_HANDLE; // not owned, needed for push constants
+		VkPipelineLayout pipeline_layout = VK_NULL_HANDLE; // Not owned, needed for push constants.
 		VkPipeline pipeline = VK_NULL_HANDLE;
 		uint32_t push_constant_size = 0;
 		uint32_t push_constant_stages = 0;
@@ -797,7 +797,7 @@ class RenderingDeviceVulkan : public RenderingDevice {
 	struct ComputePipeline {
 		RID shader;
 		Vector<uint32_t> set_formats;
-		VkPipelineLayout pipeline_layout = VK_NULL_HANDLE; // not owned, needed for push constants
+		VkPipelineLayout pipeline_layout = VK_NULL_HANDLE; // Not owned, needed for push constants.
 		VkPipeline pipeline = VK_NULL_HANDLE;
 		uint32_t push_constant_size = 0;
 		uint32_t push_constant_stages = 0;
@@ -823,7 +823,7 @@ class RenderingDeviceVulkan : public RenderingDevice {
 
 	struct SplitDrawListAllocator {
 		VkCommandPool command_pool = VK_NULL_HANDLE;
-		Vector<VkCommandBuffer> command_buffers; //one for each frame
+		Vector<VkCommandBuffer> command_buffers; // One for each frame.
 	};
 
 	Vector<SplitDrawListAllocator> split_draw_list_allocators;
@@ -975,7 +975,7 @@ class RenderingDeviceVulkan : public RenderingDevice {
 	// when the frame is cycled.
 
 	struct Frame {
-		//list in usage order, from last to free to first to free
+		// List in usage order, from last to free to first to free.
 		List<Buffer> buffers_to_dispose_of;
 		List<Texture> textures_to_dispose_of;
 		List<Framebuffer> framebuffers_to_dispose_of;
@@ -987,8 +987,8 @@ class RenderingDeviceVulkan : public RenderingDevice {
 		List<ComputePipeline> compute_pipelines_to_dispose_of;
 
 		VkCommandPool command_pool = VK_NULL_HANDLE;
-		VkCommandBuffer setup_command_buffer = VK_NULL_HANDLE; //used at the beginning of every frame for set-up
-		VkCommandBuffer draw_command_buffer = VK_NULL_HANDLE; //used at the beginning of every frame for set-up
+		VkCommandBuffer setup_command_buffer = VK_NULL_HANDLE; // Used at the beginning of every frame for set-up.
+		VkCommandBuffer draw_command_buffer = VK_NULL_HANDLE; // Used at the beginning of every frame for set-up.
 
 		struct Timestamp {
 			String description;
@@ -1009,9 +1009,9 @@ class RenderingDeviceVulkan : public RenderingDevice {
 
 	uint32_t max_timestamp_query_elements = 0;
 
-	TightLocalVector<Frame> frames; //frames available, for main device they are cycled (usually 3), for local devices only 1
-	int frame = 0; //current frame
-	int frame_count = 0; //total amount of frames
+	TightLocalVector<Frame> frames; // Frames available, for main device they are cycled (usually 3), for local devices only 1.
+	int frame = 0; // Current frame.
+	int frame_count = 0; // Total amount of frames.
 	uint64_t frames_drawn = 0;
 	RID local_device;
 	bool local_device_processing = false;
@@ -1089,7 +1089,7 @@ public:
 
 	virtual RID vertex_buffer_create(uint32_t p_size_bytes, const Vector<uint8_t> &p_data = Vector<uint8_t>(), bool p_use_as_storage = false);
 
-	// Internally reference counted, this ID is warranted to be unique for the same description, but needs to be freed as many times as it was allocated
+	// Internally reference counted, this ID is warranted to be unique for the same description, but needs to be freed as many times as it was allocated.
 	virtual VertexFormatID vertex_format_create(const Vector<VertexAttribute> &p_vertex_formats);
 	virtual RID vertex_array_create(uint32_t p_vertex_count, VertexFormatID p_vertex_format, const Vector<RID> &p_src_buffers);
 
@@ -1120,7 +1120,7 @@ public:
 	virtual bool uniform_set_is_valid(RID p_uniform_set);
 	virtual void uniform_set_set_invalidation_callback(RID p_uniform_set, InvalidationCallback p_callback, void *p_userdata);
 
-	virtual Error buffer_update(RID p_buffer, uint32_t p_offset, uint32_t p_size, const void *p_data, uint32_t p_post_barrier = BARRIER_MASK_ALL); //works for any buffer
+	virtual Error buffer_update(RID p_buffer, uint32_t p_offset, uint32_t p_size, const void *p_data, uint32_t p_post_barrier = BARRIER_MASK_ALL); // Works for any buffer.
 	virtual Error buffer_clear(RID p_buffer, uint32_t p_offset, uint32_t p_size, uint32_t p_post_barrier = BARRIER_MASK_ALL);
 	virtual Vector<uint8_t> buffer_get_data(RID p_buffer);
 
@@ -1218,10 +1218,10 @@ public:
 	void initialize(VulkanContext *p_context, bool p_local_device = false);
 	void finalize();
 
-	virtual void swap_buffers(); //for main device
+	virtual void swap_buffers(); // For main device.
 
-	virtual void submit(); //for local device
-	virtual void sync(); //for local device
+	virtual void submit(); // For local device.
+	virtual void sync(); // For local device.
 
 	virtual uint32_t get_frame_delay() const;
 
diff --git a/drivers/vulkan/vulkan_context.cpp b/drivers/vulkan/vulkan_context.cpp
index a9a8ce68ac..afc3e78372 100644
--- a/drivers/vulkan/vulkan_context.cpp
+++ b/drivers/vulkan/vulkan_context.cpp
@@ -237,7 +237,7 @@ Error VulkanContext::_get_preferred_validation_layers(uint32_t *count, const cha
 		{ "VK_LAYER_GOOGLE_threading", "VK_LAYER_LUNARG_parameter_validation", "VK_LAYER_LUNARG_object_tracker", "VK_LAYER_LUNARG_core_validation", "VK_LAYER_GOOGLE_unique_objects" }
 	};
 
-	// Clear out-arguments
+	// Clear out-arguments.
 	*count = 0;
 	if (names != nullptr) {
 		*names = nullptr;
@@ -441,7 +441,7 @@ String VulkanContext::SubgroupCapabilities::supported_stages_desc() const {
 		res += ", STAGE_MESH_NV";
 	}
 
-	return res.substr(2); // Remove first ", "
+	return res.substr(2); // Remove first ", ".
 }
 
 uint32_t VulkanContext::SubgroupCapabilities::supported_operations_flags_rd() const {
@@ -506,7 +506,7 @@ String VulkanContext::SubgroupCapabilities::supported_operations_desc() const {
 		res += ", FEATURE_PARTITIONED_NV";
 	}
 
-	return res.substr(2); // Remove first ", "
+	return res.substr(2); // Remove first ", ".
 }
 
 Error VulkanContext::_check_capabilities() {
@@ -641,8 +641,8 @@ Error VulkanContext::_check_capabilities() {
 		subgroup_capabilities.supportedStages = subgroupProperties.supportedStages;
 		subgroup_capabilities.supportedOperations = subgroupProperties.supportedOperations;
 		// Note: quadOperationsInAllStages will be true if:
-		// - supportedStages has VK_SHADER_STAGE_ALL_GRAPHICS + VK_SHADER_STAGE_COMPUTE_BIT
-		// - supportedOperations has VK_SUBGROUP_FEATURE_QUAD_BIT
+		// - supportedStages has VK_SHADER_STAGE_ALL_GRAPHICS + VK_SHADER_STAGE_COMPUTE_BIT.
+		// - supportedOperations has VK_SUBGROUP_FEATURE_QUAD_BIT.
 		subgroup_capabilities.quadOperationsInAllStages = subgroupProperties.quadOperationsInAllStages;
 
 		if (vrs_capabilities.pipeline_vrs_supported || vrs_capabilities.primitive_vrs_supported || vrs_capabilities.attachment_vrs_supported) {
@@ -654,7 +654,7 @@ Error VulkanContext::_check_capabilities() {
 				print_verbose("  Primitive fragment shading rate");
 			}
 			if (vrs_capabilities.attachment_vrs_supported) {
-				// TODO expose these somehow to the end user
+				// TODO expose these somehow to the end user.
 				vrs_capabilities.min_texel_size.x = vrsProperties.minFragmentShadingRateAttachmentTexelSize.width;
 				vrs_capabilities.min_texel_size.y = vrsProperties.minFragmentShadingRateAttachmentTexelSize.height;
 				vrs_capabilities.max_texel_size.x = vrsProperties.maxFragmentShadingRateAttachmentTexelSize.width;
@@ -731,7 +731,7 @@ Error VulkanContext::_create_instance() {
 	VkDebugUtilsMessengerCreateInfoEXT dbg_messenger_create_info;
 	VkDebugReportCallbackCreateInfoEXT dbg_report_callback_create_info{};
 	if (enabled_debug_utils) {
-		// VK_EXT_debug_utils style
+		// VK_EXT_debug_utils style.
 		dbg_messenger_create_info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
 		dbg_messenger_create_info.pNext = nullptr;
 		dbg_messenger_create_info.flags = 0;
@@ -902,8 +902,8 @@ Error VulkanContext::_create_physical_device(VkSurfaceKHR p_surface) {
 		}
 	} else {
 		// TODO: At least on Linux Laptops integrated GPUs fail with Vulkan in many instances.
-		//   The device should really be a preference, but for now choosing a discrete GPU over the
-		//   integrated one is better than the default.
+		// The device should really be a preference, but for now choosing a discrete GPU over the
+		// integrated one is better than the default.
 
 		int type_selected = -1;
 		print_verbose("Vulkan devices:");
@@ -1175,7 +1175,7 @@ Error VulkanContext::_create_device() {
 
 	VkPhysicalDeviceFragmentShadingRateFeaturesKHR vrs_features;
 	if (vrs_capabilities.pipeline_vrs_supported || vrs_capabilities.primitive_vrs_supported || vrs_capabilities.attachment_vrs_supported) {
-		// insert into our chain to enable these features if they are available
+		// Insert into our chain to enable these features if they are available.
 		vrs_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
 		vrs_features.pNext = nextptr;
 		vrs_features.pipelineFragmentShadingRate = vrs_capabilities.pipeline_vrs_supported;
@@ -1611,17 +1611,17 @@ Error VulkanContext::_update_swap_chain(Window *window) {
 	// The FIFO present mode is guaranteed by the spec to be supported
 	// and to have no tearing.  It's a great default present mode to use.
 
-	//  There are times when you may wish to use another present mode.  The
-	//  following code shows how to select them, and the comments provide some
-	//  reasons you may wish to use them.
+	// There are times when you may wish to use another present mode.  The
+	// following code shows how to select them, and the comments provide some
+	// reasons you may wish to use them.
 	//
 	// It should be noted that Vulkan 1.0 doesn't provide a method for
-	// synchronizing rendering with the presentation engine's display.  There
+	// synchronizing rendering with the presentation engine's display. There
 	// is a method provided for throttling rendering with the display, but
 	// there are some presentation engines for which this method will not work.
 	// If an application doesn't throttle its rendering, and if it renders much
 	// faster than the refresh rate of the display, this can waste power on
-	// mobile devices.  That is because power is being spent rendering images
+	// mobile devices. That is because power is being spent rendering images
 	// that may never be seen.
 
 	// VK_PRESENT_MODE_IMMEDIATE_KHR is for applications that don't care about
@@ -1699,7 +1699,7 @@ Error VulkanContext::_update_swap_chain(Window *window) {
 	// If maxImageCount is 0, we can ask for as many images as we want;
 	// otherwise we're limited to maxImageCount.
 	if ((surfCapabilities.maxImageCount > 0) && (desiredNumOfSwapchainImages > surfCapabilities.maxImageCount)) {
-		// Application must settle for fewer images than desired:
+		// Application must settle for fewer images than desired.
 		desiredNumOfSwapchainImages = surfCapabilities.maxImageCount;
 	}
 
@@ -2043,14 +2043,14 @@ Error VulkanContext::prepare_buffers() {
 		}
 
 		do {
-			// Get the index of the next available swapchain image:
+			// Get the index of the next available swapchain image.
 			err =
 					fpAcquireNextImageKHR(device, w->swapchain, UINT64_MAX,
 							w->image_acquired_semaphores[frame_index], VK_NULL_HANDLE, &w->current_buffer);
 
 			if (err == VK_ERROR_OUT_OF_DATE_KHR) {
 				// Swapchain is out of date (e.g. the window was resized) and
-				// must be recreated:
+				// must be recreated.
 				print_verbose("Vulkan: Early out of date swapchain, recreating.");
 				// resize_notify();
 				_update_swap_chain(w);
@@ -2083,7 +2083,7 @@ Error VulkanContext::swap_buffers() {
 #if 0
 	if (VK_GOOGLE_display_timing_enabled) {
 		// Look at what happened to previous presents, and make appropriate
-		// adjustments in timing:
+		// adjustments in timing.
 		DemoUpdateTargetIPD(demo);
 
 		// Note: a real application would position its geometry to that it's in
@@ -2246,7 +2246,7 @@ Error VulkanContext::swap_buffers() {
 			uint64_t curtime = getTimeInNanoseconds();
 			if (curtime == 0) {
 				// Since we didn't find out the current time, don't give a
-				// desiredPresentTime:
+				// desiredPresentTime.
 				ptime.desiredPresentTime = 0;
 			} else {
 				ptime.desiredPresentTime = curtime + (target_IPD >> 1);
@@ -2278,7 +2278,7 @@ Error VulkanContext::swap_buffers() {
 
 	if (err == VK_ERROR_OUT_OF_DATE_KHR) {
 		// Swapchain is out of date (e.g. the window was resized) and
-		// must be recreated:
+		// must be recreated.
 		print_verbose("Vulkan: Swapchain is out of date, recreating.");
 		resize_notify();
 	} else if (err == VK_SUBOPTIMAL_KHR) {
diff --git a/drivers/vulkan/vulkan_context.h b/drivers/vulkan/vulkan_context.h
index 35e7ce7db8..5cc3b515d9 100644
--- a/drivers/vulkan/vulkan_context.h
+++ b/drivers/vulkan/vulkan_context.h
@@ -70,9 +70,9 @@ public:
 	};
 
 	struct VRSCapabilities {
-		bool pipeline_vrs_supported; // We can specify our fragment rate on a pipeline level
-		bool primitive_vrs_supported; // We can specify our fragment rate on each drawcall
-		bool attachment_vrs_supported; // We can provide a density map attachment on our framebuffer
+		bool pipeline_vrs_supported; // We can specify our fragment rate on a pipeline level.
+		bool primitive_vrs_supported; // We can specify our fragment rate on each drawcall.
+		bool attachment_vrs_supported; // We can provide a density map attachment on our framebuffer.
 
 		Size2i min_texel_size;
 		Size2i max_texel_size;
@@ -107,7 +107,7 @@ private:
 	bool device_initialized = false;
 	bool inst_initialized = false;
 
-	// Vulkan 1.0 doesn't return version info so we assume this by default until we know otherwise
+	// Vulkan 1.0 doesn't return version info so we assume this by default until we know otherwise.
 	uint32_t vulkan_major = 1;
 	uint32_t vulkan_minor = 0;
 	uint32_t vulkan_patch = 0;
@@ -267,7 +267,7 @@ protected:
 	Error _get_preferred_validation_layers(uint32_t *count, const char *const **names);
 
 public:
-	// Extension calls
+	// Extension calls.
 	VkResult vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass);
 
 	uint32_t get_vulkan_major() const { return vulkan_major; };