+ img.instantiate();

+ Image::png_unpacker = lossless_unpack_png;

+ Image::png_packer = lossless_pack_png;

+#include "core/io/file_access.h"

+ resource_saver_png.instantiate();

+#include "core/io/dir_access.h"

+ if (is_backup_save_enabled() && (p_mode_flags == WRITE)) {

+#include "core/io/file_access.h"

+ for (const IPAddress &F : c.ip_addresses) {

+ if (!F.is_ipv4()) {

+ if_ip = F;

+ ret.minute = lt.tm_min;

+ ret.second = lt.tm_sec;

+ env.Prepend(CPPPATH=[thirdparty_dir, thirdparty_dir + "/include"])

+#include "core/io/compression.h"

+#include "core/io/file_access.h"

+#include "core/io/marshalls.h"

+#include "thirdparty/misc/smolv.h"

+ buffer_memory += p_size;

+

+ buffer_memory -= p_buffer->size;

+ if (p_format.usage_bits & TEXTURE_USAGE_INPUT_ATTACHMENT_BIT) {

+ image_create_info.usage |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;

+ }

+

+ image_memory += texture.allocation_info.size;

+ _texture_update(id, i, p_data[i], RD::BARRIER_MASK_ALL, true);

+ if (texture.usage_flags & TEXTURE_USAGE_INPUT_ATTACHMENT_BIT) {

+ usage_info.usage |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;

+ }

+

+ return _texture_update(p_texture, p_layer, p_data, p_post_barrier, false);

+}

+

+Error RenderingDeviceVulkan::_texture_update(RID p_texture, uint32_t p_layer, const Vector<uint8_t> &p_data, uint32_t p_post_barrier, bool p_use_setup_queue) {

+ ERR_FAIL_COND_V_MSG((draw_list || compute_list) && !p_use_setup_queue, ERR_INVALID_PARAMETER,

+ "Updating textures is forbidden during creation of a draw or compute list");

+ VkCommandBuffer command_buffer = p_use_setup_queue ? frames[frame].setup_command_buffer : frames[frame].draw_command_buffer;

+ Error err = _staging_buffer_allocate(to_allocate, required_align, alloc_offset, alloc_size, false, !p_use_setup_queue);

+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) {

+ LocalVector<int32_t> attachment_last_pass;

+ attachment_last_pass.resize(p_attachments.size());

+ Vector<VkAttachmentDescription> attachments;

+

+ for (int i = 0; i < p_attachments.size(); i++) {

+ ERR_FAIL_INDEX_V(p_attachments[i].format, DATA_FORMAT_MAX, VK_NULL_HANDLE);

+ ERR_FAIL_INDEX_V(p_attachments[i].samples, TEXTURE_SAMPLES_MAX, VK_NULL_HANDLE);

+ ERR_FAIL_COND_V_MSG(!(p_attachments[i].usage_flags & (TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | TEXTURE_USAGE_INPUT_ATTACHMENT_BIT)),

+ VK_NULL_HANDLE, "Texture format for index (" + itos(i) + ") requires an attachment (color, depth, input or stencil) bit set.");

+ description.format = vulkan_formats[p_attachments[i].format];

+ description.samples = rasterization_sample_count[p_attachments[i].samples];

+ bool is_sampled = p_attachments[i].usage_flags & TEXTURE_USAGE_SAMPLING_BIT;

+ bool is_storage = p_attachments[i].usage_flags & TEXTURE_USAGE_STORAGE_BIT;

+ bool is_depth = p_attachments[i].usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;

+ switch (is_depth ? p_initial_depth_action : p_initial_action) {

+ if (p_attachments[i].usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT) {

+ } else if (p_attachments[i].usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {

+ if (p_attachments[i].usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT) {

+ } else if (p_attachments[i].usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {

+ if (p_attachments[i].usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT) {

+ } else if (p_attachments[i].usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {

+ switch (is_depth ? p_final_depth_action : p_final_action) {

+ if (p_attachments[i].usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT) {

+ } else if (p_attachments[i].usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {

+ if (p_attachments[i].usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT) {

+ } else if (p_attachments[i].usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {

+ if (p_attachments[i].usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT) {

+ } else if (p_attachments[i].usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {

+ attachment_last_pass[i] = -1;

+

+ }

+

+ LocalVector<VkSubpassDescription> subpasses;

+ LocalVector<LocalVector<VkAttachmentReference>> color_reference_array;

+ LocalVector<LocalVector<VkAttachmentReference>> input_reference_array;

+ LocalVector<LocalVector<VkAttachmentReference>> resolve_reference_array;

+ LocalVector<LocalVector<uint32_t>> preserve_reference_array;

+ LocalVector<VkAttachmentReference> depth_reference_array;

+

+ subpasses.resize(p_passes.size());

+ color_reference_array.resize(p_passes.size());

+ input_reference_array.resize(p_passes.size());

+ resolve_reference_array.resize(p_passes.size());

+ preserve_reference_array.resize(p_passes.size());

+ depth_reference_array.resize(p_passes.size());

+

+ LocalVector<VkSubpassDependency> subpass_dependencies;

+

+ for (int i = 0; i < p_passes.size(); i++) {

+ const FramebufferPass *pass = &p_passes[i];

+

+ LocalVector<VkAttachmentReference> &color_references = color_reference_array[i];

+ TextureSamples texture_samples = TEXTURE_SAMPLES_1;

+ bool is_multisample_first = true;

+ for (int j = 0; j < pass->color_attachments.size(); j++) {

+ int32_t attachment = pass->color_attachments[j];

+ VkAttachmentReference reference;

+ if (attachment == FramebufferPass::ATTACHMENT_UNUSED) {

+ reference.attachment = VK_ATTACHMENT_UNUSED;

+ reference.layout = VK_IMAGE_LAYOUT_UNDEFINED;

+ } else {

+ ERR_FAIL_INDEX_V_MSG(attachment, p_attachments.size(), VK_NULL_HANDLE, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), color attachment (" + itos(j) + ").");

+ ERR_FAIL_COND_V_MSG(!(p_attachments[attachment].usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT), VK_NULL_HANDLE, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), it's marked as depth, but it's not usable as color attachment.");

+ ERR_FAIL_COND_V_MSG(attachment_last_pass[attachment] == i, VK_NULL_HANDLE, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), it already was used for something else before in this pass.");

+

+ if (is_multisample_first) {

+ texture_samples = p_attachments[attachment].samples;

+ is_multisample_first = false;

+ } else {

+ ERR_FAIL_COND_V_MSG(texture_samples != p_attachments[attachment].samples, VK_NULL_HANDLE, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), if an attachment is marked as multisample, all of them should be multisample and use the same number of samples.");

+ }

+ reference.attachment = attachment;

+ reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;

+ attachment_last_pass[attachment] = i;

+ }

+ }

+

+ LocalVector<VkAttachmentReference> &input_references = input_reference_array[i];

+

+ for (int j = 0; j < pass->input_attachments.size(); j++) {

+ int32_t attachment = pass->input_attachments[j];

+ VkAttachmentReference reference;

+ if (attachment == FramebufferPass::ATTACHMENT_UNUSED) {

+ reference.attachment = VK_ATTACHMENT_UNUSED;

+ reference.layout = VK_IMAGE_LAYOUT_UNDEFINED;

+ } else {

+ ERR_FAIL_INDEX_V_MSG(attachment, p_attachments.size(), VK_NULL_HANDLE, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), input attachment (" + itos(j) + ").");

+ ERR_FAIL_COND_V_MSG(!(p_attachments[attachment].usage_flags & TEXTURE_USAGE_INPUT_ATTACHMENT_BIT), VK_NULL_HANDLE, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), it isn't marked as an input texture.");

+ ERR_FAIL_COND_V_MSG(attachment_last_pass[attachment] == i, VK_NULL_HANDLE, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), it already was used for something else before in this pass.");

+ reference.attachment = attachment;

+ reference.layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;

+ attachment_last_pass[attachment] = i;

+ }

+ input_references.push_back(reference);

+ }

+

+ LocalVector<VkAttachmentReference> &resolve_references = resolve_reference_array[i];

+

+ if (pass->resolve_attachments.size() > 0) {

+ ERR_FAIL_COND_V_MSG(pass->resolve_attachments.size() != pass->color_attachments.size(), VK_NULL_HANDLE, "The amount of resolve attachments (" + itos(pass->resolve_attachments.size()) + ") must match the number of color attachments (" + itos(pass->color_attachments.size()) + ").");

+ ERR_FAIL_COND_V_MSG(texture_samples == TEXTURE_SAMPLES_1, VK_NULL_HANDLE, "Resolve attachments specified, but color attachments are not multisample.");

+ }

+ for (int j = 0; j < pass->resolve_attachments.size(); j++) {

+ int32_t attachment = pass->resolve_attachments[j];

+ VkAttachmentReference reference;

+ if (attachment == FramebufferPass::ATTACHMENT_UNUSED) {

+ reference.attachment = VK_ATTACHMENT_UNUSED;

+ reference.layout = VK_IMAGE_LAYOUT_UNDEFINED;

+ } else {

+ ERR_FAIL_INDEX_V_MSG(attachment, p_attachments.size(), VK_NULL_HANDLE, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), resolve attachment (" + itos(j) + ").");

+ ERR_FAIL_COND_V_MSG(pass->color_attachments[j] == FramebufferPass::ATTACHMENT_UNUSED, VK_NULL_HANDLE, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), resolve attachment (" + itos(j) + "), the respective color attachment is marked as unused.");

+ ERR_FAIL_COND_V_MSG(!(p_attachments[attachment].usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT), VK_NULL_HANDLE, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), resolve attachment, it isn't marked as a color texture.");

+ ERR_FAIL_COND_V_MSG(attachment_last_pass[attachment] == i, VK_NULL_HANDLE, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), it already was used for something else before in this pass.");

+ 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;

+ reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; // VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;

+ attachment_last_pass[attachment] = i;

+ }

+ }

+

+ LocalVector<uint32_t> &preserve_references = preserve_reference_array[i];

+

+ for (int j = 0; j < pass->preserve_attachments.size(); j++) {

+ int32_t attachment = pass->preserve_attachments[j];

+

+ ERR_FAIL_COND_V_MSG(attachment == FramebufferPass::ATTACHMENT_UNUSED, VK_NULL_HANDLE, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), preserve attachment (" + itos(j) + "). Preserve attachments can't be unused.");

+

+ 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) + ").");

+ ERR_FAIL_COND_V_MSG(attachment_last_pass[attachment] == i, VK_NULL_HANDLE, "Invalid framebuffer format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), it already was used for something else before in this pass.");

+

+ attachment_last_pass[attachment] = i;

+

+ preserve_references.push_back(attachment);

+ }

+

+ VkAttachmentReference &depth_stencil_reference = depth_reference_array[i];

+

+ if (pass->depth_attachment != FramebufferPass::ATTACHMENT_UNUSED) {

+ int32_t attachment = pass->depth_attachment;

+ ERR_FAIL_INDEX_V_MSG(attachment, p_attachments.size(), VK_NULL_HANDLE, "Invalid framebuffer depth format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), depth attachment.");

+ ERR_FAIL_COND_V_MSG(!(p_attachments[attachment].usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT), VK_NULL_HANDLE, "Invalid framebuffer depth format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), it's marked as depth, but it's not a depth attachment.");

+ ERR_FAIL_COND_V_MSG(attachment_last_pass[attachment] == i, VK_NULL_HANDLE, "Invalid framebuffer depth format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), it already was used for something else before in this pass.");

+ depth_stencil_reference.attachment = attachment;

+ depth_stencil_reference.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;

+ attachment_last_pass[attachment] = i;

+

+ if (is_multisample_first) {

+ texture_samples = p_attachments[attachment].samples;

+ is_multisample_first = false;

+ } else {

+ ERR_FAIL_COND_V_MSG(texture_samples != p_attachments[attachment].samples, VK_NULL_HANDLE, "Invalid framebuffer depth format attachment(" + itos(attachment) + "), in pass (" + itos(i) + "), if an attachment is marked as multisample, all of them should be multisample and use the same number of samples including the depth.");

+ }

+

+ depth_stencil_reference.attachment = VK_ATTACHMENT_UNUSED;

+ depth_stencil_reference.layout = VK_IMAGE_LAYOUT_UNDEFINED;

+ VkSubpassDescription &subpass = subpasses[i];

+ subpass.flags = 0;

+ subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;

+ subpass.inputAttachmentCount = input_references.size();

+ if (input_references.size()) {

+ subpass.pInputAttachments = input_references.ptr();

+ } else {

+ subpass.pInputAttachments = nullptr;

+ }

+ subpass.colorAttachmentCount = color_references.size();

+ if (color_references.size()) {

+ subpass.pColorAttachments = color_references.ptr();

+ } else {

+ subpass.pColorAttachments = nullptr;

+ }

+ if (depth_stencil_reference.attachment != VK_ATTACHMENT_UNUSED) {

+ subpass.pDepthStencilAttachment = &depth_stencil_reference;

+ } else {

+ subpass.pDepthStencilAttachment = nullptr;

+ }

+

+ if (resolve_references.size()) {

+ subpass.pResolveAttachments = resolve_references.ptr();

+ } else {

+ subpass.pResolveAttachments = nullptr;

+ }

+

+ subpass.preserveAttachmentCount = preserve_references.size();

+ if (preserve_references.size()) {

+ subpass.pPreserveAttachments = preserve_references.ptr();

+ } else {

+ subpass.pPreserveAttachments = nullptr;

+ }

+

+ if (r_samples) {

+ r_samples->push_back(texture_samples);

+ }

+

+ if (i > 0) {

+ VkSubpassDependency dependency;

+ dependency.srcSubpass = i - 1;

+ dependency.dstSubpass = i;

+ dependency.srcStageMask = 0;

+ dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;

+ dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;

+

+ dependency.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;

+ dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;

+ dependency.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;

+ subpass_dependencies.push_back(dependency);

+ }

+ /*

+ */

+ render_pass_create_info.subpassCount = subpasses.size();

+ render_pass_create_info.pSubpasses = subpasses.ptr();

+ render_pass_create_info.dependencyCount = subpass_dependencies.size();

+ if (subpass_dependencies.size()) {

+ render_pass_create_info.pDependencies = subpass_dependencies.ptr();

+ } else {

+ render_pass_create_info.pDependencies = nullptr;

+ }

+

+ // These are only used if we use multiview but we need to define them in scope.

+ const uint32_t view_mask = (1 << p_view_count) - 1;

+ const uint32_t correlation_mask = (1 << p_view_count) - 1;

+ Vector<uint32_t> view_masks;

+ VkRenderPassMultiviewCreateInfo render_pass_multiview_create_info;

+

+ if (p_view_count > 1) {

+ const VulkanContext::MultiviewCapabilities capabilities = context->get_multiview_capabilities();

+

+ // For now this only works with multiview!

+ ERR_FAIL_COND_V_MSG(!capabilities.is_supported, VK_NULL_HANDLE, "Multiview not supported");

+

+ // 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

+ for (uint32_t i = 0; i < subpasses.size(); i++) {

+ view_masks.push_back(view_mask);

+ };

+

+ render_pass_multiview_create_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO;

+ render_pass_multiview_create_info.pNext = nullptr;

+ render_pass_multiview_create_info.subpassCount = subpasses.size();

+ render_pass_multiview_create_info.pViewMasks = view_masks.ptr();

+ render_pass_multiview_create_info.dependencyCount = 0;

+ render_pass_multiview_create_info.pViewOffsets = nullptr;

+ render_pass_multiview_create_info.correlationMaskCount = 1;

+ render_pass_multiview_create_info.pCorrelationMasks = &correlation_mask;

+

+ render_pass_create_info.pNext = &render_pass_multiview_create_info;

+ }

+RenderingDevice::FramebufferFormatID RenderingDeviceVulkan::framebuffer_format_create(const Vector<AttachmentFormat> &p_format, uint32_t p_view_count) {

+ FramebufferPass pass;

+ for (int i = 0; i < p_format.size(); i++) {

+ if (p_format[i].usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {

+ pass.depth_attachment = i;

+ } else {

+ pass.color_attachments.push_back(i);

+ }

+ }

+

+ Vector<FramebufferPass> passes;

+ passes.push_back(pass);

+ return framebuffer_format_create_multipass(p_format, passes, p_view_count);

+}

+RenderingDevice::FramebufferFormatID RenderingDeviceVulkan::framebuffer_format_create_multipass(const Vector<AttachmentFormat> &p_attachments, Vector<FramebufferPass> &p_passes, uint32_t p_view_count) {

+ key.attachments = p_attachments;

+ key.passes = p_passes;

+ key.view_count = p_view_count;

+ 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

+ fb_format.pass_samples = samples;

+ fb_format.view_count = p_view_count;

+ key.passes.push_back(FramebufferPass());

+ fb_format.pass_samples.push_back(p_samples);

+RenderingDevice::TextureSamples RenderingDeviceVulkan::framebuffer_format_get_texture_samples(FramebufferFormatID p_format, uint32_t p_pass) {

+ ERR_FAIL_COND_V(p_pass >= uint32_t(E->get().pass_samples.size()), TEXTURE_SAMPLES_1);

+ return E->get().pass_samples[p_pass];

+ framebuffer.view_count = 1;

+RID RenderingDeviceVulkan::framebuffer_create(const Vector<RID> &p_texture_attachments, FramebufferFormatID p_format_check, uint32_t p_view_count) {

+ _THREAD_SAFE_METHOD_

+

+ FramebufferPass pass;

+

+ for (int i = 0; i < p_texture_attachments.size(); i++) {

+ Texture *texture = texture_owner.getornull(p_texture_attachments[i]);

+ ERR_FAIL_COND_V_MSG(!texture, RID(), "Texture index supplied for framebuffer (" + itos(i) + ") is not a valid texture.");

+

+ ERR_FAIL_COND_V_MSG(texture->layers != p_view_count, RID(), "Layers of our texture doesn't match view count for this framebuffer");

+

+ if (texture->usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {

+ pass.depth_attachment = i;

+ } else {

+ pass.color_attachments.push_back(i);

+ }

+ }

+

+ Vector<FramebufferPass> passes;

+ passes.push_back(pass);

+

+ return framebuffer_create_multipass(p_texture_attachments, passes, p_format_check, p_view_count);

+}

+

+RID RenderingDeviceVulkan::framebuffer_create_multipass(const Vector<RID> &p_texture_attachments, Vector<FramebufferPass> &p_passes, FramebufferFormatID p_format_check, uint32_t p_view_count) {

+ ERR_FAIL_COND_V_MSG(texture->layers != p_view_count, RID(), "Layers of our texture doesn't match view count for this framebuffer");

+

+ FramebufferFormatID format_id = framebuffer_format_create_multipass(attachments, p_passes, p_view_count);

+ framebuffer.view_count = p_view_count;

+#define SHADER_BINARY_VERSION 1

+String RenderingDeviceVulkan::shader_get_binary_cache_key() const {

+ return "Vulkan-SV" + itos(SHADER_BINARY_VERSION);

+}

+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)

+};

+struct RenderingDeviceVulkanShaderBinarySpecializationConstant {

+ uint32_t type;

+ uint32_t constant_id;

+ union {

+ uint32_t int_value;

+ float float_value;

+ bool bool_value;

+ };

+ uint32_t stage_flags;

+};

+struct RenderingDeviceVulkanShaderBinaryData {

+ uint32_t vertex_input_mask;

+ uint32_t fragment_outputs;

+ uint32_t specialization_constant_count;

+ uint32_t is_compute;

+ uint32_t compute_local_size[3];

+ uint32_t set_count;

+ uint32_t push_constant_size;

+ uint32_t push_constants_vk_stage;

+ uint32_t stage_count;

+};

+

+Vector<uint8_t> RenderingDeviceVulkan::shader_compile_binary_from_spirv(const Vector<ShaderStageSPIRVData> &p_spirv) {

+ RenderingDeviceVulkanShaderBinaryData binary_data;

+ binary_data.vertex_input_mask = 0;

+ binary_data.fragment_outputs = 0;

+ binary_data.specialization_constant_count = 0;

+ binary_data.is_compute = 0;

+ binary_data.compute_local_size[0] = 0;

+ binary_data.compute_local_size[1] = 0;

+ binary_data.compute_local_size[2] = 0;

+ binary_data.set_count = 0;

+ binary_data.push_constant_size = 0;

+ binary_data.push_constants_vk_stage = 0;

+

+ Vector<Vector<RenderingDeviceVulkanShaderBinaryDataBinding>> uniform_info; //set bindings

+ Vector<RenderingDeviceVulkanShaderBinarySpecializationConstant> specialization_constants;

+ uint32_t stages_processed = 0;

+ for (int i = 0; i < p_spirv.size(); i++) {

+ if (p_spirv[i].shader_stage == SHADER_STAGE_COMPUTE) {

+ binary_data.is_compute = true;

+ ERR_FAIL_COND_V_MSG(p_spirv.size() != 1, Vector<uint8_t>(),

+ ERR_FAIL_COND_V_MSG(stages_processed & (1 << p_spirv[i].shader_stage), Vector<uint8_t>(),

+ "Stage " + String(shader_stage_names[p_spirv[i].shader_stage]) + " submitted more than once.");

+ const uint8_t *spirv = p_spirv[i].spir_v.ptr();

+ SpvReflectResult result = spvReflectCreateShaderModule(p_spirv[i].spir_v.size(), spirv, &module);

+ ERR_FAIL_COND_V_MSG(result != SPV_REFLECT_RESULT_SUCCESS, Vector<uint8_t>(),

+ "Reflection of SPIR-V shader stage '" + String(shader_stage_names[p_spirv[i].shader_stage]) + "' failed parsing shader.");

+

+ if (binary_data.is_compute) {

+ binary_data.compute_local_size[0] = module.entry_points->local_size.x;

+ binary_data.compute_local_size[1] = module.entry_points->local_size.y;

+ binary_data.compute_local_size[2] = module.entry_points->local_size.z;

+ ERR_FAIL_COND_V_MSG(result != SPV_REFLECT_RESULT_SUCCESS, Vector<uint8_t>(),

+ "Reflection of SPIR-V shader stage '" + String(shader_stage_names[p_spirv[i].shader_stage]) + "' failed enumerating descriptor bindings.");

+ uint32_t stage = p_spirv[i].shader_stage;

+ ERR_FAIL_COND_V_MSG(result != SPV_REFLECT_RESULT_SUCCESS, Vector<uint8_t>(),

+ "Reflection of SPIR-V shader stage '" + String(shader_stage_names[p_spirv[i].shader_stage]) + "' failed getting descriptor bindings.");

+ RenderingDeviceVulkanShaderBinaryDataBinding info;

+ need_array_dimensions = true;

+ ERR_FAIL_COND_V_MSG(set >= MAX_UNIFORM_SETS, Vector<uint8_t>(),

+ ERR_FAIL_COND_V_MSG(set >= limits.maxBoundDescriptorSets, Vector<uint8_t>(),

+ if (set < (uint32_t)uniform_info.size()) {

+ for (int k = 0; k < uniform_info[set].size(); k++) {

+ if (uniform_info[set][k].binding == (uint32_t)info.binding) {

+ ERR_FAIL_COND_V_MSG(uniform_info[set][k].type != info.type, Vector<uint8_t>(),

+ ERR_FAIL_COND_V_MSG(uniform_info[set][k].length != info.length, Vector<uint8_t>(),

+ if (set >= (uint32_t)uniform_info.size()) {

+ {

+ //specialization constants

+

+ uint32_t sc_count = 0;

+ result = spvReflectEnumerateSpecializationConstants(&module, &sc_count, nullptr);

+ ERR_FAIL_COND_V_MSG(result != SPV_REFLECT_RESULT_SUCCESS, Vector<uint8_t>(),

+ "Reflection of SPIR-V shader stage '" + String(shader_stage_names[p_spirv[i].shader_stage]) + "' failed enumerating specialization constants.");

+

+ if (sc_count) {

+ Vector<SpvReflectSpecializationConstant *> spec_constants;

+ spec_constants.resize(sc_count);

+

+ result = spvReflectEnumerateSpecializationConstants(&module, &sc_count, spec_constants.ptrw());

+ ERR_FAIL_COND_V_MSG(result != SPV_REFLECT_RESULT_SUCCESS, Vector<uint8_t>(),

+ "Reflection of SPIR-V shader stage '" + String(shader_stage_names[p_spirv[i].shader_stage]) + "' failed obtaining specialization constants.");

+

+ for (uint32_t j = 0; j < sc_count; j++) {

+ int32_t existing = -1;

+ RenderingDeviceVulkanShaderBinarySpecializationConstant sconst;

+ sconst.constant_id = spec_constants[j]->constant_id;

+ switch (spec_constants[j]->constant_type) {

+ case SPV_REFLECT_SPECIALIZATION_CONSTANT_BOOL: {

+ sconst.type = PIPELINE_SPECIALIZATION_CONSTANT_TYPE_BOOL;

+ sconst.bool_value = spec_constants[j]->default_value.int_bool_value != 0;

+ } break;

+ case SPV_REFLECT_SPECIALIZATION_CONSTANT_INT: {

+ sconst.type = PIPELINE_SPECIALIZATION_CONSTANT_TYPE_INT;

+ sconst.int_value = spec_constants[j]->default_value.int_bool_value;

+ } break;

+ case SPV_REFLECT_SPECIALIZATION_CONSTANT_FLOAT: {

+ sconst.type = PIPELINE_SPECIALIZATION_CONSTANT_TYPE_FLOAT;

+ sconst.float_value = spec_constants[j]->default_value.float_value;

+ } break;

+ }

+ sconst.stage_flags = 1 << p_spirv[i].shader_stage;

+

+ for (int k = 0; k < specialization_constants.size(); k++) {

+ if (specialization_constants[k].constant_id == sconst.constant_id) {

+ ERR_FAIL_COND_V_MSG(specialization_constants[k].type != sconst.type, Vector<uint8_t>(), "More than one specialization constant used for id (" + itos(sconst.constant_id) + "), but their types differ.");

+ ERR_FAIL_COND_V_MSG(specialization_constants[k].int_value != sconst.int_value, Vector<uint8_t>(), "More than one specialization constant used for id (" + itos(sconst.constant_id) + "), but their default values differ.");

+ existing = k;

+ break;

+ }

+ }

+

+ if (existing > 0) {

+ specialization_constants.write[existing].stage_flags |= sconst.stage_flags;

+ } else {

+ specialization_constants.push_back(sconst);

+ }

+ }

+ }

+ }

+

+ ERR_FAIL_COND_V_MSG(result != SPV_REFLECT_RESULT_SUCCESS, Vector<uint8_t>(),

+ "Reflection of SPIR-V shader stage '" + String(shader_stage_names[p_spirv[i].shader_stage]) + "' failed enumerating input variables.");

+ ERR_FAIL_COND_V_MSG(result != SPV_REFLECT_RESULT_SUCCESS, Vector<uint8_t>(),

+ "Reflection of SPIR-V shader stage '" + String(shader_stage_names[p_spirv[i].shader_stage]) + "' failed obtaining input variables.");

+ binary_data.vertex_input_mask |= (1 << uint32_t(input_vars[j]->location));

+ ERR_FAIL_COND_V_MSG(result != SPV_REFLECT_RESULT_SUCCESS, Vector<uint8_t>(),

+ "Reflection of SPIR-V shader stage '" + String(shader_stage_names[p_spirv[i].shader_stage]) + "' failed enumerating output variables.");

+ ERR_FAIL_COND_V_MSG(result != SPV_REFLECT_RESULT_SUCCESS, Vector<uint8_t>(),

+ "Reflection of SPIR-V shader stage '" + String(shader_stage_names[p_spirv[i].shader_stage]) + "' failed obtaining output variables.");

+ const SpvReflectInterfaceVariable *refvar = output_vars[j];

+ if (refvar != nullptr && refvar->built_in != SpvBuiltInFragDepth) {

+ binary_data.fragment_outputs |= 1 << refvar->location;

+ ERR_FAIL_COND_V_MSG(result != SPV_REFLECT_RESULT_SUCCESS, Vector<uint8_t>(),

+ "Reflection of SPIR-V shader stage '" + String(shader_stage_names[p_spirv[i].shader_stage]) + "' failed enumerating push constants.");

+ ERR_FAIL_COND_V_MSG(pc_count > 1, Vector<uint8_t>(),

+ "Reflection of SPIR-V shader stage '" + String(shader_stage_names[p_spirv[i].shader_stage]) + "': Only one push constant is supported, which should be the same across shader stages.");

+ ERR_FAIL_COND_V_MSG(result != SPV_REFLECT_RESULT_SUCCESS, Vector<uint8_t>(),

+ "Reflection of SPIR-V shader stage '" + String(shader_stage_names[p_spirv[i].shader_stage]) + "' failed obtaining push constants.");

+ ERR_FAIL_COND_V_MSG(binary_data.push_constant_size && binary_data.push_constant_size != pconstants[0]->size, Vector<uint8_t>(),

+ "Reflection of SPIR-V shader stage '" + String(shader_stage_names[p_spirv[i].shader_stage]) + "': Push constant block must be the same across shader stages.");

+ binary_data.push_constant_size = pconstants[0]->size;

+ binary_data.push_constants_vk_stage |= shader_stage_masks[stage];

+ stages_processed |= (1 << p_spirv[i].shader_stage);

+ }

+

+ Vector<Vector<uint8_t>> compressed_stages;

+ Vector<uint32_t> smolv_size;

+ Vector<uint32_t> zstd_size; //if 0, stdno t used

+

+ uint32_t stages_binary_size = 0;

+

+ bool strip_debug = false;

+

+ for (int i = 0; i < p_spirv.size(); i++) {

+ smolv::ByteArray smolv;

+ if (!smolv::Encode(p_spirv[i].spir_v.ptr(), p_spirv[i].spir_v.size(), smolv, strip_debug ? smolv::kEncodeFlagStripDebugInfo : 0)) {

+ 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

+ 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);

+

+ if (dst_size > 0 && (uint32_t)dst_size < smolv.size()) {

+ zstd_size.push_back(dst_size);

+ zstd.resize(dst_size);

+ compressed_stages.push_back(zstd);

+ } else {

+ Vector<uint8_t> smv;

+ smv.resize(smolv.size());

+ memcpy(smv.ptrw(), &smolv[0], smolv.size());

+ zstd_size.push_back(0); //not using zstd

+ compressed_stages.push_back(smv);

+ }

+ }

+ }

+ uint32_t s = compressed_stages[i].size();

+ if (s % 4 != 0) {

+ s += 4 - (s % 4);

+ }

+ stages_binary_size += s;

+ }

+

+ binary_data.specialization_constant_count = specialization_constants.size();

+ binary_data.set_count = uniform_info.size();

+ binary_data.stage_count = p_spirv.size();

+

+ uint32_t total_size = sizeof(uint32_t) * 3; //header + version + main datasize;

+ total_size += sizeof(RenderingDeviceVulkanShaderBinaryData);

+

+ for (int i = 0; i < uniform_info.size(); i++) {

+ total_size += sizeof(uint32_t);

+ total_size += uniform_info[i].size() * sizeof(RenderingDeviceVulkanShaderBinaryDataBinding);

+ }

+

+ total_size += sizeof(RenderingDeviceVulkanShaderBinarySpecializationConstant) * specialization_constants.size();

+

+ total_size += compressed_stages.size() * sizeof(uint32_t) * 3; //sizes

+ total_size += stages_binary_size;

+

+ Vector<uint8_t> ret;

+ ret.resize(total_size);

+ uint32_t offset = 0;

+ {

+ uint8_t *binptr = ret.ptrw();

+ binptr[0] = 'G';

+ binptr[1] = 'V';

+ binptr[2] = 'B';

+ binptr[3] = 'D'; //godot vulkan binary data

+ offset += 4;

+ encode_uint32(SHADER_BINARY_VERSION, binptr + offset);

+ offset += sizeof(uint32_t);

+ encode_uint32(sizeof(RenderingDeviceVulkanShaderBinaryData), binptr + offset);

+ offset += sizeof(uint32_t);

+ memcpy(binptr + offset, &binary_data, sizeof(RenderingDeviceVulkanShaderBinaryData));

+ offset += sizeof(RenderingDeviceVulkanShaderBinaryData);

+

+ for (int i = 0; i < uniform_info.size(); i++) {

+ int count = uniform_info[i].size();

+ encode_uint32(count, binptr + offset);

+ offset += sizeof(uint32_t);

+ if (count > 0) {

+ memcpy(binptr + offset, uniform_info[i].ptr(), sizeof(RenderingDeviceVulkanShaderBinaryDataBinding) * count);

+ offset += sizeof(RenderingDeviceVulkanShaderBinaryDataBinding) * count;

+ }

+ }

+

+ if (specialization_constants.size()) {

+ memcpy(binptr + offset, specialization_constants.ptr(), sizeof(RenderingDeviceVulkanShaderBinarySpecializationConstant) * specialization_constants.size());

+ offset += sizeof(RenderingDeviceVulkanShaderBinarySpecializationConstant) * specialization_constants.size();

+ }

+

+ for (int i = 0; i < compressed_stages.size(); i++) {

+ encode_uint32(p_spirv[i].shader_stage, binptr + offset);

+ offset += sizeof(uint32_t);

+ encode_uint32(smolv_size[i], binptr + offset);

+ offset += sizeof(uint32_t);

+ encode_uint32(zstd_size[i], binptr + offset);

+ offset += sizeof(uint32_t);

+ memcpy(binptr + offset, compressed_stages[i].ptr(), compressed_stages[i].size());

+

+ uint32_t s = compressed_stages[i].size();

+

+ if (s % 4 != 0) {

+ s += 4 - (s % 4);

+ }

+

+ offset += s;

+ }

+

+ ERR_FAIL_COND_V(offset != (uint32_t)ret.size(), Vector<uint8_t>());

+ }

+

+ return ret;

+}

+

+RID RenderingDeviceVulkan::shader_create_from_bytecode(const Vector<uint8_t> &p_shader_binary) {

+ const uint8_t *binptr = p_shader_binary.ptr();

+ uint32_t binsize = p_shader_binary.size();

+

+ uint32_t read_offset = 0;

+ //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());

+

+ uint32_t bin_version = decode_uint32(binptr + 4);

+ ERR_FAIL_COND_V(bin_version > SHADER_BINARY_VERSION, RID());

+

+ uint32_t bin_data_size = decode_uint32(binptr + 8);

+

+ const RenderingDeviceVulkanShaderBinaryData &binary_data = *(const RenderingDeviceVulkanShaderBinaryData *)(binptr + 12);

+

+ Shader::PushConstant push_constant;

+ push_constant.push_constant_size = binary_data.push_constant_size;

+ push_constant.push_constants_vk_stage = binary_data.push_constants_vk_stage;

+

+ uint32_t vertex_input_mask = binary_data.vertex_input_mask;

+

+ uint32_t fragment_outputs = binary_data.fragment_outputs;

+

+ bool is_compute = binary_data.is_compute;

+

+ uint32_t compute_local_size[3] = { binary_data.compute_local_size[0], binary_data.compute_local_size[1], binary_data.compute_local_size[2] };

+

+ read_offset += sizeof(uint32_t) * 3 + bin_data_size;

+

+ Vector<Vector<VkDescriptorSetLayoutBinding>> set_bindings;

+ Vector<Vector<UniformInfo>> uniform_info;

+

+ set_bindings.resize(binary_data.set_count);

+ uniform_info.resize(binary_data.set_count);

+

+ for (uint32_t i = 0; i < binary_data.set_count; i++) {

+ ERR_FAIL_COND_V(read_offset + sizeof(uint32_t) >= binsize, RID());

+ uint32_t set_count = decode_uint32(binptr + read_offset);

+ read_offset += sizeof(uint32_t);

+ const RenderingDeviceVulkanShaderBinaryDataBinding *set_ptr = (const RenderingDeviceVulkanShaderBinaryDataBinding *)(binptr + read_offset);

+ uint32_t set_size = set_count * sizeof(RenderingDeviceVulkanShaderBinaryDataBinding);

+ ERR_FAIL_COND_V(read_offset + set_size >= binsize, RID());

+

+ for (uint32_t j = 0; j < set_count; j++) {

+ UniformInfo info;

+ info.type = UniformType(set_ptr[j].type);

+ info.length = set_ptr[j].length;

+ info.binding = set_ptr[j].binding;

+ info.stages = set_ptr[j].stages;

+

+ VkDescriptorSetLayoutBinding layout_binding;

+ layout_binding.pImmutableSamplers = nullptr;

+ layout_binding.binding = set_ptr[j].binding;

+ layout_binding.descriptorCount = 1;

+ layout_binding.stageFlags = 0;

+ for (uint32_t k = 0; k < SHADER_STAGE_MAX; k++) {

+ if (set_ptr[j].stages & (1 << k)) {

+ layout_binding.stageFlags |= shader_stage_masks[k];

+ }

+ }

+

+ switch (info.type) {

+ case UNIFORM_TYPE_SAMPLER: {

+ layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER;

+ layout_binding.descriptorCount = set_ptr[j].length;

+ } break;

+ case UNIFORM_TYPE_SAMPLER_WITH_TEXTURE: {

+ layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;

+ layout_binding.descriptorCount = set_ptr[j].length;

+ } break;

+ case UNIFORM_TYPE_TEXTURE: {

+ layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;

+ layout_binding.descriptorCount = set_ptr[j].length;

+ } break;

+ case UNIFORM_TYPE_IMAGE: {

+ layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;

+ layout_binding.descriptorCount = set_ptr[j].length;

+ } break;

+ case UNIFORM_TYPE_TEXTURE_BUFFER: {

+ layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;

+ layout_binding.descriptorCount = set_ptr[j].length;

+ } break;

+ case UNIFORM_TYPE_IMAGE_BUFFER: {

+ layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;

+ } break;

+ case UNIFORM_TYPE_UNIFORM_BUFFER: {

+ layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;

+ } break;

+ case UNIFORM_TYPE_STORAGE_BUFFER: {

+ layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;

+ } break;

+ case UNIFORM_TYPE_INPUT_ATTACHMENT: {

+ layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;

+ } break;

+ default: {

+ ERR_FAIL_V(RID());

+ }

+ }

+

+ set_bindings.write[i].push_back(layout_binding);

+ uniform_info.write[i].push_back(info);

+ }

+

+ read_offset += set_size;

+ }

+

+ ERR_FAIL_COND_V(read_offset + binary_data.specialization_constant_count * sizeof(RenderingDeviceVulkanShaderBinarySpecializationConstant) >= binsize, RID());

+

+ Vector<Shader::SpecializationConstant> specialization_constants;

+

+ for (uint32_t i = 0; i < binary_data.specialization_constant_count; i++) {

+ const RenderingDeviceVulkanShaderBinarySpecializationConstant &src_sc = *(const RenderingDeviceVulkanShaderBinarySpecializationConstant *)(binptr + read_offset);

+ Shader::SpecializationConstant sc;

+ sc.constant.int_value = src_sc.int_value;

+ sc.constant.type = PipelineSpecializationConstantType(src_sc.type);

+ sc.constant.constant_id = src_sc.constant_id;

+ sc.stage_flags = src_sc.stage_flags;

+ specialization_constants.push_back(sc);

+

+ read_offset += sizeof(RenderingDeviceVulkanShaderBinarySpecializationConstant);

+ }

+

+ Vector<Vector<uint8_t>> stage_spirv_data;

+ Vector<ShaderStage> stage_type;

+

+ for (uint32_t i = 0; i < binary_data.stage_count; i++) {

+ ERR_FAIL_COND_V(read_offset + sizeof(uint32_t) * 3 >= binsize, RID());

+ uint32_t stage = decode_uint32(binptr + read_offset);

+ read_offset += sizeof(uint32_t);

+ uint32_t smolv_size = decode_uint32(binptr + read_offset);

+ read_offset += sizeof(uint32_t);

+ uint32_t zstd_size = decode_uint32(binptr + read_offset);

+ read_offset += sizeof(uint32_t);

+

+ uint32_t buf_size = (zstd_size > 0) ? zstd_size : smolv_size;

+

+ Vector<uint8_t> smolv;

+ const uint8_t *src_smolv = nullptr;

+

+ if (zstd_size > 0) {

+ //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());

+ src_smolv = smolv.ptr();

+ } else {

+ src_smolv = binptr + read_offset;

+ }

+

+ Vector<uint8_t> spirv;

+ uint32_t spirv_size = smolv::GetDecodedBufferSize(src_smolv, smolv_size);

+ spirv.resize(spirv_size);

+ if (!smolv::Decode(src_smolv, smolv_size, spirv.ptrw(), spirv_size)) {

+ ERR_FAIL_V_MSG(RID(), "Malformed smolv input uncompressing shader stage:" + String(shader_stage_names[stage]));

+ }

+ stage_spirv_data.push_back(spirv);

+ stage_type.push_back(ShaderStage(stage));

+

+ if (buf_size % 4 != 0) {

+ buf_size += 4 - (buf_size % 4);

+ }

+

+ ERR_FAIL_COND_V(read_offset + buf_size > binsize, RID());

+

+ read_offset += buf_size;

+ ERR_FAIL_COND_V(read_offset != binsize, RID());

+

+ shader.fragment_output_mask = fragment_outputs;

+ shader.specialization_constants = specialization_constants;

+ for (int i = 0; i < stage_spirv_data.size(); i++) {

+ shader_module_create_info.codeSize = stage_spirv_data[i].size();

+ const uint8_t *r = stage_spirv_data[i].ptr();

+ error_text = "Error (" + itos(res) + ") creating shader module for stage: " + String(shader_stage_names[stage_type[i]]);

+ shader_stage.stage = shader_stage_bits[stage_type[i]];

+ if (texture->usage_flags & (TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | TEXTURE_USAGE_INPUT_ATTACHMENT_BIT)) {

+ if (texture->usage_flags & (TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | TEXTURE_USAGE_INPUT_ATTACHMENT_BIT)) {

+ ERR_FAIL_COND_V_MSG(shader->is_compute, RID(), "InputAttachment (binding: " + itos(uniform.binding) + ") supplied for compute shader (this is not allowed).");

+

+ if (uniform.ids.size() != set_uniform.length) {

+ if (set_uniform.length > 1) {

+ ERR_FAIL_V_MSG(RID(), "InputAttachment (binding: " + itos(uniform.binding) + ") is an array of (" + itos(set_uniform.length) + ") textures, so it should be provided equal number of texture IDs to satisfy it (IDs provided: " + itos(uniform.ids.size()) + ").");

+ } else {

+ ERR_FAIL_V_MSG(RID(), "InputAttachment (binding: " + itos(uniform.binding) + ") should provide one ID referencing a texture (IDs provided: " + itos(uniform.ids.size()) + ").");

+ }

+ }

+

+ Vector<VkDescriptorImageInfo> image_info;

+

+ for (int j = 0; j < uniform.ids.size(); j++) {

+ Texture *texture = texture_owner.getornull(uniform.ids[j]);

+

+ ERR_FAIL_COND_V_MSG(!texture, RID(),

+ "InputAttachment (binding: " + itos(uniform.binding) + ", index " + itos(j) + ") is not a valid texture.");

+

+ ERR_FAIL_COND_V_MSG(!(texture->usage_flags & TEXTURE_USAGE_SAMPLING_BIT), RID(),

+ "InputAttachment (binding: " + itos(uniform.binding) + ", index " + itos(j) + ") needs the TEXTURE_USAGE_SAMPLING_BIT usage flag set in order to be used as uniform.");

+

+ VkDescriptorImageInfo img_info;

+ img_info.sampler = VK_NULL_HANDLE;

+ img_info.imageView = texture->view;

+

+ if (texture->owner.is_valid()) {

+ texture = texture_owner.getornull(texture->owner);

+ ERR_FAIL_COND_V(!texture, RID()); //bug, should never happen

+ }

+

+ img_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;

+

+ image_info.push_back(img_info);

+ }

+

+ write.dstArrayElement = 0;

+ write.descriptorCount = uniform.ids.size();

+ write.descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;

+ write.pImageInfo = image_infos.push_back(image_info)->get().ptr();

+ write.pBufferInfo = nullptr;

+ write.pTexelBufferView = nullptr;

+

+ type_size = uniform.ids.size();

+void RenderingDeviceVulkan::uniform_set_set_invalidation_callback(RID p_uniform_set, UniformSetInvalidatedCallback p_callback, void *p_userdata) {

+ UniformSet *us = uniform_set_owner.getornull(p_uniform_set);

+ ERR_FAIL_COND(!us);

+ us->invalidated_callback = p_callback;

+ us->invalidated_callback_userdata = p_userdata;

+}

+

+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) {

+ 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];

+ uint32_t output_mask = 0;

+ for (int i = 0; i < pass.color_attachments.size(); i++) {

+ if (pass.color_attachments[i] != FramebufferPass::ATTACHMENT_UNUSED) {

+ output_mask |= 1 << i;

+ }

+ }

+ 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.");

+ ERR_FAIL_COND_V(limits.maxTessellationPatchSize > 0 && (p_rasterization_state.patch_control_points < 1 || p_rasterization_state.patch_control_points > limits.maxTessellationPatchSize), RID());

+ {

+ const FramebufferPass &pass = fb_format.E->key().passes[p_for_render_pass];

+

+ for (int i = 0; i < pass.color_attachments.size(); i++) {

+ if (pass.color_attachments[i] != FramebufferPass::ATTACHMENT_UNUSED) {

+ int idx = attachment_states.size();

+

+ ERR_FAIL_INDEX_V(idx, p_blend_state.attachments.size(), RID());

+ VkPipelineColorBlendAttachmentState state;

+ state.blendEnable = p_blend_state.attachments[idx].enable_blend;

+

+ ERR_FAIL_INDEX_V(p_blend_state.attachments[idx].src_color_blend_factor, BLEND_FACTOR_MAX, RID());

+ state.srcColorBlendFactor = blend_factors[p_blend_state.attachments[idx].src_color_blend_factor];

+ ERR_FAIL_INDEX_V(p_blend_state.attachments[idx].dst_color_blend_factor, BLEND_FACTOR_MAX, RID());

+ state.dstColorBlendFactor = blend_factors[p_blend_state.attachments[idx].dst_color_blend_factor];

+ ERR_FAIL_INDEX_V(p_blend_state.attachments[idx].color_blend_op, BLEND_OP_MAX, RID());

+ state.colorBlendOp = blend_operations[p_blend_state.attachments[idx].color_blend_op];

+

+ ERR_FAIL_INDEX_V(p_blend_state.attachments[idx].src_alpha_blend_factor, BLEND_FACTOR_MAX, RID());

+ state.srcAlphaBlendFactor = blend_factors[p_blend_state.attachments[idx].src_alpha_blend_factor];

+ ERR_FAIL_INDEX_V(p_blend_state.attachments[idx].dst_alpha_blend_factor, BLEND_FACTOR_MAX, RID());

+ state.dstAlphaBlendFactor = blend_factors[p_blend_state.attachments[idx].dst_alpha_blend_factor];

+ ERR_FAIL_INDEX_V(p_blend_state.attachments[idx].alpha_blend_op, BLEND_OP_MAX, RID());

+ state.alphaBlendOp = blend_operations[p_blend_state.attachments[idx].alpha_blend_op];

+

+ state.colorWriteMask = 0;

+ if (p_blend_state.attachments[idx].write_r) {

+ state.colorWriteMask |= VK_COLOR_COMPONENT_R_BIT;

+ }

+ if (p_blend_state.attachments[idx].write_g) {

+ state.colorWriteMask |= VK_COLOR_COMPONENT_G_BIT;

+ }

+ if (p_blend_state.attachments[idx].write_b) {

+ state.colorWriteMask |= VK_COLOR_COMPONENT_B_BIT;

+ }

+ if (p_blend_state.attachments[idx].write_a) {

+ state.colorWriteMask |= VK_COLOR_COMPONENT_A_BIT;

+ }

+ attachment_states.push_back(state);

+ idx++;

+ };

+ ERR_FAIL_COND_V(attachment_states.size() != p_blend_state.attachments.size(), RID());

+ }

+ Vector<VkPipelineShaderStageCreateInfo> pipeline_stages = shader->pipeline_stages;

+ Vector<VkSpecializationInfo> specialization_info;

+ Vector<Vector<VkSpecializationMapEntry>> specialization_map_entries;

+ Vector<uint32_t> specialization_constant_data;

+

+ if (shader->specialization_constants.size()) {

+ specialization_constant_data.resize(shader->specialization_constants.size());

+ uint32_t *data_ptr = specialization_constant_data.ptrw();

+ 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

+ const Shader::SpecializationConstant &sc = shader->specialization_constants[i];

+ 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];

+ if (psc.constant_id == sc.constant.constant_id) {

+ ERR_FAIL_COND_V_MSG(psc.type != sc.constant.type, RID(), "Specialization constant provided for id (" + itos(sc.constant.constant_id) + ") is of the wrong type.");

+ data_ptr[i] = psc.int_value;

+ break;

+ }

+ }

+

+ VkSpecializationMapEntry entry;

+

+ entry.constantID = sc.constant.constant_id;

+ entry.offset = i * sizeof(uint32_t);

+ entry.size = sizeof(uint32_t);

+

+ for (int j = 0; j < SHADER_STAGE_MAX; j++) {

+ if (sc.stage_flags & (1 << j)) {

+ VkShaderStageFlagBits stage = shader_stage_masks[j];

+ for (int k = 0; k < pipeline_stages.size(); k++) {

+ if (pipeline_stages[k].stage == stage) {

+ specialization_map_entries.write[k].push_back(entry);

+ }

+ }

+ }

+ }

+ }

+

+ for (int i = 0; i < pipeline_stages.size(); i++) {

+ if (specialization_map_entries[i].size()) {

+ specialization_info.write[i].dataSize = specialization_constant_data.size() * sizeof(uint32_t);

+ specialization_info.write[i].pData = data_ptr;

+ specialization_info.write[i].mapEntryCount = specialization_map_entries[i].size();

+ specialization_info.write[i].pMapEntries = specialization_map_entries[i].ptr();

+

+ pipeline_stages.write[i].pSpecializationInfo = specialization_info.ptr() + i;

+ }

+ }

+ }

+

+ graphics_pipeline_create_info.stageCount = pipeline_stages.size();

+ graphics_pipeline_create_info.pStages = pipeline_stages.ptr();

+

+ graphics_pipeline_create_info.subpass = p_for_render_pass;

+ pipeline.validation.render_pass = p_for_render_pass;

+RID RenderingDeviceVulkan::compute_pipeline_create(RID p_shader, const Vector<PipelineSpecializationConstant> &p_specialization_constants) {

+ VkSpecializationInfo specialization_info;

+ Vector<VkSpecializationMapEntry> specialization_map_entries;

+ Vector<uint32_t> specialization_constant_data;

+

+ if (shader->specialization_constants.size()) {

+ 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

+ const Shader::SpecializationConstant &sc = shader->specialization_constants[i];

+ 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];

+ if (psc.constant_id == sc.constant.constant_id) {

+ ERR_FAIL_COND_V_MSG(psc.type != sc.constant.type, RID(), "Specialization constant provided for id (" + itos(sc.constant.constant_id) + ") is of the wrong type.");

+ data_ptr[i] = sc.constant.int_value;

+ break;

+ }

+ }

+

+ VkSpecializationMapEntry entry;

+

+ entry.constantID = sc.constant.constant_id;

+ entry.offset = i * sizeof(uint32_t);

+ entry.size = sizeof(uint32_t);

+

+ specialization_map_entries.push_back(entry);

+ }

+

+ specialization_info.dataSize = specialization_constant_data.size() * sizeof(uint32_t);

+ specialization_info.pData = data_ptr;

+ specialization_info.mapEntryCount = specialization_map_entries.size();

+ specialization_info.pMapEntries = specialization_map_entries.ptr();

+

+ compute_pipeline_create_info.stage.pSpecializationInfo = &specialization_info;

+ }

+

+

+ Size2i size = Size2i(context->window_get_width(p_screen), context->window_get_height(p_screen));

+

+ _draw_list_allocate(Rect2i(Vector2i(), size), 0, 0);

+ draw_list_framebuffer_format = screen_get_framebuffer_format();

+ draw_list_subpass_count = 1;

+ render_pass_begin.renderArea.extent.width = size.width;

+ render_pass_begin.renderArea.extent.height = size.height;

+Error RenderingDeviceVulkan::_draw_list_setup_framebuffer(Framebuffer *p_framebuffer, InitialAction p_initial_color_action, FinalAction p_final_color_action, InitialAction p_initial_depth_action, FinalAction p_final_depth_action, VkFramebuffer *r_framebuffer, VkRenderPass *r_render_pass, uint32_t *r_subpass_count) {

+ vk.view_count = p_framebuffer->view_count;

+ 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);

+ version.subpass_count = framebuffer_formats[p_framebuffer->format_id].E->key().passes.size();

+

+ *r_subpass_count = version.subpass_count;

+ int color_count = 0;

+ for (int i = 0; i < framebuffer->texture_ids.size(); i++) {

+ Texture *texture = texture_owner.getornull(framebuffer->texture_ids[i]);

+

+ if (texture->usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT) {

+ color_count++;

+ }

+ }

+

+ ERR_FAIL_COND_V_MSG(p_clear_color_values.size() != color_count, INVALID_ID,

+ "Clear color values supplied (" + itos(p_clear_color_values.size()) + ") differ from the amount required for framebuffer color attachments (" + itos(color_count) + ").");

+ Error err = _draw_list_setup_framebuffer(framebuffer, p_initial_color_action, p_final_color_action, p_initial_depth_action, p_final_depth_action, &vkframebuffer, &render_pass, &draw_list_subpass_count);

+ draw_list_render_pass = render_pass;

+ draw_list_vkframebuffer = vkframebuffer;

+

+ _draw_list_allocate(Rect2i(viewport_offset, viewport_size), 0, 0);

+ draw_list_framebuffer_format = framebuffer->format_id;

+ draw_list_current_subpass = 0;

+ int color_count = 0;

+ for (int i = 0; i < framebuffer->texture_ids.size(); i++) {

+ Texture *texture = texture_owner.getornull(framebuffer->texture_ids[i]);

+ if (texture->usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT) {

+ color_count++;

+

+ ERR_FAIL_COND_V_MSG(p_clear_color_values.size() != color_count, ERR_INVALID_PARAMETER,

+ "Clear color values supplied (" + itos(p_clear_color_values.size()) + ") differ from the amount required for framebuffer (" + itos(color_count) + ").");

+ Error err = _draw_list_setup_framebuffer(framebuffer, p_initial_color_action, p_final_color_action, p_initial_depth_action, p_final_depth_action, &vkframebuffer, &render_pass, &draw_list_subpass_count);

+ draw_list_current_subpass = 0;

+ draw_list_framebuffer_format = framebuffer->format_id;

+ draw_list_render_pass = render_pass;

+ draw_list_vkframebuffer = vkframebuffer;

+ err = _draw_list_allocate(Rect2i(viewport_offset, viewport_size), p_splits, 0);

+ if (err != OK) {

+ return err;

+ }

+

+ if (needs_clear_color || needs_clear_depth) {

+ _draw_list_insert_clear_region(&draw_list[0], framebuffer, viewport_offset, viewport_size, needs_clear_color, p_clear_color_values, needs_clear_depth, p_clear_depth, p_clear_stencil);

+ }

+ for (uint32_t i = 0; i < p_splits; i++) {

+ vkCmdSetViewport(draw_list[i].command_buffer, 0, 1, &viewport);

+ vkCmdSetScissor(draw_list[i].command_buffer, 0, 1, &scissor);

+ ERR_FAIL_COND(pipeline->validation.framebuffer_format != draw_list_framebuffer_format && pipeline->validation.render_pass != draw_list_current_subpass);

+uint32_t RenderingDeviceVulkan::draw_list_get_current_pass() {

+ return draw_list_current_subpass;

+}

+RenderingDevice::DrawListID RenderingDeviceVulkan::draw_list_switch_to_next_pass() {

+ ERR_FAIL_COND_V(draw_list == nullptr, INVALID_ID);

+ ERR_FAIL_COND_V(draw_list_current_subpass >= draw_list_subpass_count - 1, INVALID_FORMAT_ID);

+

+ draw_list_current_subpass++;

+

+ Rect2i viewport;

+ _draw_list_free(&viewport);

+ vkCmdNextSubpass(frames[frame].draw_command_buffer, VK_SUBPASS_CONTENTS_INLINE);

+

+ _draw_list_allocate(viewport, 0, draw_list_current_subpass);

+

+ return int64_t(ID_TYPE_DRAW_LIST) << ID_BASE_SHIFT;

+}

+Error RenderingDeviceVulkan::draw_list_switch_to_next_pass_split(uint32_t p_splits, DrawListID *r_split_ids) {

+ ERR_FAIL_COND_V(draw_list == nullptr, ERR_INVALID_PARAMETER);

+ ERR_FAIL_COND_V(draw_list_current_subpass >= draw_list_subpass_count - 1, ERR_INVALID_PARAMETER);

+

+ draw_list_current_subpass++;

+

+ Rect2i viewport;

+ _draw_list_free(&viewport);

+

+ vkCmdNextSubpass(frames[frame].draw_command_buffer, VK_SUBPASS_CONTENTS_INLINE);

+

+ _draw_list_allocate(viewport, p_splits, draw_list_current_subpass);

+

+ for (uint32_t i = 0; i < p_splits; i++) {

+ r_split_ids[i] = (int64_t(ID_TYPE_SPLIT_DRAW_LIST) << ID_BASE_SHIFT) + i;

+ }

+

+ return OK;

+}

+

+Error RenderingDeviceVulkan::_draw_list_allocate(const Rect2i &p_viewport, uint32_t p_splits, uint32_t p_subpass) {

+ if (p_splits == 0) {

+ draw_list = memnew(DrawList);

+ draw_list->command_buffer = frames[frame].draw_command_buffer;

+ draw_list->viewport = p_viewport;

+ draw_list_count = 0;

+ draw_list_split = false;

+ } else {

+ if (p_splits > (uint32_t)split_draw_list_allocators.size()) {

+ uint32_t from = split_draw_list_allocators.size();

+ split_draw_list_allocators.resize(p_splits);

+ for (uint32_t i = from; i < p_splits; i++) {

+ VkCommandPoolCreateInfo cmd_pool_info;

+ cmd_pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;

+ cmd_pool_info.pNext = nullptr;

+ cmd_pool_info.queueFamilyIndex = context->get_graphics_queue();

+ cmd_pool_info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;

+

+ VkResult res = vkCreateCommandPool(device, &cmd_pool_info, nullptr, &split_draw_list_allocators.write[i].command_pool);

+ ERR_FAIL_COND_V_MSG(res, ERR_CANT_CREATE, "vkCreateCommandPool failed with error " + itos(res) + ".");

+

+ for (int j = 0; j < frame_count; j++) {

+ VkCommandBuffer command_buffer;

+

+ VkCommandBufferAllocateInfo cmdbuf;

+ //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;

+ cmdbuf.level = VK_COMMAND_BUFFER_LEVEL_SECONDARY;

+ cmdbuf.commandBufferCount = 1;

+

+ VkResult err = vkAllocateCommandBuffers(device, &cmdbuf, &command_buffer);

+ ERR_FAIL_COND_V_MSG(err, ERR_CANT_CREATE, "vkAllocateCommandBuffers failed with error " + itos(err) + ".");

+

+ split_draw_list_allocators.write[i].command_buffers.push_back(command_buffer);

+ }

+ }

+ }

+ draw_list = memnew_arr(DrawList, p_splits);

+ draw_list_count = p_splits;

+ draw_list_split = true;

+

+ for (uint32_t i = 0; i < p_splits; i++) {

+ //take a command buffer and initialize it

+ VkCommandBuffer command_buffer = split_draw_list_allocators[i].command_buffers[frame];

+

+ VkCommandBufferInheritanceInfo inheritance_info;

+ inheritance_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;

+ inheritance_info.pNext = nullptr;

+ inheritance_info.renderPass = draw_list_render_pass;

+ inheritance_info.subpass = p_subpass;

+ inheritance_info.framebuffer = draw_list_vkframebuffer;

+ inheritance_info.occlusionQueryEnable = false;

+ inheritance_info.queryFlags = 0; //?

+ inheritance_info.pipelineStatistics = 0;

+

+ VkCommandBufferBeginInfo cmdbuf_begin;

+ cmdbuf_begin.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;

+ cmdbuf_begin.pNext = nullptr;

+ cmdbuf_begin.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT | VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;

+ cmdbuf_begin.pInheritanceInfo = &inheritance_info;

+

+ VkResult res = vkResetCommandBuffer(command_buffer, 0);

+ if (res) {

+ memdelete_arr(draw_list);

+ draw_list = nullptr;

+ ERR_FAIL_V_MSG(ERR_CANT_CREATE, "vkResetCommandBuffer failed with error " + itos(res) + ".");

+ }

+

+ res = vkBeginCommandBuffer(command_buffer, &cmdbuf_begin);

+ if (res) {

+ memdelete_arr(draw_list);

+ draw_list = nullptr;

+ ERR_FAIL_V_MSG(ERR_CANT_CREATE, "vkBeginCommandBuffer failed with error " + itos(res) + ".");

+ }

+

+ draw_list[i].command_buffer = command_buffer;

+ draw_list[i].viewport = p_viewport;

+ }

+ }

+

+ return OK;

+}

+

+void RenderingDeviceVulkan::_draw_list_free(Rect2i *r_last_viewport) {

+ if (r_last_viewport) {

+ if (i == 0 || draw_list[i].viewport_set) {

+ *r_last_viewport = draw_list[i].viewport;

+ }

+ }

+ if (r_last_viewport) {

+ *r_last_viewport = draw_list->viewport;

+ }

+}

+

+void RenderingDeviceVulkan::draw_list_end(uint32_t p_post_barrier) {

+ _THREAD_SAFE_METHOD_

+

+ ERR_FAIL_COND_MSG(!draw_list, "Immediate draw list is already inactive.");

+

+ _draw_list_free();

+

+ vkCmdEndRenderPass(frames[frame].draw_command_buffer);

+ if (uniform_set->invalidated_callback != nullptr) {

+ uniform_set->invalidated_callback(p_id, uniform_set->invalidated_callback_userdata);

+ }

+

+ image_memory -= texture->allocation_info.size;

+uint64_t RenderingDeviceVulkan::get_memory_usage(MemoryType p_type) const {

+ if (p_type == MEMORY_BUFFERS) {

+ return buffer_memory;

+ } else if (p_type == MEMORY_TEXTURES) {

+ return image_memory;

+ } else {

+ VmaStats stats;

+ vmaCalculateStats(allocator, &stats);

+ return stats.total.usedBytes;

+ }

+ for (const RID &E : owned) {

+ free(E);

+ owned.erase(E);

+ for (const RID &E : owned) {

+ free(E);

+ Error _texture_update(RID p_texture, uint32_t p_layer, const Vector<uint8_t> &p_data, uint32_t p_post_barrier, bool p_use_setup_queue);

+ Vector<FramebufferPass> passes;

+ uint32_t view_count = 1;

+ if (view_count != p_key.view_count) {

+ return view_count < p_key.view_count;

+ }

+

+ uint32_t pass_size = passes.size();

+ uint32_t key_pass_size = p_key.passes.size();

+ if (pass_size != key_pass_size) {

+ return pass_size < key_pass_size;

+ }

+ const FramebufferPass *pass_ptr = passes.ptr();

+ const FramebufferPass *key_pass_ptr = p_key.passes.ptr();

+

+ for (uint32_t i = 0; i < pass_size; i++) {

+ { //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) {

+ return attachment_size < key_attachment_size;

+ }

+ const int32_t *pass_attachment_ptr = pass_ptr[i].color_attachments.ptr();

+ const int32_t *key_pass_attachment_ptr = key_pass_ptr[i].color_attachments.ptr();

+

+ for (uint32_t j = 0; j < attachment_size; j++) {

+ if (pass_attachment_ptr[j] != key_pass_attachment_ptr[j]) {

+ return pass_attachment_ptr[j] < key_pass_attachment_ptr[j];

+ }

+ }

+ }

+ { //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) {

+ return attachment_size < key_attachment_size;

+ }

+ const int32_t *pass_attachment_ptr = pass_ptr[i].input_attachments.ptr();

+ const int32_t *key_pass_attachment_ptr = key_pass_ptr[i].input_attachments.ptr();

+

+ for (uint32_t j = 0; j < attachment_size; j++) {

+ if (pass_attachment_ptr[j] != key_pass_attachment_ptr[j]) {

+ return pass_attachment_ptr[j] < key_pass_attachment_ptr[j];

+ }

+ }

+ }

+ { //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) {

+ return attachment_size < key_attachment_size;

+ }

+ const int32_t *pass_attachment_ptr = pass_ptr[i].resolve_attachments.ptr();

+ const int32_t *key_pass_attachment_ptr = key_pass_ptr[i].resolve_attachments.ptr();

+

+ for (uint32_t j = 0; j < attachment_size; j++) {

+ if (pass_attachment_ptr[j] != key_pass_attachment_ptr[j]) {

+ return pass_attachment_ptr[j] < key_pass_attachment_ptr[j];

+ }

+ }

+ }

+ { //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) {

+ return attachment_size < key_attachment_size;

+ }

+ const int32_t *pass_attachment_ptr = pass_ptr[i].preserve_attachments.ptr();

+ const int32_t *key_pass_attachment_ptr = key_pass_ptr[i].preserve_attachments.ptr();

+

+ for (uint32_t j = 0; j < attachment_size; j++) {

+ if (pass_attachment_ptr[j] != key_pass_attachment_ptr[j]) {

+ return pass_attachment_ptr[j] < key_pass_attachment_ptr[j];

+ }

+ }

+ }

+ if (pass_ptr[i].depth_attachment != key_pass_ptr[i].depth_attachment) {

+ return pass_ptr[i].depth_attachment < key_pass_ptr[i].depth_attachment;

+ }

+ }

+

+ VkRenderPass _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 = 1, Vector<TextureSamples> *r_samples = nullptr);

+ Vector<TextureSamples> pass_samples;

+ uint32_t view_count = 1; // number of views

+ uint32_t view_count;

+

+ if (final_depth_action == p_key.final_depth_action) {

+ return view_count < p_key.view_count;

+ } else {

+ return final_depth_action < p_key.final_depth_action;

+ }

+ uint32_t subpass_count = 1;

+ uint32_t view_count;

+ uint32_t fragment_output_mask = 0;

+ struct SpecializationConstant {

+ PipelineSpecializationConstant constant;

+ uint32_t stage_flags = 0;

+ };

+

+ Vector<SpecializationConstant> specialization_constants;

+ // create a pool for every descriptor set type, as

+ // this prevents fragmentation.

+ UniformSetInvalidatedCallback invalidated_callback = nullptr;

+ void *invalidated_callback_userdata = nullptr;

+ uint32_t render_pass = 0;

+ bool viewport_set = false;

+ uint32_t draw_list_subpass_count = 0;

+ VkRenderPass draw_list_render_pass;

+ VkFramebuffer draw_list_vkframebuffer;

+#ifdef DEBUG_ENABLED

+ FramebufferFormatID draw_list_framebuffer_format = INVALID_ID;

+#endif

+ uint32_t draw_list_current_subpass = 0;

+

+ Error _draw_list_setup_framebuffer(Framebuffer *p_framebuffer, InitialAction p_initial_color_action, FinalAction p_final_color_action, InitialAction p_initial_depth_action, FinalAction p_final_depth_action, VkFramebuffer *r_framebuffer, VkRenderPass *r_render_pass, uint32_t *r_subpass_count);

+ Error _draw_list_allocate(const Rect2i &p_viewport, uint32_t p_splits, uint32_t p_subpass);

+ void _draw_list_free(Rect2i *r_last_viewport = nullptr);

+ uint64_t image_memory = 0;

+ uint64_t buffer_memory = 0;

+

+ virtual FramebufferFormatID framebuffer_format_create(const Vector<AttachmentFormat> &p_format, uint32_t p_view_count = 1);

+ virtual FramebufferFormatID framebuffer_format_create_multipass(const Vector<AttachmentFormat> &p_attachments, Vector<FramebufferPass> &p_passes, uint32_t p_view_count = 1);

+ virtual TextureSamples framebuffer_format_get_texture_samples(FramebufferFormatID p_format, uint32_t p_pass = 0);

+ virtual RID framebuffer_create(const Vector<RID> &p_texture_attachments, FramebufferFormatID p_format_check = INVALID_ID, uint32_t p_view_count = 1);

+ virtual RID framebuffer_create_multipass(const Vector<RID> &p_texture_attachments, Vector<FramebufferPass> &p_passes, FramebufferFormatID p_format_check = INVALID_ID, uint32_t p_view_count = 1);

+ virtual String shader_get_binary_cache_key() const;

+ virtual Vector<uint8_t> shader_compile_binary_from_spirv(const Vector<ShaderStageSPIRVData> &p_spirv);

+

+ virtual RID shader_create_from_bytecode(const Vector<uint8_t> &p_shader_binary);

+

+ virtual void uniform_set_set_invalidation_callback(RID p_uniform_set, UniformSetInvalidatedCallback p_callback, void *p_userdata);

+ virtual RID 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 = 0, uint32_t p_for_render_pass = 0, const Vector<PipelineSpecializationConstant> &p_specialization_constants = Vector<PipelineSpecializationConstant>());

+ virtual RID compute_pipeline_create(RID p_shader, const Vector<PipelineSpecializationConstant> &p_specialization_constants = Vector<PipelineSpecializationConstant>());

+ virtual uint32_t draw_list_get_current_pass();

+ virtual DrawListID draw_list_switch_to_next_pass();

+ virtual Error draw_list_switch_to_next_pass_split(uint32_t p_splits, DrawListID *r_split_ids);

+

+ virtual uint64_t get_memory_usage(MemoryType p_type) const;

+ if (!strcmp(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, instance_extensions[i].extensionName)) {

+ extension_names[enabled_extension_count++] = VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME;

+ }

+ multiview_capabilities.geometry_shader_is_supported = false;

+ multiview_capabilities.tessellation_shader_is_supported = false;

+ multiview_capabilities.geometry_shader_is_supported = multiview_features.multiviewGeometryShader;

+ multiview_capabilities.tessellation_shader_is_supported = multiview_features.multiviewTessellationShader;

+ print_verbose("- Vulkan multiview supported:");

+ print_verbose(" max view count: " + itos(multiview_capabilities.max_view_count));

+ print_verbose(" max instances: " + itos(multiview_capabilities.max_instance_count));

+ print_verbose("- Vulkan multiview not supported");

+ print_verbose("- Vulkan subgroup:");

+ print_verbose(" size: " + itos(subgroup_capabilities.size));

+ print_verbose(" stages: " + subgroup_capabilities.supported_stages_desc());

+ print_verbose(" supported ops: " + subgroup_capabilities.supported_operations_desc());

+ print_verbose(" quad operations in all stages");

+ print_verbose("- Couldn't call vkGetPhysicalDeviceProperties2");

+

+ // 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.

+

+ // Default to first device

+

+ for (uint32_t i = 0; i < gpu_count; ++i) {

+ VkPhysicalDeviceProperties props;

+ vkGetPhysicalDeviceProperties(physical_devices[i], &props);

+

+ if (props.deviceType == VkPhysicalDeviceType::VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) {

+ // Prefer discrete GPU.

+ device_index = i;

+ break;

+ }

+ }

+

+ { 0x106B, "Apple" },

+ { 0x8086, "Intel" },

+

+

+ if (!strcmp(VK_KHR_MULTIVIEW_EXTENSION_NAME, device_extensions[i].extensionName)) {

+ // if multiview is supported, enable it

+ extension_names[enabled_extension_count++] = VK_KHR_MULTIVIEW_EXTENSION_NAME;

+ }

+

+#ifdef VK_VERSION_1_2

+ VkPhysicalDeviceVulkan11Features vulkan11features;

+

+ vulkan11features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;

+ vulkan11features.pNext = nullptr;

+ // !BAS! Need to figure out which ones of these we want enabled...

+ vulkan11features.storageBuffer16BitAccess = 0;

+ vulkan11features.uniformAndStorageBuffer16BitAccess = 0;

+ vulkan11features.storagePushConstant16 = 0;

+ vulkan11features.storageInputOutput16 = 0;

+ vulkan11features.multiview = multiview_capabilities.is_supported;

+ vulkan11features.multiviewGeometryShader = multiview_capabilities.geometry_shader_is_supported;

+ vulkan11features.multiviewTessellationShader = multiview_capabilities.tessellation_shader_is_supported;

+ vulkan11features.variablePointersStorageBuffer = 0;

+ vulkan11features.variablePointers = 0;

+ vulkan11features.protectedMemory = 0;

+ vulkan11features.samplerYcbcrConversion = 0;

+ vulkan11features.shaderDrawParameters = 0;

+

+ sdevice.pNext = &vulkan11features;

+#elif VK_VERSION_1_1

+ VkPhysicalDeviceMultiviewFeatures multiview_features;

+

+ multiview_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;

+ multiview_features.pNext = nullptr;

+ multiview_features.multiview = multiview_capabilities.is_supported;

+ multiview_features.multiviewGeometryShader = multiview_capabilities.geometry_shader_is_supported;

+ multiview_features.multiviewTessellationShader = multiview_capabilities.tessellation_shader_is_supported;

+

+ sdevice.pNext = &multiview_features;

+#endif

+

+Error VulkanContext::_initialize_queues(VkSurfaceKHR p_surface) {

+ fpGetPhysicalDeviceSurfaceSupportKHR(gpu, i, p_surface, &supportsPresent[i]);

+ VkResult err = fpGetPhysicalDeviceSurfaceFormatsKHR(gpu, p_surface, &formatCount, nullptr);

+ err = fpGetPhysicalDeviceSurfaceFormatsKHR(gpu, p_surface, &formatCount, surfFormats);

+Error VulkanContext::_window_create(DisplayServer::WindowID p_window_id, DisplayServer::VSyncMode p_vsync_mode, VkSurfaceKHR p_surface, int p_width, int p_height) {

+ } else {

+ // make sure any of the surfaces supports present (validation layer complains if this is not done).

+ bool any_supports_present = false;

+ for (uint32_t i = 0; i < queue_family_count; i++) {

+ VkBool32 supports;

+ fpGetPhysicalDeviceSurfaceSupportKHR(gpu, i, p_surface, &supports);

+ if (supports) {

+ any_supports_present = true;

+ break;

+ }

+ }

+

+ ERR_FAIL_COND_V_MSG(!any_supports_present, ERR_CANT_CREATE, "Surface passed for sub-window creation does not support presenting");

+ window.vsync_mode = p_vsync_mode;

+ VkSemaphoreCreateInfo semaphoreCreateInfo = {

+ /*sType*/ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,

+ /*pNext*/ nullptr,

+ /*flags*/ 0,

+ };

+

+ for (uint32_t i = 0; i < FRAME_LAG; i++) {

+ VkResult vkerr = vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &window.image_acquired_semaphores[i]);

+ ERR_FAIL_COND_V(vkerr, ERR_CANT_CREATE);

+ }

+

+ for (uint32_t i = 0; i < FRAME_LAG; i++) {

+ vkDestroySemaphore(device, windows[p_window_id].image_acquired_semaphores[i], nullptr);

+ }

+

+ VkPresentModeKHR requested_present_mode = VkPresentModeKHR::VK_PRESENT_MODE_FIFO_KHR;

+ switch (window->vsync_mode) {

+ case DisplayServer::VSYNC_MAILBOX:

+ requested_present_mode = VkPresentModeKHR::VK_PRESENT_MODE_MAILBOX_KHR;

+ break;

+ case DisplayServer::VSYNC_ADAPTIVE:

+ requested_present_mode = VkPresentModeKHR::VK_PRESENT_MODE_FIFO_RELAXED_KHR;

+ break;

+ case DisplayServer::VSYNC_ENABLED:

+ requested_present_mode = VkPresentModeKHR::VK_PRESENT_MODE_FIFO_KHR;

+ break;

+ case DisplayServer::VSYNC_DISABLED:

+ requested_present_mode = VkPresentModeKHR::VK_PRESENT_MODE_IMMEDIATE_KHR;

+ break;

+ }

+

+ // Check if the requested mode is available.

+ bool present_mode_available = false;

+ for (uint32_t i = 0; i < presentModeCount; i++) {

+ if (presentModes[i] == requested_present_mode) {

+ present_mode_available = true;

+

+ // Set the windows present mode if it is available, otherwise FIFO is used (guaranteed supported).

+ if (present_mode_available) {

+ window->presentMode = requested_present_mode;

+ } else {

+ WARN_PRINT("Requested VSync mode is not available!");

+ window->vsync_mode = DisplayServer::VSYNC_ENABLED; //Set to default

+ }

+

+ print_verbose("Using present mode: " + String(string_VkPresentModeKHR(window->presentMode)));

+

+ /*presentMode*/ window->presentMode,

+ w->semaphore_acquired = false;

+

+ w->image_acquired_semaphores[frame_index], VK_NULL_HANDLE, &w->current_buffer);

+ } else if (err != VK_SUCCESS) {

+ ERR_BREAK_MSG(err != VK_SUCCESS, "Vulkan: Did not create swapchain successfully.");

+ w->semaphore_acquired = true;

+ VkSemaphore *semaphores_to_acquire = (VkSemaphore *)alloca(windows.size() * sizeof(VkSemaphore));

+ uint32_t semaphores_to_acquire_count = 0;

+

+ for (Map<int, Window>::Element *E = windows.front(); E; E = E->next()) {

+ Window *w = &E->get();

+

+ if (w->semaphore_acquired) {

+ semaphores_to_acquire[semaphores_to_acquire_count++] = w->image_acquired_semaphores[frame_index];

+ }

+ }

+

+ submit_info.waitSemaphoreCount = semaphores_to_acquire_count;

+ submit_info.pWaitSemaphores = semaphores_to_acquire;

+DisplayServer::VSyncMode VulkanContext::get_vsync_mode(DisplayServer::WindowID p_window) const {

+ ERR_FAIL_COND_V_MSG(!windows.has(p_window), DisplayServer::VSYNC_ENABLED, "Could not get VSync mode for window with WindowID " + itos(p_window) + " because it does not exist.");

+ return windows[p_window].vsync_mode;

+}

+

+void VulkanContext::set_vsync_mode(DisplayServer::WindowID p_window, DisplayServer::VSyncMode p_mode) {

+ ERR_FAIL_COND_MSG(!windows.has(p_window), "Could not set VSync mode for window with WindowID " + itos(p_window) + " because it does not exist.");

+ windows[p_window].vsync_mode = p_mode;

+ _update_swap_chain(&windows[p_window]);

+}

+

+ bool geometry_shader_is_supported;

+ bool tessellation_shader_is_supported;

+ uint32_t max_view_count;

+ uint32_t max_instance_count;

+ VkSemaphore image_acquired_semaphores[FRAME_LAG];

+ bool semaphore_acquired = false;

+ DisplayServer::VSyncMode vsync_mode = DisplayServer::VSYNC_ENABLED;

+ Error _initialize_queues(VkSurfaceKHR p_surface);

+ virtual Error _window_create(DisplayServer::WindowID p_window_id, DisplayServer::VSyncMode p_vsync_mode, VkSurfaceKHR p_surface, int p_width, int p_height);

+ void set_vsync_mode(DisplayServer::WindowID p_window, DisplayServer::VSyncMode p_mode);

+ DisplayServer::VSyncMode get_vsync_mode(DisplayServer::WindowID p_window = 0) const;

+

+ if (!p_file.is_absolute_path()) {

+#include "core/io/dir_access.h"

+ if (is_backup_save_enabled() && p_mode_flags == WRITE) {

+#include "core/io/file_access.h"