-//#define FORCE_FULL_BARRIER

-/******************/

-/**** BARRIERS ****/

-/******************/

-

-void RenderingDevice::_full_barrier(bool p_sync_with_draw) {

- // Used for debug.

-

- RDD::MemoryBarrier mb;

- mb.src_access = (RDD::BARRIER_ACCESS_INDIRECT_COMMAND_READ_BIT |

- RDD::BARRIER_ACCESS_INDEX_READ_BIT |

- RDD::BARRIER_ACCESS_VERTEX_ATTRIBUTE_READ_BIT |

- RDD::BARRIER_ACCESS_UNIFORM_READ_BIT |

- RDD::BARRIER_ACCESS_INPUT_ATTACHMENT_READ_BIT |

- RDD::BARRIER_ACCESS_SHADER_READ_BIT |

- RDD::BARRIER_ACCESS_SHADER_WRITE_BIT |

- RDD::BARRIER_ACCESS_COLOR_ATTACHMENT_READ_BIT |

- RDD::BARRIER_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |

- RDD::BARRIER_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |

- RDD::BARRIER_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |

- RDD::BARRIER_ACCESS_TRANSFER_READ_BIT |

- RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT |

- RDD::BARRIER_ACCESS_HOST_READ_BIT |

- RDD::BARRIER_ACCESS_HOST_WRITE_BIT);

- mb.dst_access = (RDD::BARRIER_ACCESS_INDIRECT_COMMAND_READ_BIT |

- RDD::BARRIER_ACCESS_INDEX_READ_BIT |

- RDD::BARRIER_ACCESS_VERTEX_ATTRIBUTE_READ_BIT |

- RDD::BARRIER_ACCESS_UNIFORM_READ_BIT |

- RDD::BARRIER_ACCESS_INPUT_ATTACHMENT_READ_BIT |

- RDD::BARRIER_ACCESS_SHADER_READ_BIT |

- RDD::BARRIER_ACCESS_SHADER_WRITE_BIT |

- RDD::BARRIER_ACCESS_COLOR_ATTACHMENT_READ_BIT |

- RDD::BARRIER_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |

- RDD::BARRIER_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |

- RDD::BARRIER_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |

- RDD::BARRIER_ACCESS_TRANSFER_READ_BIT |

- RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT |

- RDD::BARRIER_ACCESS_HOST_READ_BIT |

- RDD::BARRIER_ACCESS_HOST_WRITE_BIT);

-

- RDD::CommandBufferID cmd_buffer = p_sync_with_draw ? frames[frame].draw_command_buffer : frames[frame].setup_command_buffer;

- driver->command_pipeline_barrier(cmd_buffer, RDD::PIPELINE_STAGE_ALL_COMMANDS_BIT, RDD::PIPELINE_STAGE_ALL_COMMANDS_BIT, mb, {}, {});

-}

-

-RenderingDevice::Buffer *RenderingDevice::_get_buffer_from_owner(RID p_buffer, BitField<RDD::PipelineStageBits> &r_stages, BitField<RDD::BarrierAccessBits> &r_access, BitField<BarrierMask> p_post_barrier) {

- r_stages.clear();

- r_access.clear();

-

- r_stages.set_flag(RDD::PIPELINE_STAGE_VERTEX_INPUT_BIT);

- r_access.set_flag(RDD::BARRIER_ACCESS_VERTEX_ATTRIBUTE_READ_BIT);

- if (buffer->usage & RDD::BUFFER_USAGE_STORAGE_BIT) {

- if (p_post_barrier.has_flag(BARRIER_MASK_VERTEX)) {

- r_access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- r_stages.set_flag(RDD::PIPELINE_STAGE_VERTEX_SHADER_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_FRAGMENT)) {

- r_access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- r_stages.set_flag(RDD::PIPELINE_STAGE_FRAGMENT_SHADER_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_COMPUTE)) {

- r_access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- r_stages.set_flag(RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT);

- }

- }

- r_stages.set_flag(RDD::PIPELINE_STAGE_VERTEX_INPUT_BIT);

- r_access.set_flag(RDD::BARRIER_ACCESS_INDEX_READ_BIT);

- if (p_post_barrier.has_flag(BARRIER_MASK_VERTEX)) {

- r_stages.set_flag(RDD::PIPELINE_STAGE_VERTEX_SHADER_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_FRAGMENT)) {

- r_stages.set_flag(RDD::PIPELINE_STAGE_FRAGMENT_SHADER_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_COMPUTE)) {

- r_stages.set_flag(RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT);

- }

- r_access.set_flag(RDD::BARRIER_ACCESS_UNIFORM_READ_BIT);

- if (p_post_barrier.has_flag(BARRIER_MASK_VERTEX)) {

- r_stages.set_flag(RDD::PIPELINE_STAGE_VERTEX_SHADER_BIT);

- r_access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_FRAGMENT)) {

- r_stages.set_flag(RDD::PIPELINE_STAGE_FRAGMENT_SHADER_BIT);

- r_access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_COMPUTE)) {

- r_stages.set_flag(RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT);

- r_access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT);

- }

-

- // FIXME: Broken.

- if (p_post_barrier.has_flag(BARRIER_MASK_VERTEX)) {

- r_stages.set_flag(RDD::PIPELINE_STAGE_VERTEX_SHADER_BIT);

- r_access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_FRAGMENT)) {

- r_stages.set_flag(RDD::PIPELINE_STAGE_FRAGMENT_SHADER_BIT);

- r_access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_COMPUTE)) {

- r_stages.set_flag(RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT);

- r_access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- }

-

- if (buffer->usage.has_flag(RDD::BUFFER_USAGE_INDIRECT_BIT)) {

- r_stages.set_flag(RDD::PIPELINE_STAGE_DRAW_INDIRECT_BIT);

- r_access.set_flag(RDD::BARRIER_ACCESS_INDIRECT_COMMAND_READ_BIT);

- }

-Error RenderingDevice::_staging_buffer_allocate(uint32_t p_amount, uint32_t p_required_align, uint32_t &r_alloc_offset, uint32_t &r_alloc_size, bool p_can_segment) {

-

- if (false) { // Separate thread from render.

-

- //block_until_next_frame()

- continue;

- } else {

- // Flush EVERYTHING including setup commands. IF not immediate, also need to flush the draw commands.

- _flush(true);

-

- // Clear the whole staging buffer.

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

- staging_buffer_blocks.write[i].frame_used = 0;

- staging_buffer_blocks.write[i].fill_amount = 0;

- }

- // Claim current.

- staging_buffer_blocks.write[staging_buffer_current].frame_used = frames_drawn;

- }

-

- if (false) {

- // Separate thread from render.

- //block_until_next_frame()

- continue; // And try again.

- } else {

- _flush(false);

-

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

- // Clear all blocks but the ones from this frame.

- int block_idx = (i + staging_buffer_current) % staging_buffer_blocks.size();

- if (staging_buffer_blocks[block_idx].frame_used == frames_drawn) {

- break; // Ok, we reached something from this frame, abort.

- }

-

- staging_buffer_blocks.write[block_idx].frame_used = 0;

- staging_buffer_blocks.write[block_idx].fill_amount = 0;

- }

-

- // Claim for current frame.

- staging_buffer_blocks.write[staging_buffer_current].frame_used = frames_drawn;

- }

-Error RenderingDevice::_buffer_update(Buffer *p_buffer, size_t p_offset, const uint8_t *p_data, size_t p_data_size, bool p_use_draw_command_buffer, uint32_t p_required_align) {

- Error err = _staging_buffer_allocate(MIN(to_submit, staging_buffer_block_size), p_required_align, block_write_offset, block_write_amount);

-

- driver->command_copy_buffer(p_use_draw_command_buffer ? frames[frame].draw_command_buffer : frames[frame].setup_command_buffer, staging_buffer_blocks[staging_buffer_current].driver_id, p_buffer->driver_id, region);

-Error RenderingDevice::buffer_copy(RID p_src_buffer, RID p_dst_buffer, uint32_t p_src_offset, uint32_t p_dst_offset, uint32_t p_size, BitField<BarrierMask> p_post_barrier) {

- // This method assumes the barriers have been pushed prior to being called, therefore no barriers are pushed

- // for the source or destination buffers before performing the copy. These masks are effectively ignored.

- BitField<RDD::PipelineStageBits> src_stages;

- BitField<RDD::BarrierAccessBits> src_access;

- Buffer *src_buffer = _get_buffer_from_owner(p_src_buffer, src_stages, src_access, BARRIER_MASK_NO_BARRIER);

- BitField<RDD::PipelineStageBits> dst_stages;

- BitField<RDD::BarrierAccessBits> dst_access;

- if (p_post_barrier.has_flag(BARRIER_MASK_TRANSFER)) {

- // If the post barrier mask defines it, we indicate the destination buffer will require a barrier with these flags set

- // after the copy command is queued.

- dst_stages.set_flag(RDD::PIPELINE_STAGE_TRANSFER_BIT);

- dst_access.set_flag(RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT);

- }

-

- Buffer *dst_buffer = _get_buffer_from_owner(p_dst_buffer, dst_stages, dst_access, p_post_barrier);

- driver->command_copy_buffer(frames[frame].draw_command_buffer, src_buffer->driver_id, dst_buffer->driver_id, region);

-#ifdef FORCE_FULL_BARRIER

- _full_barrier(true);

-#else

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS) && p_post_barrier != RD::BARRIER_MASK_NO_BARRIER) {

- if (dst_stages.is_empty()) {

- dst_stages = RDD::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;

- }

-

- // As indicated by the post barrier mask, push a new barrier.

- RDD::BufferBarrier bb;

- bb.buffer = dst_buffer->driver_id;

- bb.src_access = RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT;

- bb.dst_access = dst_access;

- bb.offset = p_dst_offset;

- bb.size = p_size;

- driver->command_pipeline_barrier(frames[frame].draw_command_buffer, RDD::PIPELINE_STAGE_TRANSFER_BIT, dst_stages, {}, bb, {});

-#endif

-Error RenderingDevice::buffer_update(RID p_buffer, uint32_t p_offset, uint32_t p_size, const void *p_data, BitField<BarrierMask> p_post_barrier) {

- BitField<RDD::PipelineStageBits> dst_stages;

- BitField<RDD::BarrierAccessBits> dst_access;

- if (p_post_barrier.has_flag(BARRIER_MASK_TRANSFER)) {

- // Protect subsequent updates.

- dst_stages.set_flag(RDD::PIPELINE_STAGE_TRANSFER_BIT);

- dst_access.set_flag(RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT);

- }

- Buffer *buffer = _get_buffer_from_owner(p_buffer, dst_stages, dst_access, p_post_barrier);

- Error err = _buffer_update(buffer, p_offset, (uint8_t *)p_data, p_size, true);

- if (err) {

- return err;

- }

-

-#ifdef FORCE_FULL_BARRIER

- _full_barrier(true);

-#else

- if (dst_stages.is_empty()) {

- dst_stages.set_flag(RDD::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT);

- }

-

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS) && p_post_barrier != RD::BARRIER_MASK_NO_BARRIER) {

- RDD::BufferBarrier bb;

- bb.buffer = buffer->driver_id;

- bb.src_access = RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT;

- bb.dst_access = dst_access;

- bb.offset = p_offset;

- bb.size = p_size;

- driver->command_pipeline_barrier(frames[frame].draw_command_buffer, RDD::PIPELINE_STAGE_TRANSFER_BIT, dst_stages, {}, bb, {});

- }

-

-#endif

- return err;

-Error RenderingDevice::buffer_clear(RID p_buffer, uint32_t p_offset, uint32_t p_size, BitField<BarrierMask> p_post_barrier) {

- BitField<RDD::PipelineStageBits> dst_stages;

- BitField<RDD::BarrierAccessBits> dst_access;

- if (p_post_barrier.has_flag(BARRIER_MASK_TRANSFER)) {

- // Protect subsequent updates.

- dst_stages.set_flag(RDD::PIPELINE_STAGE_TRANSFER_BIT);

- dst_access.set_flag(RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT);

- }

-

- Buffer *buffer = _get_buffer_from_owner(p_buffer, dst_stages, dst_access, p_post_barrier);

- driver->command_clear_buffer(frames[frame].draw_command_buffer, buffer->driver_id, p_offset, p_size);

-

-#ifdef FORCE_FULL_BARRIER

- _full_barrier(true);

-#else

- if (dst_stages.is_empty()) {

- dst_stages.set_flag(RDD::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT);

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- RDD::BufferBarrier bb;

- bb.buffer = buffer->driver_id;

- bb.src_access = RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT;

- bb.dst_access = dst_access;

- bb.offset = p_offset;

- bb.size = p_size;

- driver->command_pipeline_barrier(frames[frame].draw_command_buffer, RDD::PIPELINE_STAGE_TRANSFER_BIT, dst_stages, {}, bb, {});

- }

-#endif

- // It could be this buffer was just created.

- BitField<RDD::PipelineStageBits> src_stages = RDD::PIPELINE_STAGE_TRANSFER_BIT;

- BitField<RDD::BarrierAccessBits> src_access = RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT;

- // Get the vulkan buffer and the potential stage/access possible.

- Buffer *buffer = _get_buffer_from_owner(p_buffer, src_stages, src_access, BARRIER_MASK_ALL_BARRIERS);

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- // Make sure no one is using the buffer -- the "true" gets us to the same command buffer as below.

- RDD::BufferBarrier bb;

- bb.buffer = buffer->driver_id;

- bb.src_access = src_access;

- bb.dst_access = RDD::BARRIER_ACCESS_TRANSFER_READ_BIT;

- bb.size = buffer->size;

- driver->command_pipeline_barrier(frames[frame].draw_command_buffer, src_stages, RDD::PIPELINE_STAGE_TRANSFER_BIT, {}, bb, {});

- }

-

- driver->command_copy_buffer(frames[frame].draw_command_buffer, buffer->driver_id, tmp_buffer, region);

- uint64_t data_size = p_data.size();

- const uint8_t *r = p_data.ptr();

- _buffer_update(&buffer, 0, r, data_size);

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- RDD::BufferBarrier bb;

- bb.buffer = buffer.driver_id;

- bb.src_access = RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT;

- bb.dst_access = (RDD::BARRIER_ACCESS_SHADER_READ_BIT | RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- bb.size = data_size;

- driver->command_pipeline_barrier(frames[frame].setup_command_buffer, RDD::PIPELINE_STAGE_TRANSFER_BIT, RDD::PIPELINE_STAGE_VERTEX_SHADER_BIT | RDD::PIPELINE_STAGE_FRAGMENT_SHADER_BIT | RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT, {}, bb, {});

- }

- return storage_buffer_owner.make_rid(buffer);

- _buffer_update(&texture_buffer, 0, p_data.ptr(), p_data.size());

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- RDD::BufferBarrier bb;

- bb.buffer = texture_buffer.driver_id;

- bb.src_access = RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT;

- bb.dst_access = RDD::BARRIER_ACCESS_SHADER_READ_BIT;

- bb.size = size_bytes;

- driver->command_pipeline_barrier(frames[frame].setup_command_buffer, RDD::PIPELINE_STAGE_TRANSFER_BIT, (RDD::PIPELINE_STAGE_VERTEX_SHADER_BIT | RDD::PIPELINE_STAGE_FRAGMENT_SHADER_BIT | RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT), {}, bb, {});

- }

- ERR_FAIL_COND_V_MSG(!(format.usage_bits & TEXTURE_USAGE_CAN_UPDATE_BIT), RID(),

- "Texture needs the TEXTURE_USAGE_CAN_UPDATE_BIT usage flag in order to be updated at initialization or later");

-

-

- texture.usage_flags = format.usage_bits;

-

- // Set base layout based on usage priority.

-

- if ((format.usage_bits & TEXTURE_USAGE_SAMPLING_BIT)) {

- // First priority, readable.

- texture.layout = RDD::TEXTURE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;

- } else if ((format.usage_bits & TEXTURE_USAGE_STORAGE_BIT)) {

- // Second priority, storage.

- texture.layout = RDD::TEXTURE_LAYOUT_GENERAL;

- } else if ((format.usage_bits & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT)) {

- // Third priority, color or depth.

- texture.layout = RDD::TEXTURE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;

- } else if ((format.usage_bits & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) {

- texture.layout = RDD::TEXTURE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;

- } else {

- texture.layout = RDD::TEXTURE_LAYOUT_GENERAL;

- }

- // Barrier to set layout.

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- RDD::TextureBarrier tb;

- tb.texture = texture.driver_id;

- tb.dst_access = RDD::BARRIER_ACCESS_SHADER_READ_BIT;

- tb.prev_layout = RDD::TEXTURE_LAYOUT_UNDEFINED;

- tb.next_layout = texture.layout;

- tb.subresources.aspect = texture.barrier_aspect_flags;

- tb.subresources.mipmap_count = format.mipmaps;

- tb.subresources.layer_count = format.array_layers;

-

- driver->command_pipeline_barrier(frames[frame].setup_command_buffer, RDD::PIPELINE_STAGE_TOP_OF_PIPE_BIT, RDD::PIPELINE_STAGE_VERTEX_SHADER_BIT | RDD::PIPELINE_STAGE_FRAGMENT_SHADER_BIT | RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT, {}, {}, tb);

- _texture_update(id, i, p_data[i], BARRIER_MASK_ALL_BARRIERS, true);

- // Set base layout based on usage priority.

-

- if (p_usage.has_flag(TEXTURE_USAGE_SAMPLING_BIT)) {

- // First priority, readable.

- texture.layout = RDD::TEXTURE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;

- } else if (p_usage.has_flag(TEXTURE_USAGE_STORAGE_BIT)) {

- // Second priority, storage.

- texture.layout = RDD::TEXTURE_LAYOUT_GENERAL;

- } else if (p_usage.has_flag(TEXTURE_USAGE_COLOR_ATTACHMENT_BIT)) {

- // Third priority, color or depth.

- texture.layout = RDD::TEXTURE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;

- } else if (p_usage.has_flag(TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) {

- texture.layout = RDD::TEXTURE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;

- } else {

- texture.layout = RDD::TEXTURE_LAYOUT_GENERAL;

- }

-

- // Barrier to set layout.

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- RDD::TextureBarrier tb;

- tb.texture = texture.driver_id;

- tb.dst_access = RDD::BARRIER_ACCESS_SHADER_READ_BIT;

- tb.prev_layout = RDD::TEXTURE_LAYOUT_UNDEFINED;

- tb.next_layout = texture.layout;

- tb.subresources.aspect = texture.barrier_aspect_flags;

- tb.subresources.mipmap_count = texture.mipmaps;

- tb.subresources.layer_count = texture.layers;

-

- driver->command_pipeline_barrier(frames[frame].setup_command_buffer, RDD::PIPELINE_STAGE_TOP_OF_PIPE_BIT, RDD::PIPELINE_STAGE_VERTEX_SHADER_BIT, {}, {}, tb);

- }

-Error RenderingDevice::texture_update(RID p_texture, uint32_t p_layer, const Vector<uint8_t> &p_data, BitField<BarrierMask> p_post_barrier) {

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

-Error RenderingDevice::_texture_update(RID p_texture, uint32_t p_layer, const Vector<uint8_t> &p_data, BitField<BarrierMask> p_post_barrier, bool p_use_setup_queue) {

- ERR_FAIL_COND_V_MSG(!(texture->usage_flags & TEXTURE_USAGE_CAN_UPDATE_BIT), ERR_INVALID_PARAMETER,

- RDD::CommandBufferID command_buffer = p_use_setup_queue ? frames[frame].setup_command_buffer : frames[frame].draw_command_buffer;

- // Barrier to transfer.

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- tb.prev_layout = texture->layout;

- driver->command_pipeline_barrier(command_buffer, RDD::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, RDD::PIPELINE_STAGE_TRANSFER_BIT, {}, {}, tb);

-

- Error err = _staging_buffer_allocate(to_allocate, required_align, alloc_offset, alloc_size, false);

- uint8_t *write_ptr = nullptr;

- driver->command_copy_buffer_to_texture(command_buffer, staging_buffer_blocks[staging_buffer_current].driver_id, texture->driver_id, RDD::TEXTURE_LAYOUT_TRANSFER_DST_OPTIMAL, copy_region);

- // Barrier to restore layout.

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- BitField<RDD::PipelineStageBits> stages;

- BitField<RDD::BarrierAccessBits> access;

- if (p_post_barrier.has_flag(BARRIER_MASK_COMPUTE)) {

- stages.set_flag(RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT);

- access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_VERTEX)) {

- stages.set_flag(RDD::PIPELINE_STAGE_VERTEX_SHADER_BIT);

- access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_FRAGMENT)) {

- stages.set_flag(RDD::PIPELINE_STAGE_FRAGMENT_SHADER_BIT);

- access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_TRANSFER)) {

- stages.set_flag(RDD::PIPELINE_STAGE_TRANSFER_BIT);

- access.set_flag(RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT);

- }

-

- if (stages.is_empty()) {

- stages.set_flag(RDD::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT);

- }

-

- tb.dst_access = access;

- tb.next_layout = texture->layout;

-

- driver->command_pipeline_barrier(command_buffer, RDD::PIPELINE_STAGE_TRANSFER_BIT, stages, {}, {}, tb);

-

- if (texture->used_in_frame != frames_drawn) {

- texture->used_in_raster = false;

- texture->used_in_compute = false;

- texture->used_in_frame = frames_drawn;

- texture->used_in_transfer = true;

- RDD::CommandBufferID command_buffer = frames[frame].draw_command_buffer; // Makes more sense to retrieve.

-

- // Pre-copy barrier.

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- RDD::TextureBarrier tb;

- tb.texture = tex->driver_id;

- tb.dst_access = RDD::BARRIER_ACCESS_TRANSFER_READ_BIT;

- tb.prev_layout = tex->layout;

- tb.next_layout = RDD::TEXTURE_LAYOUT_TRANSFER_SRC_OPTIMAL;

- tb.subresources.aspect = tex->barrier_aspect_flags;

- tb.subresources.mipmap_count = tex->mipmaps;

- tb.subresources.base_layer = p_layer;

- tb.subresources.layer_count = 1;

-

- driver->command_pipeline_barrier(command_buffer, RDD::PIPELINE_STAGE_TOP_OF_PIPE_BIT, RDD::PIPELINE_STAGE_TRANSFER_BIT, {}, {}, tb);

- }

- {

- uint32_t w = tex->width;

- uint32_t h = tex->height;

- uint32_t d = tex->depth;

- for (uint32_t i = 0; i < tex->mipmaps; i++) {

- RDD::BufferTextureCopyRegion copy_region;

- copy_region.buffer_offset = mip_layouts[i].offset;

- copy_region.texture_subresources.aspect = tex->read_aspect_flags;

- copy_region.texture_subresources.mipmap = i;

- copy_region.texture_subresources.base_layer = p_layer;

- copy_region.texture_subresources.layer_count = 1;

- copy_region.texture_region_size.x = w;

- copy_region.texture_region_size.y = h;

- copy_region.texture_region_size.z = d;

- driver->command_copy_texture_to_buffer(command_buffer, tex->driver_id, RDD::TEXTURE_LAYOUT_TRANSFER_SRC_OPTIMAL, tmp_buffer, copy_region);

-

- w = MAX(1u, w >> 1);

- h = MAX(1u, h >> 1);

- d = MAX(1u, d >> 1);

- }

- // Post-copy barrier.

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- RDD::TextureBarrier tb;

- tb.texture = tex->driver_id;

- tb.src_access = RDD::BARRIER_ACCESS_TRANSFER_READ_BIT;

- tb.dst_access = RDD::BARRIER_ACCESS_SHADER_READ_BIT;

- if ((tex->usage_flags & TEXTURE_USAGE_STORAGE_BIT)) {

- tb.dst_access.set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- }

- tb.prev_layout = RDD::TEXTURE_LAYOUT_TRANSFER_SRC_OPTIMAL;

- tb.next_layout = tex->layout;

- tb.subresources.aspect = tex->barrier_aspect_flags;

- tb.subresources.mipmap_count = tex->mipmaps;

- tb.subresources.base_layer = p_layer;

- tb.subresources.layer_count = 1;

-

- driver->command_pipeline_barrier(command_buffer, RDD::PIPELINE_STAGE_TRANSFER_BIT, RDD::PIPELINE_STAGE_VERTEX_SHADER_BIT | RDD::PIPELINE_STAGE_FRAGMENT_SHADER_BIT | RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT, {}, {}, tb);

- {

- uint32_t tight_buffer_size = get_image_format_required_size(tex->format, tex->width, tex->height, tex->depth, tex->mipmaps);

- buffer_data.resize(tight_buffer_size);

-

- uint8_t *write_ptr = buffer_data.ptrw();

-

- uint32_t w = tex->width;

- uint32_t h = tex->height;

- uint32_t d = tex->depth;

- for (uint32_t i = 0; i < tex->mipmaps; i++) {

- uint32_t width = 0, height = 0, depth = 0;

- uint32_t tight_mip_size = get_image_format_required_size(tex->format, w, h, d, 1, &width, &height, &depth);

- uint32_t block_w = 0, block_h = 0;

- get_compressed_image_format_block_dimensions(tex->format, block_w, block_h);

- uint32_t tight_row_pitch = tight_mip_size / ((height / block_h) * depth);

-

- {

- // Copy row-by-row to erase padding due to alignments.

- const uint8_t *rp = read_ptr;

- uint8_t *wp = write_ptr;

- for (uint32_t row = h * d / block_h; row != 0; row--) {

- memcpy(wp, rp, tight_row_pitch);

- rp += mip_layouts[i].row_pitch;

- wp += tight_row_pitch;

- }

- }

- w = MAX(1u, w >> 1);

- h = MAX(1u, h >> 1);

- d = MAX(1u, d >> 1);

- read_ptr += mip_layouts[i].size;

- write_ptr += tight_mip_size;

-Error RenderingDevice::texture_copy(RID p_from_texture, RID p_to_texture, const Vector3 &p_from, const Vector3 &p_to, const Vector3 &p_size, uint32_t p_src_mipmap, uint32_t p_dst_mipmap, uint32_t p_src_layer, uint32_t p_dst_layer, BitField<BarrierMask> p_post_barrier) {

- RDD::CommandBufferID command_buffer = frames[frame].draw_command_buffer;

- // PRE Copy the image.

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- { // Source.

- RDD::TextureBarrier tb;

- tb.texture = src_tex->driver_id;

- tb.dst_access = RDD::BARRIER_ACCESS_TRANSFER_READ_BIT;

- tb.prev_layout = src_tex->layout;

- tb.next_layout = RDD::TEXTURE_LAYOUT_TRANSFER_SRC_OPTIMAL;

- tb.subresources.aspect = src_tex->barrier_aspect_flags;

- tb.subresources.base_mipmap = p_src_mipmap;

- tb.subresources.mipmap_count = 1;

- tb.subresources.base_layer = p_src_layer;

- tb.subresources.layer_count = 1;

- driver->command_pipeline_barrier(command_buffer, RDD::PIPELINE_STAGE_TOP_OF_PIPE_BIT, RDD::PIPELINE_STAGE_TRANSFER_BIT, {}, {}, tb);

- }

- { // Dest.

- RDD::TextureBarrier tb;

- tb.texture = dst_tex->driver_id;

- tb.dst_access = RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT;

- tb.prev_layout = dst_tex->layout;

- tb.next_layout = RDD::TEXTURE_LAYOUT_TRANSFER_DST_OPTIMAL;

- tb.subresources.aspect = dst_tex->read_aspect_flags;

- tb.subresources.base_mipmap = p_dst_mipmap;

- tb.subresources.mipmap_count = 1;

- tb.subresources.base_layer = p_dst_layer;

- tb.subresources.layer_count = 1;

-

- driver->command_pipeline_barrier(command_buffer, RDD::PIPELINE_STAGE_TOP_OF_PIPE_BIT, RDD::PIPELINE_STAGE_TRANSFER_BIT, {}, {}, tb);

- }

- // COPY.

-

- {

- RDD::TextureCopyRegion copy_region;

- copy_region.src_subresources.aspect = src_tex->read_aspect_flags;

- copy_region.src_subresources.mipmap = p_src_mipmap;

- copy_region.src_subresources.base_layer = p_src_layer;

- copy_region.src_subresources.layer_count = 1;

- copy_region.src_offset = p_from;

-

- copy_region.dst_subresources.aspect = dst_tex->read_aspect_flags;

- copy_region.dst_subresources.mipmap = p_dst_mipmap;

- copy_region.dst_subresources.base_layer = p_dst_layer;

- copy_region.dst_subresources.layer_count = 1;

- copy_region.dst_offset = p_to;

-

- copy_region.size = p_size;

-

- driver->command_copy_texture(command_buffer, src_tex->driver_id, RDD::TEXTURE_LAYOUT_TRANSFER_SRC_OPTIMAL, dst_tex->driver_id, RDD::TEXTURE_LAYOUT_TRANSFER_DST_OPTIMAL, copy_region);

- }

-

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- // RESTORE LAYOUT for SRC and DST.

-

- BitField<RDD::PipelineStageBits> stages;

- BitField<RDD::BarrierAccessBits> access;

- if (p_post_barrier.has_flag(BARRIER_MASK_COMPUTE)) {

- stages.set_flag(RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT);

- access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_VERTEX)) {

- stages.set_flag(RDD::PIPELINE_STAGE_VERTEX_SHADER_BIT);

- access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_FRAGMENT)) {

- stages.set_flag(RDD::PIPELINE_STAGE_FRAGMENT_SHADER_BIT);

- access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_TRANSFER)) {

- stages.set_flag(RDD::PIPELINE_STAGE_TRANSFER_BIT);

- access.set_flag(RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT);

- }

-

- if (stages.is_empty()) {

- stages.set_flag(RDD::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT);

- }

-

- { // Restore src.

- RDD::TextureBarrier tb;

- tb.texture = src_tex->driver_id;

- tb.src_access = RDD::BARRIER_ACCESS_TRANSFER_READ_BIT;

- tb.dst_access = access;

- tb.prev_layout = RDD::TEXTURE_LAYOUT_TRANSFER_SRC_OPTIMAL;

- tb.next_layout = src_tex->layout;

- tb.subresources.aspect = src_tex->barrier_aspect_flags;

- tb.subresources.base_mipmap = p_src_mipmap;

- tb.subresources.mipmap_count = 1;

- tb.subresources.base_layer = p_src_layer;

- tb.subresources.layer_count = 1;

-

- driver->command_pipeline_barrier(command_buffer, RDD::PIPELINE_STAGE_TRANSFER_BIT, stages, {}, {}, tb);

- }

-

- { // Make dst readable.

-

- RDD::TextureBarrier tb;

- tb.texture = dst_tex->driver_id;

- tb.src_access = RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT;

- tb.dst_access = access;

- tb.prev_layout = RDD::TEXTURE_LAYOUT_TRANSFER_DST_OPTIMAL;

- tb.next_layout = dst_tex->layout;

- tb.subresources.aspect = dst_tex->read_aspect_flags;

- tb.subresources.base_mipmap = p_dst_mipmap;

- tb.subresources.mipmap_count = 1;

- tb.subresources.base_layer = p_dst_layer;

- tb.subresources.layer_count = 1;

-

- driver->command_pipeline_barrier(command_buffer, RDD::PIPELINE_STAGE_TRANSFER_BIT, stages, {}, {}, tb);

- }

-

- if (dst_tex->used_in_frame != frames_drawn) {

- dst_tex->used_in_raster = false;

- dst_tex->used_in_compute = false;

- dst_tex->used_in_frame = frames_drawn;

- }

- dst_tex->used_in_transfer = true;

- }

-Error RenderingDevice::texture_resolve_multisample(RID p_from_texture, RID p_to_texture, BitField<BarrierMask> p_post_barrier) {

- RDD::CommandBufferID command_buffer = frames[frame].draw_command_buffer;

-

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- // PRE Copy the image.

-

- { // Source.

- RDD::TextureBarrier tb;

- tb.texture = src_tex->driver_id;

- tb.dst_access = RDD::BARRIER_ACCESS_TRANSFER_READ_BIT;

- tb.prev_layout = src_tex->layout;

- tb.next_layout = RDD::TEXTURE_LAYOUT_TRANSFER_SRC_OPTIMAL;

- tb.subresources.aspect = src_tex->barrier_aspect_flags;

- tb.subresources.base_mipmap = src_tex->base_mipmap;

- tb.subresources.mipmap_count = 1;

- tb.subresources.base_layer = src_tex->base_layer;

- tb.subresources.layer_count = 1;

-

- driver->command_pipeline_barrier(command_buffer, RDD::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, RDD::PIPELINE_STAGE_TRANSFER_BIT, {}, {}, tb);

- }

- { // Dest.

- RDD::TextureBarrier tb;

- tb.texture = dst_tex->driver_id;

- tb.dst_access = RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT;

- tb.prev_layout = dst_tex->layout;

- tb.next_layout = RDD::TEXTURE_LAYOUT_TRANSFER_DST_OPTIMAL;

- tb.subresources.aspect = dst_tex->barrier_aspect_flags;

- tb.subresources.base_mipmap = dst_tex->base_mipmap;

- tb.subresources.mipmap_count = 1;

- tb.subresources.base_layer = dst_tex->base_layer;

- tb.subresources.layer_count = 1;

-

- driver->command_pipeline_barrier(command_buffer, RDD::PIPELINE_STAGE_TOP_OF_PIPE_BIT, RDD::PIPELINE_STAGE_TRANSFER_BIT, {}, {}, tb);

- }

- // RESOLVE.

- driver->command_resolve_texture(command_buffer, src_tex->driver_id, RDD::TEXTURE_LAYOUT_TRANSFER_SRC_OPTIMAL, src_tex->base_layer, src_tex->base_mipmap, dst_tex->driver_id, RDD::TEXTURE_LAYOUT_TRANSFER_DST_OPTIMAL, dst_tex->base_layer, dst_tex->base_mipmap);

-

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- // RESTORE LAYOUT for SRC and DST.

-

- BitField<RDD::PipelineStageBits> stages;

- BitField<RDD::BarrierAccessBits> access;

- if (p_post_barrier.has_flag(BARRIER_MASK_COMPUTE)) {

- stages.set_flag(RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT);

- access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_VERTEX)) {

- stages.set_flag(RDD::PIPELINE_STAGE_VERTEX_SHADER_BIT);

- access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_FRAGMENT)) {

- stages.set_flag(RDD::PIPELINE_STAGE_FRAGMENT_SHADER_BIT);

- access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_TRANSFER)) {

- stages.set_flag(RDD::PIPELINE_STAGE_TRANSFER_BIT);

- access.set_flag(RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT);

- }

-

- if (stages.is_empty()) {

- stages.set_flag(RDD::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT);

- }

-

- { // Restore src.

- RDD::TextureBarrier tb;

- tb.texture = src_tex->driver_id;

- tb.src_access = RDD::BARRIER_ACCESS_TRANSFER_READ_BIT;

- tb.dst_access = access;

- tb.prev_layout = RDD::TEXTURE_LAYOUT_TRANSFER_SRC_OPTIMAL;

- tb.next_layout = src_tex->layout;

- tb.subresources.aspect = src_tex->barrier_aspect_flags;

- tb.subresources.base_mipmap = src_tex->base_mipmap;

- tb.subresources.mipmap_count = 1;

- tb.subresources.base_layer = src_tex->base_layer;

- tb.subresources.layer_count = 1;

-

- driver->command_pipeline_barrier(command_buffer, RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT, stages, {}, {}, tb);

- }

-

- { // Make dst readable.

-

- RDD::TextureBarrier tb;

- tb.texture = dst_tex->driver_id;

- tb.src_access = RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT;

- tb.dst_access = access;

- tb.prev_layout = RDD::TEXTURE_LAYOUT_TRANSFER_DST_OPTIMAL;

- tb.next_layout = dst_tex->layout;

- tb.subresources.aspect = RDD::TEXTURE_ASPECT_COLOR_BIT;

- tb.subresources.base_mipmap = dst_tex->base_mipmap;

- tb.subresources.mipmap_count = 1;

- tb.subresources.base_layer = dst_tex->base_layer;

- tb.subresources.layer_count = 1;

-

- driver->command_pipeline_barrier(command_buffer, RDD::PIPELINE_STAGE_TRANSFER_BIT, stages, {}, {}, tb);

- }

- }

-Error RenderingDevice::texture_clear(RID p_texture, const Color &p_color, uint32_t p_base_mipmap, uint32_t p_mipmaps, uint32_t p_base_layer, uint32_t p_layers, BitField<BarrierMask> p_post_barrier) {

- RDD::CommandBufferID command_buffer = frames[frame].draw_command_buffer;

-

- RDD::TextureLayout clear_layout = (src_tex->layout == RDD::TEXTURE_LAYOUT_GENERAL) ? RDD::TEXTURE_LAYOUT_GENERAL : RDD::TEXTURE_LAYOUT_TRANSFER_DST_OPTIMAL;

-

- // NOTE: Perhaps the valid stages/accesses for a given owner should be a property of the owner. (Here and places like _get_buffer_from_owner.)

- const BitField<RDD::PipelineStageBits> valid_texture_stages = RDD::PIPELINE_STAGE_VERTEX_SHADER_BIT | RDD::PIPELINE_STAGE_FRAGMENT_SHADER_BIT | RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT;

- constexpr BitField<RDD::BarrierAccessBits> read_access = RDD::BARRIER_ACCESS_SHADER_READ_BIT;

- constexpr BitField<RDD::BarrierAccessBits> read_write_access = RDD::BARRIER_ACCESS_SHADER_READ_BIT | RDD::BARRIER_ACCESS_SHADER_WRITE_BIT;

- const BitField<RDD::BarrierAccessBits> valid_texture_access = (src_tex->usage_flags & TEXTURE_USAGE_STORAGE_BIT) ? read_write_access : read_access;

-

- // Barrier from previous access with optional layout change (see clear_layout logic above).

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- RDD::TextureBarrier tb;

- tb.texture = src_tex->driver_id;

- tb.src_access = valid_texture_access;

- tb.dst_access = RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT;

- tb.prev_layout = src_tex->layout;

- tb.next_layout = clear_layout;

- tb.subresources.aspect = src_tex->read_aspect_flags;

- tb.subresources.base_mipmap = src_tex->base_mipmap + p_base_mipmap;

- tb.subresources.mipmap_count = p_mipmaps;

- tb.subresources.base_layer = src_tex->base_layer + p_base_layer;

- tb.subresources.layer_count = p_layers;

-

- driver->command_pipeline_barrier(command_buffer, valid_texture_stages, RDD::PIPELINE_STAGE_TRANSFER_BIT, {}, {}, tb);

- }

-

- driver->command_clear_color_texture(command_buffer, src_tex->driver_id, clear_layout, p_color, range);

-

- // Barrier to post clear accesses (changing back the layout if needed).

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- BitField<RDD::PipelineStageBits> stages;

- BitField<RDD::BarrierAccessBits> access;

- if (p_post_barrier.has_flag(BARRIER_MASK_COMPUTE)) {

- stages.set_flag(RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT);

- access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_VERTEX)) {

- stages.set_flag(RDD::PIPELINE_STAGE_VERTEX_SHADER_BIT);

- access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_FRAGMENT)) {

- stages.set_flag(RDD::PIPELINE_STAGE_FRAGMENT_SHADER_BIT);

- access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_TRANSFER)) {

- stages.set_flag(RDD::PIPELINE_STAGE_TRANSFER_BIT);

- access.set_flag(RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT);

- }

-

- if (stages.is_empty()) {

- stages.set_flag(RDD::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT);

- }

-

- RDD::TextureBarrier tb;

- tb.texture = src_tex->driver_id;

- tb.src_access = RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT;

- tb.dst_access = access;

- tb.prev_layout = clear_layout;

- tb.next_layout = src_tex->layout;

- tb.subresources.aspect = src_tex->read_aspect_flags;

- tb.subresources.base_mipmap = src_tex->base_mipmap + p_base_mipmap;

- tb.subresources.mipmap_count = p_mipmaps;

- tb.subresources.base_layer = src_tex->base_layer + p_base_layer;

- tb.subresources.layer_count = p_layers;

-

- driver->command_pipeline_barrier(command_buffer, RDD::PIPELINE_STAGE_TRANSFER_BIT, stages, {}, {}, tb);

-

- if (src_tex->used_in_frame != frames_drawn) {

- src_tex->used_in_raster = false;

- src_tex->used_in_compute = false;

- src_tex->used_in_frame = frames_drawn;

- }

- src_tex->used_in_transfer = true;

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

-

- // For VRS we only read, there is no writing to this texture.

- description.initial_layout = RDD::TEXTURE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;

- description.stencil_load_op = RDD::ATTACHMENT_LOAD_OP_LOAD;

- } else {

- // For each UNDEFINED, assume the prior use was a *read*, as we'd be discarding the output of a write.

- // Also, each UNDEFINED will do an immediate layout transition (write), s.t. we must ensure execution synchronization vs

- // the read. If this is a performance issue, one could track the actual last accessor of each resource, adding only that

- // stage.

-

- switch (is_depth ? p_initial_depth_action : p_initial_action) {

- case INITIAL_ACTION_CLEAR_REGION:

- case INITIAL_ACTION_CLEAR: {

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

- description.load_op = RDD::ATTACHMENT_LOAD_OP_CLEAR;

- description.initial_layout = is_sampled ? RDD::TEXTURE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : (is_storage ? RDD::TEXTURE_LAYOUT_GENERAL : RDD::TEXTURE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);

- description.stencil_load_op = RDD::ATTACHMENT_LOAD_OP_DONT_CARE;

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

- description.load_op = RDD::ATTACHMENT_LOAD_OP_CLEAR;

- description.initial_layout = is_sampled ? RDD::TEXTURE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : (is_storage ? RDD::TEXTURE_LAYOUT_GENERAL : RDD::TEXTURE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);

- description.stencil_load_op = RDD::ATTACHMENT_LOAD_OP_CLEAR;

- } else {

- description.load_op = RDD::ATTACHMENT_LOAD_OP_DONT_CARE;

- description.stencil_load_op = RDD::ATTACHMENT_LOAD_OP_DONT_CARE;

- description.initial_layout = RDD::TEXTURE_LAYOUT_UNDEFINED; // Don't care what is there.

- }

- } break;

- case INITIAL_ACTION_KEEP: {

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

- description.load_op = RDD::ATTACHMENT_LOAD_OP_LOAD;

- description.initial_layout = is_sampled ? RDD::TEXTURE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : (is_storage ? RDD::TEXTURE_LAYOUT_GENERAL : RDD::TEXTURE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);

- description.stencil_load_op = RDD::ATTACHMENT_LOAD_OP_DONT_CARE;

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

- description.load_op = RDD::ATTACHMENT_LOAD_OP_LOAD;

- description.initial_layout = is_sampled ? RDD::TEXTURE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : (is_storage ? RDD::TEXTURE_LAYOUT_GENERAL : RDD::TEXTURE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);

- description.stencil_load_op = RDD::ATTACHMENT_LOAD_OP_LOAD;

- } else {

- description.load_op = RDD::ATTACHMENT_LOAD_OP_DONT_CARE;

- description.stencil_load_op = RDD::ATTACHMENT_LOAD_OP_DONT_CARE;

- description.initial_layout = RDD::TEXTURE_LAYOUT_UNDEFINED; // Don't care what is there.

- }

- } break;

- case INITIAL_ACTION_DROP: {

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

- description.load_op = RDD::ATTACHMENT_LOAD_OP_DONT_CARE;

- description.initial_layout = is_sampled ? RDD::TEXTURE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : (is_storage ? RDD::TEXTURE_LAYOUT_GENERAL : RDD::TEXTURE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);

- description.stencil_load_op = RDD::ATTACHMENT_LOAD_OP_DONT_CARE;

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

- description.load_op = RDD::ATTACHMENT_LOAD_OP_DONT_CARE;

- description.initial_layout = RDD::TEXTURE_LAYOUT_UNDEFINED; // Don't care what is there.

- description.stencil_load_op = RDD::ATTACHMENT_LOAD_OP_DONT_CARE;

- } else {

- description.load_op = RDD::ATTACHMENT_LOAD_OP_DONT_CARE;

- description.stencil_load_op = RDD::ATTACHMENT_LOAD_OP_DONT_CARE;

- description.initial_layout = RDD::TEXTURE_LAYOUT_UNDEFINED; // Don't care what is there.

- }

- } break;

- case INITIAL_ACTION_CLEAR_REGION_CONTINUE:

- case INITIAL_ACTION_CONTINUE: {

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

- description.load_op = RDD::ATTACHMENT_LOAD_OP_LOAD;

- description.initial_layout = RDD::TEXTURE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;

- description.stencil_load_op = RDD::ATTACHMENT_LOAD_OP_DONT_CARE;

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

- description.load_op = RDD::ATTACHMENT_LOAD_OP_LOAD;

- description.initial_layout = RDD::TEXTURE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;

- description.stencil_load_op = RDD::ATTACHMENT_LOAD_OP_LOAD;

- } else {

- description.load_op = RDD::ATTACHMENT_LOAD_OP_DONT_CARE;

- description.stencil_load_op = RDD::ATTACHMENT_LOAD_OP_DONT_CARE;

- description.initial_layout = RDD::TEXTURE_LAYOUT_UNDEFINED; // Don't care what is there.

- }

- } break;

- default: {

- ERR_FAIL_V(RDD::RenderPassID()); // Should never reach here.

- }

- }

- }

-

- bool used_last = false;

-

- {

- int last_pass = p_passes.size() - 1;

-

- if (is_depth) {

- // Likely missing depth resolve?

- if (p_passes[last_pass].depth_attachment == i) {

- used_last = true;

- }

- } else if (is_vrs) {

- if (p_passes[last_pass].vrs_attachment == i) {

- used_last = true;

- }

- } else {

- if (p_passes[last_pass].resolve_attachments.size()) {

- // If using resolve attachments, check resolve attachments.

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

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

- used_last = true;

- break;

- }

- }

- }

- if (!used_last) {

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

- break;

- }

- }

- }

- }

-

- if (!used_last) {

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

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

- used_last = true;

- break;

- }

- }

- }

- }

-

- FinalAction final_action = p_final_action;

- FinalAction final_depth_action = p_final_depth_action;

-

- if (!used_last) {

- if (is_depth) {

- final_depth_action = FINAL_ACTION_DISCARD;

-

- } else {

- final_action = FINAL_ACTION_DISCARD;

- }

- }

-

- if (is_vrs) {

- // We don't change our VRS texture during this process.

-

- switch (is_depth ? final_depth_action : final_action) {

- case FINAL_ACTION_READ: {

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

- description.store_op = RDD::ATTACHMENT_STORE_OP_STORE;

- description.stencil_store_op = RDD::ATTACHMENT_STORE_OP_DONT_CARE;

- description.final_layout = is_sampled ? RDD::TEXTURE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : (is_storage ? RDD::TEXTURE_LAYOUT_GENERAL : RDD::TEXTURE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);

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

- description.store_op = RDD::ATTACHMENT_STORE_OP_STORE;

- description.stencil_store_op = RDD::ATTACHMENT_STORE_OP_STORE;

- description.final_layout = is_sampled ? RDD::TEXTURE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : (is_storage ? RDD::TEXTURE_LAYOUT_GENERAL : RDD::TEXTURE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);

- } else {

- description.load_op = RDD::ATTACHMENT_LOAD_OP_DONT_CARE;

- description.stencil_load_op = RDD::ATTACHMENT_LOAD_OP_DONT_CARE;

- description.final_layout = RDD::TEXTURE_LAYOUT_UNDEFINED; // Don't care what is there.

- // TODO: What does this mean about the next usage (and thus appropriate dependency masks.

- }

- } break;

- case FINAL_ACTION_DISCARD: {

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

- description.store_op = RDD::ATTACHMENT_STORE_OP_DONT_CARE;

- description.stencil_store_op = RDD::ATTACHMENT_STORE_OP_DONT_CARE;

- description.final_layout = is_sampled ? RDD::TEXTURE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : (is_storage ? RDD::TEXTURE_LAYOUT_GENERAL : RDD::TEXTURE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);

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

- description.store_op = RDD::ATTACHMENT_STORE_OP_DONT_CARE;

- description.stencil_store_op = RDD::ATTACHMENT_STORE_OP_DONT_CARE;

- description.final_layout = is_sampled ? RDD::TEXTURE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : (is_storage ? RDD::TEXTURE_LAYOUT_GENERAL : RDD::TEXTURE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);

- } else {

- description.store_op = RDD::ATTACHMENT_STORE_OP_DONT_CARE;

- description.stencil_store_op = RDD::ATTACHMENT_STORE_OP_DONT_CARE;

- description.final_layout = RDD::TEXTURE_LAYOUT_UNDEFINED; // Don't care what is there.

- }

- } break;

- case FINAL_ACTION_CONTINUE: {

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

- description.store_op = RDD::ATTACHMENT_STORE_OP_STORE;

- description.stencil_store_op = RDD::ATTACHMENT_STORE_OP_DONT_CARE;

- description.final_layout = RDD::TEXTURE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;

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

- description.store_op = RDD::ATTACHMENT_STORE_OP_STORE;

- description.stencil_store_op = RDD::ATTACHMENT_STORE_OP_STORE;

- description.final_layout = RDD::TEXTURE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;

- } else {

- description.store_op = RDD::ATTACHMENT_STORE_OP_DONT_CARE;

- description.stencil_store_op = RDD::ATTACHMENT_STORE_OP_DONT_CARE;

- description.final_layout = RDD::TEXTURE_LAYOUT_UNDEFINED; // Don't care what is there.

- }

-

- } break;

- default: {

- ERR_FAIL_V(RDD::RenderPassID()); // Should never reach here.

- }

- RDD::RenderPassID 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.

- uint64_t data_size = p_data.size();

- const uint8_t *r = p_data.ptr();

- _buffer_update(&buffer, 0, r, data_size);

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- RDD::BufferBarrier bb;

- bb.buffer = buffer.driver_id;

- bb.src_access = RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT;

- bb.dst_access = RDD::BARRIER_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;

- bb.size = data_size;

- driver->command_pipeline_barrier(frames[frame].setup_command_buffer, RDD::PIPELINE_STAGE_TRANSFER_BIT, RDD::PIPELINE_STAGE_VERTEX_INPUT_BIT, {}, bb, {});

- }

- uint64_t data_size = p_data.size();

- const uint8_t *r = p_data.ptr();

- _buffer_update(&index_buffer, 0, r, data_size);

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- RDD::BufferBarrier bb;

- bb.buffer = index_buffer.driver_id;

- bb.src_access = RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT;

- bb.dst_access = RDD::BARRIER_ACCESS_INDEX_READ_BIT;

- bb.size = data_size;

- driver->command_pipeline_barrier(frames[frame].setup_command_buffer, RDD::PIPELINE_STAGE_TRANSFER_BIT, RDD::PIPELINE_STAGE_VERTEX_INPUT_BIT, {}, bb, {});

- }

- uint64_t data_size = p_data.size();

- const uint8_t *r = p_data.ptr();

- _buffer_update(&buffer, 0, r, data_size);

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- RDD::BufferBarrier bb;

- bb.buffer = buffer.driver_id;

- bb.src_access = RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT;

- bb.dst_access = RDD::BARRIER_ACCESS_UNIFORM_READ_BIT;

- bb.size = data_size;

- driver->command_pipeline_barrier(frames[frame].setup_command_buffer, RDD::PIPELINE_STAGE_TRANSFER_BIT, RDD::PIPELINE_STAGE_VERTEX_SHADER_BIT | RDD::PIPELINE_STAGE_FRAGMENT_SHADER_BIT | RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT, {}, bb, {});

- }

- Vector<Texture *> mutable_sampled_textures;

- Vector<Texture *> mutable_storage_textures;

- Texture *texture = texture_owner.get_or_null(uniform.get_id(j + 1));

- if ((texture->usage_flags & TEXTURE_USAGE_STORAGE_BIT)) {

- mutable_sampled_textures.push_back(texture);

- Texture *texture = texture_owner.get_or_null(uniform.get_id(j));

- if ((texture->usage_flags & TEXTURE_USAGE_STORAGE_BIT)) {

- mutable_sampled_textures.push_back(texture);

- Texture *texture = texture_owner.get_or_null(uniform.get_id(j));

- if ((texture->usage_flags & TEXTURE_USAGE_SAMPLING_BIT)) {

- mutable_storage_textures.push_back(texture);

- Buffer *buffer = texture_buffer_owner.get_or_null(uniform.get_id(j));

- Buffer *buffer = texture_buffer_owner.get_or_null(uniform.get_id(j + 1));

- Buffer *buffer = uniform_buffer_owner.get_or_null(uniform.get_id(0));

- if (storage_buffer_owner.owns(uniform.get_id(0))) {

- buffer = storage_buffer_owner.get_or_null(uniform.get_id(0));

- } else if (vertex_buffer_owner.owns(uniform.get_id(0))) {

- buffer = vertex_buffer_owner.get_or_null(uniform.get_id(0));

- Texture *texture = texture_owner.get_or_null(uniform.get_id(j));

- uniform_set.mutable_sampled_textures = mutable_sampled_textures;

- uniform_set.mutable_storage_textures = mutable_storage_textures;

- RDD::CommandBufferID command_buffer = frames[frame].draw_command_buffer;

-

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

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

- driver->command_begin_render_pass(

- command_buffer,

- context->window_get_render_pass(p_screen),

- context->window_get_framebuffer(p_screen),

- RDD::COMMAND_BUFFER_TYPE_PRIMARY,

- Rect2i(0, 0, size.width, size.height),

- VectorView(&clear_value, 1));

- driver->command_render_set_viewport(command_buffer, Rect2i(Point2i(), size));

- driver->command_render_set_scissor(command_buffer, Rect2i(Point2i(), size));

-Error RenderingDevice::_draw_list_render_pass_begin(Framebuffer *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_colors, float p_clear_depth, uint32_t p_clear_stencil, Point2i p_viewport_offset, Point2i p_viewport_size, RDD::FramebufferID p_framebuffer_driver_id, RDD::RenderPassID p_render_pass, RDD::CommandBufferID p_command_buffer, RDD::CommandBufferType p_cmd_buffer_mode, const Vector<RID> &p_storage_textures, bool p_constrained_to_region) {

- if (color_index < p_clear_colors.size() && texture->usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT) {

- ERR_FAIL_INDEX_V(color_index, p_clear_colors.size(), ERR_BUG); // A bug.

- clear_value.color = p_clear_colors[color_index];

- color_index++;

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

- Texture *texture = texture_owner.get_or_null(p_storage_textures[i]);

- if (!texture) {

- continue;

- }

- ERR_CONTINUE_MSG(!(texture->usage_flags & TEXTURE_USAGE_STORAGE_BIT), "Supplied storage texture " + itos(i) + " for draw list is not set to be used for storage.");

-

- if (texture->usage_flags & TEXTURE_USAGE_SAMPLING_BIT) {

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- // Must change layout to general.

- RDD::TextureBarrier tb;

- tb.texture = texture->driver_id;

- tb.src_access = (RDD::BARRIER_ACCESS_SHADER_READ_BIT | RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- tb.dst_access = (RDD::BARRIER_ACCESS_SHADER_READ_BIT | RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- tb.prev_layout = texture->layout;

- tb.next_layout = RDD::TEXTURE_LAYOUT_GENERAL;

- tb.subresources.aspect = texture->read_aspect_flags;

- tb.subresources.base_mipmap = texture->base_mipmap;

- tb.subresources.mipmap_count = texture->mipmaps;

- tb.subresources.base_layer = texture->base_layer;

- tb.subresources.layer_count = texture->layers;

-

- driver->command_pipeline_barrier(p_command_buffer, RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT | RDD::PIPELINE_STAGE_FRAGMENT_SHADER_BIT, RDD::PIPELINE_STAGE_VERTEX_INPUT_BIT | RDD::PIPELINE_STAGE_FRAGMENT_SHADER_BIT, {}, {}, tb);

-

- texture->layout = RDD::TEXTURE_LAYOUT_GENERAL;

- }

-

- draw_list_storage_textures.push_back(p_storage_textures[i]);

- }

- }

-

- Rect2i region;

- if (p_constrained_to_region) {

- region = Rect2i(p_viewport_offset, p_viewport_size);

- } else {

- region = Rect2i(Point2i(), p_framebuffer->size);

- }

-

- driver->command_begin_render_pass(

- p_command_buffer,

- p_render_pass,

- p_framebuffer_driver_id,

- p_cmd_buffer_mode,

- region,

- clear_values);

- draw_list_unbind_color_textures = p_final_color_action != FINAL_ACTION_CONTINUE;

- draw_list_unbind_depth_textures = p_final_depth_action != FINAL_ACTION_CONTINUE;

-

- driver->command_render_clear_attachments(p_draw_list->command_buffer, clear_attachments, rect);

-RenderingDevice::DrawListID RenderingDevice::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) {

- ERR_FAIL_COND_V_MSG(compute_list != nullptr && !compute_list->state.allow_draw_overlap, INVALID_ID, "Only one draw/compute list can be active at the same time.");

- bool constrained_to_region = false;

- bool needs_clear_color = false;

- bool needs_clear_depth = false;

-

- // If clearing regions both in color and depth, we can switch to a fast path where we let Vulkan to the clears

- // and we constrain the render area to the region.

- if (p_initial_color_action == INITIAL_ACTION_CLEAR_REGION && p_initial_depth_action == INITIAL_ACTION_CLEAR_REGION) {

- constrained_to_region = true;

- p_initial_color_action = INITIAL_ACTION_CLEAR;

- p_initial_depth_action = INITIAL_ACTION_CLEAR;

- } else {

- if (p_initial_color_action == INITIAL_ACTION_CLEAR_REGION_CONTINUE) {

- needs_clear_color = true;

- p_initial_color_action = INITIAL_ACTION_CONTINUE;

- }

- if (p_initial_depth_action == INITIAL_ACTION_CLEAR_REGION_CONTINUE) {

- needs_clear_depth = true;

- p_initial_depth_action = INITIAL_ACTION_CONTINUE;

- }

- if (p_initial_color_action == INITIAL_ACTION_CLEAR_REGION) {

- needs_clear_color = true;

- p_initial_color_action = INITIAL_ACTION_KEEP;

- }

- if (p_initial_depth_action == INITIAL_ACTION_CLEAR_REGION) {

- needs_clear_depth = true;

- p_initial_depth_action = INITIAL_ACTION_KEEP;

- }

- }

- if (p_initial_color_action == INITIAL_ACTION_CLEAR || needs_clear_color) { // Check clear values.

- RDD::CommandBufferID command_buffer = frames[frame].draw_command_buffer;

- err = _draw_list_render_pass_begin(framebuffer, p_initial_color_action, p_final_color_action, p_initial_depth_action, p_final_depth_action, p_clear_color_values, p_clear_depth, p_clear_stencil, viewport_offset, viewport_size, fb_driver_id, render_pass, command_buffer, RDD::COMMAND_BUFFER_TYPE_PRIMARY, p_storage_textures, constrained_to_region);

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

- if (needs_clear_color || needs_clear_depth) {

- DEV_ASSERT(!constrained_to_region);

- _draw_list_insert_clear_region(draw_list, framebuffer, viewport_offset, viewport_size, needs_clear_color, p_clear_color_values, needs_clear_depth, p_clear_depth, p_clear_stencil);

- }

-

- driver->command_render_set_viewport(command_buffer, Rect2i(viewport_offset, viewport_size));

- driver->command_render_set_scissor(command_buffer, Rect2i(viewport_offset, viewport_size));

- _THREAD_SAFE_METHOD_

-

- ERR_FAIL_COND_V_MSG(draw_list != nullptr, ERR_BUSY, "Only one draw list can be active at the same time.");

- ERR_FAIL_COND_V_MSG(compute_list != nullptr && !compute_list->state.allow_draw_overlap, ERR_BUSY, "Only one draw/compute list can be active at the same time.");

-

- ERR_FAIL_COND_V(p_splits < 1, ERR_INVALID_DECLARATION);

-

- Framebuffer *framebuffer = framebuffer_owner.get_or_null(p_framebuffer);

- ERR_FAIL_NULL_V(framebuffer, ERR_INVALID_DECLARATION);

-

- Point2i viewport_offset;

- Point2i viewport_size = framebuffer->size;

- bool constrained_to_region = false;

- bool needs_clear_color = false;

- bool needs_clear_depth = false;

-

- if (p_region != Rect2() && p_region != Rect2(Vector2(), viewport_size)) { // Check custom region.

- Rect2i viewport(viewport_offset, viewport_size);

- Rect2i regioni = p_region;

- if (!(regioni.position.x >= viewport.position.x) && (regioni.position.y >= viewport.position.y) &&

- ((regioni.position.x + regioni.size.x) <= (viewport.position.x + viewport.size.x)) &&

- ((regioni.position.y + regioni.size.y) <= (viewport.position.y + viewport.size.y))) {

- ERR_FAIL_V_MSG(ERR_INVALID_PARAMETER, "When supplying a custom region, it must be contained within the framebuffer rectangle");

- }

-

- viewport_offset = regioni.position;

- viewport_size = regioni.size;

-

- // If clearing regions both in color and depth, we can switch to a fast path where we let Vulkan to the clears

- // and we constrain the render area to the region.

- if (p_initial_color_action == INITIAL_ACTION_CLEAR_REGION && p_initial_depth_action == INITIAL_ACTION_CLEAR_REGION) {

- constrained_to_region = true;

- p_initial_color_action = INITIAL_ACTION_CLEAR;

- p_initial_depth_action = INITIAL_ACTION_CLEAR;

- } else {

- if (p_initial_color_action == INITIAL_ACTION_CLEAR_REGION_CONTINUE) {

- needs_clear_color = true;

- p_initial_color_action = INITIAL_ACTION_CONTINUE;

- }

- if (p_initial_depth_action == INITIAL_ACTION_CLEAR_REGION_CONTINUE) {

- needs_clear_depth = true;

- p_initial_depth_action = INITIAL_ACTION_CONTINUE;

- }

- if (p_initial_color_action == INITIAL_ACTION_CLEAR_REGION) {

- needs_clear_color = true;

- p_initial_color_action = INITIAL_ACTION_KEEP;

- }

- if (p_initial_depth_action == INITIAL_ACTION_CLEAR_REGION) {

- needs_clear_depth = true;

- p_initial_depth_action = INITIAL_ACTION_KEEP;

- }

- }

- }

-

- if (p_initial_color_action == INITIAL_ACTION_CLEAR || needs_clear_color) { // Check clear values.

-

- int color_count = 0;

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

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

-

- if (!texture || !(texture->usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_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) + ").");

- }

-

- RDD::FramebufferID fb_driver_id;

- RDD::RenderPassID render_pass;

-

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

- ERR_FAIL_COND_V(err != OK, ERR_CANT_CREATE);

-

- RDD::CommandBufferID frame_command_buffer = frames[frame].draw_command_buffer;

- err = _draw_list_render_pass_begin(framebuffer, p_initial_color_action, p_final_color_action, p_initial_depth_action, p_final_depth_action, p_clear_color_values, p_clear_depth, p_clear_stencil, viewport_offset, viewport_size, fb_driver_id, render_pass, frame_command_buffer, RDD::COMMAND_BUFFER_TYPE_SECONDARY, p_storage_textures, constrained_to_region);

-

- if (err != OK) {

- return ERR_CANT_CREATE;

- }

-

- draw_list_current_subpass = 0;

-

-#ifdef DEBUG_ENABLED

- draw_list_framebuffer_format = framebuffer->format_id;

-#endif

- draw_list_render_pass = render_pass;

- draw_list_vkframebuffer = fb_driver_id;

-

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

- if (err != OK) {

- return err;

- }

-

- if (needs_clear_color || needs_clear_depth) {

- DEV_ASSERT(!constrained_to_region);

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

- }

-

- bool secondary_viewport_scissor = driver->api_trait_get(RDD::API_TRAIT_SECONDARY_VIEWPORT_SCISSOR);

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

- if (secondary_viewport_scissor) {

- driver->command_render_set_viewport(draw_list[i].command_buffer, Rect2i(viewport_offset, viewport_size));

- driver->command_render_set_scissor(draw_list[i].command_buffer, Rect2i(viewport_offset, viewport_size));

- }

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

- }

-

- return OK;

- if (draw_list_split) {

- return nullptr;

- }

- } else if (p_id >> DrawListID(ID_BASE_SHIFT) == ID_TYPE_SPLIT_DRAW_LIST) {

- if (!draw_list_split) {

- return nullptr;

- }

-

- uint64_t index = p_id & ((DrawListID(1) << DrawListID(ID_BASE_SHIFT)) - 1); // Mask.

-

- if (index >= draw_list_count) {

- return nullptr;

- }

-

- return &draw_list[index];

- driver->command_render_set_blend_constants(dl->command_buffer, p_color);

- driver->command_bind_render_pipeline(dl->command_buffer, pipeline->driver_id);

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- uint32_t mst_count = uniform_set->mutable_storage_textures.size();

- if (mst_count) {

- Texture **mst_textures = const_cast<UniformSet *>(uniform_set)->mutable_storage_textures.ptrw();

- for (uint32_t i = 0; i < mst_count; i++) {

- if (mst_textures[i]->used_in_frame != frames_drawn) {

- mst_textures[i]->used_in_frame = frames_drawn;

- mst_textures[i]->used_in_transfer = false;

- mst_textures[i]->used_in_compute = false;

- }

- mst_textures[i]->used_in_raster = true;

- }

- }

- }

-

- driver->command_render_bind_vertex_buffers(dl->command_buffer, vertex_array->buffers.size(), vertex_array->buffers.ptr(), vertex_array->offsets.ptr());

- driver->command_render_bind_index_buffer(dl->command_buffer, index_array->driver_id, index_array->format, index_array->offset);

- driver->command_render_set_line_width(dl->command_buffer, p_width);

- driver->command_bind_push_constants(dl->command_buffer, dl->state.pipeline_shader_driver_id, 0, VectorView((const uint32_t *)p_data, p_data_size / sizeof(uint32_t)));

- driver->command_uniform_set_prepare_for_use(dl->command_buffer, dl->state.sets[i].uniform_set_driver_id, dl->state.pipeline_shader_driver_id, i);

- driver->command_bind_render_uniform_set(dl->command_buffer, dl->state.sets[i].uniform_set_driver_id, dl->state.pipeline_shader_driver_id, i);

- driver->command_render_draw_indexed(dl->command_buffer, to_draw, p_instances, dl->validation.index_array_offset, 0, 0);

- driver->command_render_draw(dl->command_buffer, to_draw, p_instances, 0, 0);

- driver->command_render_set_scissor(dl->command_buffer, rect);

- driver->command_render_set_scissor(dl->command_buffer, dl->viewport);

- driver->command_next_render_subpass(frames[frame].draw_command_buffer, RDD::COMMAND_BUFFER_TYPE_PRIMARY);

- _draw_list_allocate(viewport, 0, draw_list_current_subpass);

-Error RenderingDevice::draw_list_switch_to_next_pass_split(uint32_t p_splits, DrawListID *r_split_ids) {

- _THREAD_SAFE_METHOD_

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

-

- driver->command_next_render_subpass(frames[frame].draw_command_buffer, RDD::COMMAND_BUFFER_TYPE_PRIMARY);

-

- _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 RenderingDevice::_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++) {

- RDD::CommandPoolID cmd_pool = driver->command_pool_create(RDD::COMMAND_BUFFER_TYPE_SECONDARY);

- ERR_FAIL_COND_V(!cmd_pool, ERR_CANT_CREATE);

- split_draw_list_allocators.write[i].command_pool = cmd_pool;

-

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

- RDD::CommandBufferID cmd_buffer = driver->command_buffer_create(RDD::COMMAND_BUFFER_TYPE_SECONDARY, cmd_pool);

- ERR_FAIL_COND_V(!cmd_buffer, ERR_CANT_CREATE);

- split_draw_list_allocators.write[i].command_buffers.push_back(cmd_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.

- RDD::CommandBufferID cmd_buffer = split_draw_list_allocators[i].command_buffers[frame];

-

- bool ok = driver->command_buffer_begin_secondary(cmd_buffer, draw_list_render_pass, p_subpass, draw_list_vkframebuffer);

- if (!ok) {

- memdelete_arr(draw_list);

- draw_list = nullptr;

- ERR_FAIL_V(ERR_CANT_CREATE);

- }

-

- draw_list[i].command_buffer = cmd_buffer;

- draw_list[i].viewport = p_viewport;

- }

- }

- if (draw_list_split) {

- // Send all command buffers.

- RDD::CommandBufferID *command_buffers = (RDD::CommandBufferID *)alloca(sizeof(RDD::CommandBufferID) * draw_list_count);

- for (uint32_t i = 0; i < draw_list_count; i++) {

- driver->command_buffer_end(draw_list[i].command_buffer);

- command_buffers[i] = draw_list[i].command_buffer;

- if (r_last_viewport) {

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

- *r_last_viewport = draw_list[i].viewport;

- }

- }

- }

-

- driver->command_buffer_execute_secondary(frames[frame].draw_command_buffer, VectorView(command_buffers, draw_list_count));

- memdelete_arr(draw_list);

- draw_list = nullptr;

-

- } else {

- if (r_last_viewport) {

- *r_last_viewport = draw_list->viewport;

- }

- // Just end the list.

- memdelete(draw_list);

- draw_list = nullptr;

-void RenderingDevice::draw_list_end(BitField<BarrierMask> p_post_barrier) {

- _draw_list_free();

- driver->command_end_render_pass(frames[frame].draw_command_buffer);

- if (draw_list_unbind_color_textures && (texture->usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT)) {

- if (draw_list_unbind_depth_textures && (texture->usage_flags & TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) {

- draw_list_bound_textures.clear();

-

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- BitField<RDD::PipelineStageBits> dst_stages;

- BitField<RDD::BarrierAccessBits> dst_access;

- if (p_post_barrier.has_flag(BARRIER_MASK_COMPUTE)) {

- dst_stages.set_flag(RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT);

- dst_access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_VERTEX)) {

- dst_stages.set_flag(RDD::PIPELINE_STAGE_VERTEX_INPUT_BIT).set_flag(RDD::PIPELINE_STAGE_VERTEX_SHADER_BIT); // RDD::PIPELINE_STAGE_DRAW_INDIRECT_BIT

- dst_access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT).set_flag(RDD::BARRIER_ACCESS_INDEX_READ_BIT).set_flag(RDD::BARRIER_ACCESS_VERTEX_ATTRIBUTE_READ_BIT); // RDD::BARRIER_ACCESS_INDIRECT_COMMAND_READ_BIT

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_FRAGMENT)) {

- dst_stages.set_flag(RDD::PIPELINE_STAGE_FRAGMENT_SHADER_BIT); // RDD::PIPELINE_STAGE_DRAW_INDIRECT_BIT

- dst_access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT); // RDD::BARRIER_ACCESS_INDIRECT_COMMAND_READ_BIT

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_TRANSFER)) {

- dst_stages.set_flag(RDD::PIPELINE_STAGE_TRANSFER_BIT);

- dst_access.set_flag(RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT).set_flag(RDD::BARRIER_ACCESS_TRANSFER_READ_BIT);

- }

-

- if (dst_stages.is_empty()) {

- dst_stages.set_flag(RDD::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT);

- }

-

- RDD::TextureBarrier *texture_barriers = nullptr;

-

- uint32_t texture_barrier_count = draw_list_storage_textures.size();

-

- if (texture_barrier_count) {

- texture_barriers = (RDD::TextureBarrier *)alloca(sizeof(RDD::TextureBarrier) * draw_list_storage_textures.size());

- }

-

- BitField<RDD::PipelineStageBits> src_stage(RDD::PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |

- RDD::PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | RDD::PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT);

- BitField<RDD::BarrierAccessBits> src_access(

- RDD::BARRIER_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | RDD::BARRIER_ACCESS_COLOR_ATTACHMENT_WRITE_BIT);

-

- if (texture_barrier_count) {

- src_stage.set_flag(RDD::PIPELINE_STAGE_VERTEX_SHADER_BIT).set_flag(RDD::PIPELINE_STAGE_FRAGMENT_SHADER_BIT);

- src_access.set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- }

-

- for (uint32_t i = 0; i < texture_barrier_count; i++) {

- Texture *texture = texture_owner.get_or_null(draw_list_storage_textures[i]);

-

- RDD::TextureBarrier &tb = texture_barriers[i];

- tb.texture = texture->driver_id;

- tb.src_access = src_access;

- tb.dst_access = dst_access;

- tb.prev_layout = texture->layout;

- tb.next_layout = RDD::TEXTURE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;

- tb.subresources.aspect = texture->read_aspect_flags;

- tb.subresources.base_mipmap = texture->base_mipmap;

- tb.subresources.mipmap_count = texture->mipmaps;

- tb.subresources.base_layer = texture->base_layer;

- tb.subresources.layer_count = texture->layers;

-

- texture->layout = RDD::TEXTURE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;

- }

-

- // To ensure proper synchronization, we must make sure rendering is done before:

- // * Some buffer is copied.

- // * Another render pass happens (since we may be done).

-

- RDD::MemoryBarrier mb;

- mb.src_access = src_access;

- mb.dst_access = dst_access;

-

- if (texture_barrier_count > 0 || p_post_barrier != BARRIER_MASK_NO_BARRIER) {

- driver->command_pipeline_barrier(frames[frame].draw_command_buffer, src_stage, dst_stages, mb, {}, VectorView(texture_barriers, texture_barrier_count));

- }

- }

- draw_list_storage_textures.clear();

-

-#ifdef FORCE_FULL_BARRIER

- _full_barrier(true);

-#endif

-RenderingDevice::ComputeListID RenderingDevice::compute_list_begin(bool p_allow_draw_overlap) {

- ERR_FAIL_COND_V_MSG(!p_allow_draw_overlap && draw_list != nullptr, INVALID_ID, "Only one draw list can be active at the same time.");

- compute_list->command_buffer = frames[frame].draw_command_buffer;

- compute_list->state.allow_draw_overlap = p_allow_draw_overlap;

- driver->command_bind_compute_pipeline(cl->command_buffer, pipeline->driver_id);

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- uint32_t textures_to_sampled_count = uniform_set->mutable_sampled_textures.size();

- uint32_t textures_to_storage_count = uniform_set->mutable_storage_textures.size();

-

- Texture **textures_to_sampled = uniform_set->mutable_sampled_textures.ptrw();

-

- RDD::TextureBarrier *texture_barriers = nullptr;

-

- if (textures_to_sampled_count + textures_to_storage_count) {

- texture_barriers = (RDD::TextureBarrier *)alloca(sizeof(RDD::TextureBarrier) * (textures_to_sampled_count + textures_to_storage_count));

- }

- uint32_t texture_barrier_count = 0;

-

- BitField<RDD::PipelineStageBits> src_stages;

-

- for (uint32_t i = 0; i < textures_to_sampled_count; i++) {

- if (textures_to_sampled[i]->layout != RDD::TEXTURE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {

- src_stages.set_flag(RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT);

-

- RDD::TextureBarrier &tb = texture_barriers[texture_barrier_count++];

- tb.texture = textures_to_sampled[i]->driver_id;

- tb.src_access = (RDD::BARRIER_ACCESS_SHADER_READ_BIT | RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- tb.dst_access = (RDD::BARRIER_ACCESS_SHADER_READ_BIT | RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- tb.prev_layout = textures_to_sampled[i]->layout;

- tb.next_layout = RDD::TEXTURE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;

- tb.subresources.aspect = textures_to_sampled[i]->read_aspect_flags;

- tb.subresources.base_mipmap = textures_to_sampled[i]->base_mipmap;

- tb.subresources.mipmap_count = textures_to_sampled[i]->mipmaps;

- tb.subresources.base_layer = textures_to_sampled[i]->base_layer;

- tb.subresources.layer_count = textures_to_sampled[i]->layers;

-

- textures_to_sampled[i]->layout = RDD::TEXTURE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;

-

- cl->state.textures_to_sampled_layout.erase(textures_to_sampled[i]);

- }

-

- if (textures_to_sampled[i]->used_in_frame != frames_drawn) {

- textures_to_sampled[i]->used_in_frame = frames_drawn;

- textures_to_sampled[i]->used_in_transfer = false;

- textures_to_sampled[i]->used_in_raster = false;

- }

- textures_to_sampled[i]->used_in_compute = true;

- }

-

- Texture **textures_to_storage = uniform_set->mutable_storage_textures.ptrw();

-

- for (uint32_t i = 0; i < textures_to_storage_count; i++) {

- if (textures_to_storage[i]->layout != RDD::TEXTURE_LAYOUT_GENERAL) {

- BitField<RDD::BarrierAccessBits> src_access;

-

- if (textures_to_storage[i]->used_in_frame == frames_drawn) {

- if (textures_to_storage[i]->used_in_compute) {

- src_stages.set_flag(RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT);

- src_access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- }

- if (textures_to_storage[i]->used_in_raster) {

- src_stages.set_flag(RDD::PIPELINE_STAGE_FRAGMENT_SHADER_BIT).set_flag(RDD::PIPELINE_STAGE_VERTEX_SHADER_BIT);

- src_access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- }

- if (textures_to_storage[i]->used_in_transfer) {

- src_stages.set_flag(RDD::PIPELINE_STAGE_TRANSFER_BIT);

- src_access.set_flag(RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT).set_flag(RDD::BARRIER_ACCESS_TRANSFER_READ_BIT);

- }

-

- textures_to_storage[i]->used_in_compute = false;

- textures_to_storage[i]->used_in_raster = false;

- textures_to_storage[i]->used_in_transfer = false;

-

- } else {

- src_access.clear();

- textures_to_storage[i]->used_in_compute = false;

- textures_to_storage[i]->used_in_raster = false;

- textures_to_storage[i]->used_in_transfer = false;

- textures_to_storage[i]->used_in_frame = frames_drawn;

- }

-

- RDD::TextureBarrier &tb = texture_barriers[texture_barrier_count++];

- tb.texture = textures_to_storage[i]->driver_id;

- tb.src_access = src_access;

- tb.dst_access = (RDD::BARRIER_ACCESS_SHADER_READ_BIT | RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- tb.prev_layout = textures_to_storage[i]->layout;

- tb.next_layout = RDD::TEXTURE_LAYOUT_GENERAL;

- tb.subresources.aspect = textures_to_storage[i]->read_aspect_flags;

- tb.subresources.base_mipmap = textures_to_storage[i]->base_mipmap;

- tb.subresources.mipmap_count = textures_to_storage[i]->mipmaps;

- tb.subresources.base_layer = textures_to_storage[i]->base_layer;

- tb.subresources.layer_count = textures_to_storage[i]->layers;

-

- textures_to_storage[i]->layout = RDD::TEXTURE_LAYOUT_GENERAL;

-

- cl->state.textures_to_sampled_layout.insert(textures_to_storage[i]); // Needs to go back to sampled layout afterwards.

- }

- }

-

- if (texture_barrier_count) {

- if (src_stages.is_empty()) {

- src_stages.set_flag(RDD::PIPELINE_STAGE_TOP_OF_PIPE_BIT);

- }

-

- driver->command_pipeline_barrier(cl->command_buffer, src_stages, RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT, {}, {}, VectorView(texture_barriers, texture_barrier_count));

- }

- }

-

- driver->command_bind_push_constants(cl->command_buffer, cl->state.pipeline_shader_driver_id, 0, VectorView((const uint32_t *)p_data, p_data_size / sizeof(uint32_t)));

- driver->command_uniform_set_prepare_for_use(cl->command_buffer, cl->state.sets[i].uniform_set_driver_id, cl->state.pipeline_shader_driver_id, i);

- driver->command_bind_compute_uniform_set(cl->command_buffer, cl->state.sets[i].uniform_set_driver_id, cl->state.pipeline_shader_driver_id, i);

- driver->command_compute_dispatch(cl->command_buffer, p_x_groups, p_y_groups, p_z_groups);

- driver->command_uniform_set_prepare_for_use(cl->command_buffer, cl->state.sets[i].uniform_set_driver_id, cl->state.pipeline_shader_driver_id, i);

- driver->command_bind_compute_uniform_set(cl->command_buffer, cl->state.sets[i].uniform_set_driver_id, cl->state.pipeline_shader_driver_id, i);

- driver->command_compute_dispatch_indirect(cl->command_buffer, buffer->driver_id, p_offset);

- BitField<RDD::PipelineStageBits> stages(RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT);

- BitField<RDD::BarrierAccessBits> access(RDD::BARRIER_ACCESS_SHADER_READ_BIT);

- _compute_list_add_barrier(BARRIER_MASK_COMPUTE, stages, access);

-}

-

-void RenderingDevice::_compute_list_add_barrier(BitField<BarrierMask> p_post_barrier, BitField<RDD::PipelineStageBits> p_stages, BitField<RDD::BarrierAccessBits> p_access) {

- ERR_FAIL_NULL(compute_list);

-

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- RDD::TextureBarrier *texture_barriers = nullptr;

-

- uint32_t texture_barrier_count = compute_list->state.textures_to_sampled_layout.size();

-

- if (texture_barrier_count) {

- texture_barriers = (RDD::TextureBarrier *)alloca(sizeof(RDD::TextureBarrier) * texture_barrier_count);

- }

-

- texture_barrier_count = 0; // We'll count how many we end up issuing.

-

- for (Texture *E : compute_list->state.textures_to_sampled_layout) {

- if (E->layout != RDD::TEXTURE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {

- RDD::TextureBarrier &tb = texture_barriers[texture_barrier_count++];

- tb.texture = E->driver_id;

- tb.src_access = RDD::BARRIER_ACCESS_SHADER_READ_BIT | RDD::BARRIER_ACCESS_SHADER_WRITE_BIT;

- tb.dst_access = p_access;

- tb.prev_layout = E->layout;

- tb.next_layout = RDD::TEXTURE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;

- tb.subresources.aspect = E->read_aspect_flags;

- tb.subresources.base_mipmap = E->base_mipmap;

- tb.subresources.mipmap_count = E->mipmaps;

- tb.subresources.base_layer = E->base_layer;

- tb.subresources.layer_count = E->layers;

-

- E->layout = RDD::TEXTURE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;

- }

-

- if (E->used_in_frame != frames_drawn) {

- E->used_in_transfer = false;

- E->used_in_raster = false;

- E->used_in_compute = false;

- E->used_in_frame = frames_drawn;

- }

- }

- if (p_stages) {

- RDD::MemoryBarrier mb;

- mb.src_access = RDD::BARRIER_ACCESS_SHADER_WRITE_BIT;

- mb.dst_access = p_access;

- driver->command_pipeline_barrier(compute_list->command_buffer, RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT, p_stages, mb, {}, VectorView(texture_barriers, texture_barrier_count));

- } else if (texture_barrier_count) {

- driver->command_pipeline_barrier(compute_list->command_buffer, RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT, RDD::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, {}, {}, VectorView(texture_barriers, texture_barrier_count));

-#ifdef FORCE_FULL_BARRIER

- _full_barrier(true);

-#endif

-void RenderingDevice::compute_list_end(BitField<BarrierMask> p_post_barrier) {

- BitField<RDD::PipelineStageBits> stages;

- BitField<RDD::BarrierAccessBits> access;

- if (p_post_barrier.has_flag(BARRIER_MASK_COMPUTE)) {

- stages.set_flag(RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT);

- access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_VERTEX)) {

- stages.set_flag(RDD::PIPELINE_STAGE_VERTEX_INPUT_BIT).set_flag(RDD::PIPELINE_STAGE_VERTEX_SHADER_BIT).set_flag(RDD::PIPELINE_STAGE_DRAW_INDIRECT_BIT);

- access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT).set_flag(RDD::BARRIER_ACCESS_INDEX_READ_BIT).set_flag(RDD::BARRIER_ACCESS_VERTEX_ATTRIBUTE_READ_BIT).set_flag(RDD::BARRIER_ACCESS_INDIRECT_COMMAND_READ_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_FRAGMENT)) {

- stages.set_flag(RDD::PIPELINE_STAGE_FRAGMENT_SHADER_BIT).set_flag(RDD::PIPELINE_STAGE_DRAW_INDIRECT_BIT);

- access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT).set_flag(RDD::BARRIER_ACCESS_INDIRECT_COMMAND_READ_BIT);

- }

- if (p_post_barrier.has_flag(BARRIER_MASK_TRANSFER)) {

- stages.set_flag(RDD::PIPELINE_STAGE_TRANSFER_BIT);

- access.set_flag(RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT).set_flag(RDD::BARRIER_ACCESS_TRANSFER_READ_BIT);

- }

- _compute_list_add_barrier(p_post_barrier, stages, access);

- if (!driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- return;

- }

- BitField<RDD::PipelineStageBits> src_stages;

- BitField<RDD::BarrierAccessBits> src_access;

- if (p_from == 0) {

- src_stages.set_flag(RDD::PIPELINE_STAGE_TOP_OF_PIPE_BIT);

- if (p_from.has_flag(BARRIER_MASK_COMPUTE)) {

- src_stages.set_flag(RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT);

- src_access.set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- }

- if (p_from.has_flag(BARRIER_MASK_FRAGMENT)) {

- src_stages.set_flag(RDD::PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT).set_flag(RDD::PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT).set_flag(RDD::PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT);

- src_access.set_flag(RDD::BARRIER_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT).set_flag(RDD::BARRIER_ACCESS_COLOR_ATTACHMENT_WRITE_BIT);

- if (p_from.has_flag(BARRIER_MASK_TRANSFER)) {

- src_stages.set_flag(RDD::PIPELINE_STAGE_TRANSFER_BIT);

- src_access.set_flag(RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT);

- BitField<RDD::PipelineStageBits> dst_stages;

- BitField<RDD::BarrierAccessBits> dst_access;

- if (p_to == 0) {

- dst_stages.set_flag(RDD::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT);

- if (p_to.has_flag(BARRIER_MASK_COMPUTE)) {

- dst_stages.set_flag(RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT);

- dst_access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT);

- }

- if (p_to.has_flag(BARRIER_MASK_VERTEX)) {

- dst_stages.set_flag(RDD::PIPELINE_STAGE_VERTEX_INPUT_BIT).set_flag(RDD::PIPELINE_STAGE_VERTEX_SHADER_BIT).set_flag(RDD::PIPELINE_STAGE_DRAW_INDIRECT_BIT);

- dst_access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT).set_flag(RDD::BARRIER_ACCESS_INDEX_READ_BIT).set_flag(RDD::BARRIER_ACCESS_VERTEX_ATTRIBUTE_READ_BIT).set_flag(RDD::BARRIER_ACCESS_INDIRECT_COMMAND_READ_BIT);

- }

- if (p_to.has_flag(BARRIER_MASK_FRAGMENT)) {

- dst_stages.set_flag(RDD::PIPELINE_STAGE_FRAGMENT_SHADER_BIT).set_flag(RDD::PIPELINE_STAGE_DRAW_INDIRECT_BIT);

- dst_access.set_flag(RDD::BARRIER_ACCESS_SHADER_READ_BIT).set_flag(RDD::BARRIER_ACCESS_SHADER_WRITE_BIT).set_flag(RDD::BARRIER_ACCESS_INDIRECT_COMMAND_READ_BIT);

- }

- if (p_to.has_flag(BARRIER_MASK_TRANSFER)) {

- dst_stages.set_flag(RDD::PIPELINE_STAGE_TRANSFER_BIT);

- dst_access.set_flag(RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT).set_flag(RDD::BARRIER_ACCESS_TRANSFER_READ_BIT);

- }

- RDD::MemoryBarrier mb;

- mb.src_access = src_access;

- mb.dst_access = dst_access;

- driver->command_pipeline_barrier(frames[frame].draw_command_buffer, src_stages, dst_stages, mb, {}, {});

-void RenderingDevice::full_barrier() {

-#ifndef DEBUG_ENABLED

- ERR_PRINT("Full barrier is debug-only, should not be used in production");

-#endif

- _full_barrier(true);

- _THREAD_SAFE_METHOD_

- context->command_begin_label(frames[frame].draw_command_buffer, p_label_name, p_color);

- _THREAD_SAFE_METHOD_

- context->command_insert_label(frames[frame].draw_command_buffer, p_label_name, p_color);

- _THREAD_SAFE_METHOD_

- context->command_end_label(frames[frame].draw_command_buffer);

-void RenderingDevice::_finalize_command_bufers() {

- {

- context->postpare_buffers(frames[frame].draw_command_buffer);

- _finalize_command_bufers();

- _finalize_command_bufers();

- draw_list_split = false;

- // This should be optional for profiling, else it will slow things down.

- if (driver->api_trait_get(RDD::API_TRAIT_HONORS_PIPELINE_BARRIERS)) {

- RDD::MemoryBarrier mb;

- mb.src_access = (RDD::BARRIER_ACCESS_INDIRECT_COMMAND_READ_BIT |

- RDD::BARRIER_ACCESS_INDEX_READ_BIT |

- RDD::BARRIER_ACCESS_VERTEX_ATTRIBUTE_READ_BIT |

- RDD::BARRIER_ACCESS_UNIFORM_READ_BIT |

- RDD::BARRIER_ACCESS_INPUT_ATTACHMENT_READ_BIT |

- RDD::BARRIER_ACCESS_SHADER_READ_BIT |

- RDD::BARRIER_ACCESS_SHADER_WRITE_BIT |

- RDD::BARRIER_ACCESS_COLOR_ATTACHMENT_READ_BIT |

- RDD::BARRIER_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |

- RDD::BARRIER_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |

- RDD::BARRIER_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |

- RDD::BARRIER_ACCESS_TRANSFER_READ_BIT |

- RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT |

- RDD::BARRIER_ACCESS_HOST_READ_BIT |

- RDD::BARRIER_ACCESS_HOST_WRITE_BIT);

- mb.dst_access = (RDD::BARRIER_ACCESS_INDIRECT_COMMAND_READ_BIT |

- RDD::BARRIER_ACCESS_INDEX_READ_BIT |

- RDD::BARRIER_ACCESS_VERTEX_ATTRIBUTE_READ_BIT |

- RDD::BARRIER_ACCESS_UNIFORM_READ_BIT |

- RDD::BARRIER_ACCESS_INPUT_ATTACHMENT_READ_BIT |

- RDD::BARRIER_ACCESS_SHADER_READ_BIT |

- RDD::BARRIER_ACCESS_SHADER_WRITE_BIT |

- RDD::BARRIER_ACCESS_COLOR_ATTACHMENT_READ_BIT |

- RDD::BARRIER_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |

- RDD::BARRIER_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |

- RDD::BARRIER_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |

- RDD::BARRIER_ACCESS_TRANSFER_READ_BIT |

- RDD::BARRIER_ACCESS_TRANSFER_WRITE_BIT |

- RDD::BARRIER_ACCESS_HOST_READ_BIT |

- RDD::BARRIER_ACCESS_HOST_WRITE_BIT);

-

- driver->command_pipeline_barrier(frames[frame].draw_command_buffer, RDD::PIPELINE_STAGE_ALL_COMMANDS_BIT, RDD::PIPELINE_STAGE_ALL_COMMANDS_BIT, mb, {}, {});

- }

-

- driver->command_timestamp_write(frames[frame].draw_command_buffer, frames[frame].timestamp_pool, frames[frame].timestamp_count);

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

- driver->command_pool_free(split_draw_list_allocators[i].command_pool);

- }

-

- ClassDB::bind_method(D_METHOD("texture_update", "texture", "layer", "data", "post_barrier"), &RenderingDevice::texture_update, DEFVAL(BARRIER_MASK_ALL_BARRIERS));

- ClassDB::bind_method(D_METHOD("texture_copy", "from_texture", "to_texture", "from_pos", "to_pos", "size", "src_mipmap", "dst_mipmap", "src_layer", "dst_layer", "post_barrier"), &RenderingDevice::texture_copy, DEFVAL(BARRIER_MASK_ALL_BARRIERS));

- ClassDB::bind_method(D_METHOD("texture_clear", "texture", "color", "base_mipmap", "mipmap_count", "base_layer", "layer_count", "post_barrier"), &RenderingDevice::texture_clear, DEFVAL(BARRIER_MASK_ALL_BARRIERS));

- ClassDB::bind_method(D_METHOD("texture_resolve_multisample", "from_texture", "to_texture", "post_barrier"), &RenderingDevice::texture_resolve_multisample, DEFVAL(BARRIER_MASK_ALL_BARRIERS));

- ClassDB::bind_method(D_METHOD("buffer_update", "buffer", "offset", "size_bytes", "data", "post_barrier"), &RenderingDevice::_buffer_update_bind, DEFVAL(BARRIER_MASK_ALL_BARRIERS));

- ClassDB::bind_method(D_METHOD("buffer_clear", "buffer", "offset", "size_bytes", "post_barrier"), &RenderingDevice::buffer_clear, DEFVAL(BARRIER_MASK_ALL_BARRIERS));

- ClassDB::bind_method(D_METHOD("draw_list_begin", "framebuffer", "initial_color_action", "final_color_action", "initial_depth_action", "final_depth_action", "clear_color_values", "clear_depth", "clear_stencil", "region", "storage_textures"), &RenderingDevice::_draw_list_begin, DEFVAL(Vector<Color>()), DEFVAL(1.0), DEFVAL(0), DEFVAL(Rect2()), DEFVAL(TypedArray<RID>()));

- ClassDB::bind_method(D_METHOD("draw_list_end", "post_barrier"), &RenderingDevice::draw_list_end, DEFVAL(BARRIER_MASK_ALL_BARRIERS));

- ClassDB::bind_method(D_METHOD("compute_list_begin", "allow_draw_overlap"), &RenderingDevice::compute_list_begin, DEFVAL(false));

- ClassDB::bind_method(D_METHOD("compute_list_end", "post_barrier"), &RenderingDevice::compute_list_end, DEFVAL(BARRIER_MASK_ALL_BARRIERS));

- BIND_ENUM_CONSTANT(INITIAL_ACTION_CLEAR); //start rendering and clear the framebuffer (supply params)

- BIND_ENUM_CONSTANT(INITIAL_ACTION_CLEAR_REGION); //start rendering and clear the framebuffer (supply params)

- BIND_ENUM_CONSTANT(INITIAL_ACTION_CLEAR_REGION_CONTINUE); //continue rendering and clear the framebuffer (supply params)

- BIND_ENUM_CONSTANT(INITIAL_ACTION_KEEP); //start rendering); but keep attached color texture contents (depth will be cleared)

- BIND_ENUM_CONSTANT(INITIAL_ACTION_DROP); //start rendering); ignore what is there); just write above it

- BIND_ENUM_CONSTANT(INITIAL_ACTION_CONTINUE); //continue rendering (framebuffer must have been left in "continue" state as final action previously)

- BIND_ENUM_CONSTANT(FINAL_ACTION_READ); //will no longer render to it); allows attached textures to be read again); but depth buffer contents will be dropped (Can't be read from)

- BIND_ENUM_CONSTANT(FINAL_ACTION_DISCARD); // discard contents after rendering

- BIND_ENUM_CONSTANT(FINAL_ACTION_CONTINUE); //will continue rendering later); attached textures can't be read until re-bound with "finish"

-Error RenderingDevice::_buffer_update_bind(RID p_buffer, uint32_t p_offset, uint32_t p_size, const Vector<uint8_t> &p_data, BitField<BarrierMask> p_post_barrier) {

- return buffer_update(p_buffer, p_offset, p_size, p_data.ptr(), p_post_barrier);

-RenderingDevice::DrawListID RenderingDevice::_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 TypedArray<RID> &p_storage_textures) {

- Vector<RID> stextures;

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

- stextures.push_back(p_storage_textures[i]);

- }

- return draw_list_begin(p_framebuffer, p_initial_color_action, p_final_color_action, p_initial_depth_action, p_final_depth_action, p_clear_color_values, p_clear_depth, p_clear_stencil, p_region, stextures);

-}

-

- Vector<DrawListID> splits;

- splits.resize(p_splits);

- Vector<RID> stextures;

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

- stextures.push_back(p_storage_textures[i]);

- }

- draw_list_begin_split(p_framebuffer, p_splits, splits.ptrw(), p_initial_color_action, p_final_color_action, p_initial_depth_action, p_final_depth_action, p_clear_color_values, p_clear_depth, p_clear_stencil, p_region, stextures);

-

- Vector<int64_t> split_ids;

- split_ids.resize(splits.size());

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

- split_ids.write[i] = splits[i];

- }

-

- return split_ids;

- Vector<DrawListID> splits;

- splits.resize(p_splits);

-

- Error err = draw_list_switch_to_next_pass_split(p_splits, splits.ptrw());

- ERR_FAIL_COND_V(err != OK, Vector<int64_t>());

-

- Vector<int64_t> split_ids;

- split_ids.resize(splits.size());

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

- split_ids.write[i] = splits[i];

- }

-

- return split_ids;