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

Buffer *buffer = nullptr;

if (vertex_buffer_owner.owns(p_buffer)) {

buffer = vertex_buffer_owner.get_or_null(p_buffer);

r_stage_mask |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;

r_access_mask |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;

if (buffer->usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) {

r_access_mask |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;

r_stage_mask |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;

}

r_access_mask |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;

r_stage_mask |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;

}

r_access_mask |= VK_ACCESS_INDEX_READ_BIT;

buffer = index_buffer_owner.get_or_null(p_buffer);

} else if (uniform_buffer_owner.owns(p_buffer)) {

r_stage_mask |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;

}

r_stage_mask |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;

}

r_access_mask |= VK_ACCESS_UNIFORM_READ_BIT;

buffer = uniform_buffer_owner.get_or_null(p_buffer);

} else if (texture_buffer_owner.owns(p_buffer)) {

r_stage_mask |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;

r_access_mask |= VK_ACCESS_SHADER_READ_BIT;

}

r_stage_mask |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;

r_access_mask |= VK_ACCESS_SHADER_READ_BIT;

}

buffer = &texture_buffer_owner.get_or_null(p_buffer)->buffer;

} else if (storage_buffer_owner.owns(p_buffer)) {

buffer = storage_buffer_owner.get_or_null(p_buffer);

r_stage_mask |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;

r_access_mask |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;

}

r_stage_mask |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;

r_access_mask |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;

}

image_create_info.pNext = nullptr;

image_create_info.flags = 0;

#ifndef ANDROID_ENABLED

ERR_FAIL_INDEX_V(p_format.samples, TEXTURE_SAMPLES_MAX, RID());

image_create_info.tiling = (p_format.usage_bits & TEXTURE_USAGE_CPU_READ_BIT) ? VK_IMAGE_TILING_LINEAR : VK_IMAGE_TILING_OPTIMAL;

// Usage.

texture.mipmaps = image_create_info.mipLevels;

texture.base_mipmap = 0;

texture.base_layer = 0;

texture.usage_flags = p_format.usage_bits;

texture.samples = p_format.samples;

texture.allowed_shared_formats = p_format.shareable_formats;

if (p_data.size()) {

for (uint32_t i = 0; i < image_create_info.arrayLayers; i++) {

}

}

return id;

texture.height = p_height;

texture.depth = p_depth;

texture.layers = p_layers;

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

if (texture.usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {

texture.read_aspect_mask = VK_IMAGE_ASPECT_DEPTH_BIT;

return id;

}

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

}

}

}

_THREAD_SAFE_METHOD_

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

{

uint32_t barrier_flags = 0;

uint32_t access_flags = 0;

barrier_flags |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;

access_flags |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;

}

barrier_flags |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;

access_flags |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;

}

barrier_flags |= VK_PIPELINE_STAGE_TRANSFER_BIT;

access_flags |= VK_ACCESS_TRANSFER_WRITE_BIT;

}

return Size2i(tex->width, tex->height);

}

_THREAD_SAFE_METHOD_

Texture *src_tex = texture_owner.get_or_null(p_from_texture);

uint32_t barrier_flags = 0;

uint32_t access_flags = 0;

barrier_flags |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;

access_flags |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;

}

barrier_flags |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;

access_flags |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;

}

barrier_flags |= VK_PIPELINE_STAGE_TRANSFER_BIT;

access_flags |= VK_ACCESS_TRANSFER_WRITE_BIT;

}

return OK;

}

_THREAD_SAFE_METHOD_

Texture *src_tex = texture_owner.get_or_null(p_from_texture);

uint32_t barrier_flags = 0;

uint32_t access_flags = 0;

barrier_flags |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;

access_flags |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;

}

barrier_flags |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;

access_flags |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;

}

barrier_flags |= VK_PIPELINE_STAGE_TRANSFER_BIT;

access_flags |= VK_ACCESS_TRANSFER_WRITE_BIT;

}

return OK;

}

_THREAD_SAFE_METHOD_

Texture *src_tex = texture_owner.get_or_null(p_texture);

uint32_t barrier_flags = 0;

uint32_t access_flags = 0;

barrier_flags |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;

access_flags |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;

}

barrier_flags |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;

access_flags |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;

}

barrier_flags |= VK_PIPELINE_STAGE_TRANSFER_BIT;

access_flags |= VK_ACCESS_TRANSFER_WRITE_BIT;

}

return OK;

}

ERR_FAIL_INDEX_V(p_format, DATA_FORMAT_MAX, false);

_THREAD_SAFE_METHOD_

vkGetPhysicalDeviceFormatProperties(context->get_physical_device(), vulkan_formats[p_format], &properties);

VkFormatFeatureFlags flags;

flags = properties.linearTilingFeatures;

} else {

flags = properties.optimalTilingFeatures;

}

return false;

}

return false;

}

return false;

}

return false;

}

return false;

}

// Validation via VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR fails if VRS attachment is not supported.

return false;

}

LocalVector<int32_t> attachment_last_pass;

attachment_last_pass.resize(p_attachments.size());

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

description.pNext = nullptr;

description.flags = 0;

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

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

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

break;

}

}

for (int j = 0; j < p_passes[last_pass].color_attachments.size(); j++) {

if (p_passes[last_pass].color_attachments[j] == i) {

used_last = true;

reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;

attachment_last_pass[attachment] = i;

}

color_references.push_back(reference);

}

reference.layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;

attachment_last_pass[attachment] = i;

}

input_references.push_back(reference);

}

reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; // VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL

attachment_last_pass[attachment] = i;

}

resolve_references.push_back(reference);

}

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_remap[attachment];

depth_stencil_reference.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;

attachment_last_pass[attachment] = i;

if (is_multisample_first) {

vrs_reference.pNext = nullptr;

vrs_reference.attachment = attachment_remap[attachment];

vrs_reference.layout = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR;

VkFragmentShadingRateAttachmentInfoKHR &vrs_attachment_info = vrs_attachment_info_array[i];

vrs_attachment_info.sType = VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR;

Vector<uint32_t> view_masks;

VkRenderPassMultiviewCreateInfo render_pass_multiview_create_info;

// Set view masks for each subpass.

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

} else if (texture && texture->usage_flags & TEXTURE_USAGE_VRS_ATTACHMENT_BIT) {

pass.vrs_attachment = i;

} else {

}

}

size.height = texture->height;

size_set = true;

} else if (texture->usage_flags & TEXTURE_USAGE_VRS_ATTACHMENT_BIT) {

// 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(),

return id;

}

_THREAD_SAFE_METHOD_

ERR_FAIL_COND_V(!vertex_formats.has(p_vertex_format), RID());

VertexArray vertex_array;

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.buffers.push_back(buffer->buffer);

}

RID id = vertex_array_owner.make_rid(vertex_array);

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

const SpvReflectDescriptorBinding &binding = *bindings[j];

bool need_array_dimensions = false;

bool need_block_size = false;

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

int32_t existing = -1;

SpvReflectSpecializationConstant *spc = spec_constants[j];

sconst.constant_id = spc->constant_id;

uint32_t offset = 0;

uint8_t *binptr = ret.ptrw();

binptr[0] = 'G';

binptr[2] = 'B';

offset += 4;

encode_uint32(SHADER_BINARY_VERSION, binptr + offset);

offset += sizeof(uint32_t);

uint32_t read_offset = 0;

// Consistency check.

ERR_FAIL_COND_V(binsize < sizeof(uint32_t) * 3 + sizeof(RenderingDeviceVulkanShaderBinaryData), RID());

uint32_t bin_version = decode_uint32(binptr + 4);

ERR_FAIL_COND_V(bin_version != SHADER_BINARY_VERSION, RID());

us->invalidated_callback_userdata = p_userdata;

}

_THREAD_SAFE_METHOD_

ERR_FAIL_COND_V_MSG(draw_list, ERR_INVALID_PARAMETER,

VkPipelineStageFlags dst_stage_mask = 0;

VkAccessFlags dst_access = 0;

// Protect subsequent updates.

dst_stage_mask = VK_PIPELINE_STAGE_TRANSFER_BIT;

dst_access = VK_ACCESS_TRANSFER_WRITE_BIT;

return err;

}

_THREAD_SAFE_METHOD_

ERR_FAIL_COND_V_MSG((p_size % 4) != 0, ERR_INVALID_PARAMETER,

VkPipelineStageFlags dst_stage_mask = 0;

VkAccessFlags dst_access = 0;

// Protect subsequent updates.

dst_stage_mask = VK_PIPELINE_STAGE_TRANSFER_BIT;

dst_access = VK_ACCESS_TRANSFER_WRITE_BIT;

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.

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

}

ERR_FAIL_INDEX_V(p_rasterization_state.cull_mode, 3, RID());

rasterization_state_create_info.cullMode = cull_mode[p_rasterization_state.cull_mode];

rasterization_state_create_info.frontFace = (p_rasterization_state.front_face == POLYGON_FRONT_FACE_CLOCKWISE ? VK_FRONT_FACE_CLOCKWISE : VK_FRONT_FACE_COUNTER_CLOCKWISE);

rasterization_state_create_info.depthBiasConstantFactor = p_rasterization_state.depth_bias_constant_factor;

rasterization_state_create_info.depthBiasClamp = p_rasterization_state.depth_bias_clamp;

rasterization_state_create_info.depthBiasSlopeFactor = p_rasterization_state.depth_bias_slope_factor;

multisample_state_create_info.pNext = nullptr;

multisample_state_create_info.flags = 0;

multisample_state_create_info.sampleShadingEnable = p_multisample_state.enable_sample_shading;

multisample_state_create_info.minSampleShading = p_multisample_state.min_sample_shading;

Vector<VkSampleMask> sample_mask;

return OK;

}

Vector<VkClearAttachment> clear_attachments;

int color_index = 0;

int texture_index = 0;

if (!texture) {

texture_index++;

VkClearRect cr;

cr.baseArrayLayer = 0;

cr.layerCount = 1;

}

RenderingDevice::DrawListID RenderingDeviceVulkan::draw_list_begin(RID p_framebuffer, InitialAction p_initial_color_action, FinalAction p_final_color_action, InitialAction p_initial_depth_action, FinalAction p_final_depth_action, const Vector<Color> &p_clear_color_values, float p_clear_depth, uint32_t p_clear_stencil, const Rect2 &p_region, const Vector<RID> &p_storage_textures) {

// If it is the first we're likely populating our VRS texture.

// Bit dirty but...

if (!texture || (!(texture->usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) && !(i != 0 && texture->usage_flags & TEXTURE_USAGE_VRS_ATTACHMENT_BIT))) {

}

}

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

dl->validation.index_array_size = index_array->indices;

dl->validation.index_array_offset = index_array->offset;

}

void RenderingDeviceVulkan::draw_list_set_line_width(DrawListID p_list, float p_width) {

_THREAD_SAFE_UNLOCK_

}

_THREAD_SAFE_METHOD_

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

uint32_t barrier_flags = 0;

uint32_t access_flags = 0;

barrier_flags |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;

access_flags |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;

}

barrier_flags |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT | VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT /*| VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT*/;

access_flags |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_INDEX_READ_BIT | VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT /*| VK_ACCESS_INDIRECT_COMMAND_READ_BIT*/;

}

barrier_flags |= VK_PIPELINE_STAGE_TRANSFER_BIT;

access_flags |= VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_TRANSFER_READ_BIT;

}

#endif

}

ERR_FAIL_COND(!compute_list);

uint32_t barrier_flags = 0;

uint32_t access_flags = 0;

barrier_flags |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;

access_flags |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;

}

barrier_flags |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT | VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT;

access_flags |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_INDEX_READ_BIT | VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT | VK_ACCESS_INDIRECT_COMMAND_READ_BIT;

}

barrier_flags |= VK_PIPELINE_STAGE_TRANSFER_BIT;

access_flags |= VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_TRANSFER_READ_BIT;

}

_THREAD_SAFE_UNLOCK_

}

uint32_t src_barrier_flags = 0;

uint32_t src_access_flags = 0;

if (p_from == 0) {

src_barrier_flags = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;

}

uint32_t dst_barrier_flags = 0;

uint32_t dst_access_flags = 0;

if (p_to == 0) {

dst_barrier_flags = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;

}

_memory_barrier(src_barrier_flags, dst_barrier_flags, src_access_flags, dst_access_flags, true);

frames[frame].index = Engine::get_singleton()->get_frames_drawn();

}

void RenderingDeviceVulkan::swap_buffers() {

ERR_FAIL_COND_MSG(local_device.is_valid(), "Local devices can't swap buffers.");

_THREAD_SAFE_METHOD_

Texture *texture = &frames[p_frame].textures_to_dispose_of.front()->get();

if (texture->bound) {

}

vkDestroyImageView(device, texture->view, nullptr);

if (texture->owner.is_null()) {

}

}

staging_buffer_block_size = MAX(4u, staging_buffer_block_size);

staging_buffer_block_size *= 1024; // Kb -> bytes.

staging_buffer_max_size = MAX(1u, staging_buffer_max_size);

staging_buffer_max_size *= 1024 * 1024;

// Validate enough blocks.

staging_buffer_max_size = staging_buffer_block_size * 4;

}

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.

ERR_CONTINUE(err != OK);

}

// Check to make sure DescriptorPoolKey is good.

static_assert(sizeof(uint64_t) * 3 >= UNIFORM_TYPE_MAX * sizeof(uint16_t));

return limits.maxComputeWorkGroupSize[1];

case LIMIT_MAX_COMPUTE_WORKGROUP_SIZE_Z:

return limits.maxComputeWorkGroupSize[2];

case LIMIT_SUBGROUP_SIZE: {

VulkanContext::SubgroupCapabilities subgroup_capabilities = context->get_subgroup_capabilities();

return subgroup_capabilities.size;

VulkanContext::SubgroupCapabilities subgroup_capabilities = context->get_subgroup_capabilities();

return subgroup_capabilities.supported_operations_flags_rd();

}

default:

ERR_FAIL_V(0);

}