godotengine/godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
39f279710c
godot/servers/rendering/rendering_device_graph.h

674 lines
25 KiB
C++
Raw Blame History

/**************************************************************************/
/* rendering_device_graph.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#ifndef RENDERING_DEVICE_GRAPH_H
#define RENDERING_DEVICE_GRAPH_H
#include "core/object/worker_thread_pool.h"
#include "rendering_device_commons.h"
#include "rendering_device_driver.h"
// Buffer barriers have not shown any significant improvement or shown to be
// even detrimental to performance. However, there are currently some known
// cases where using them can solve problems that using singular memory
// barriers does not, probably due to driver issues (see comment on PR #84976
// https://github.com/godotengine/godot/pull/84976#issuecomment-1878566830).
#define USE_BUFFER_BARRIERS 1
class RenderingDeviceGraph {
public:
struct ComputeListInstruction {
enum Type {
TYPE_NONE,
TYPE_BIND_PIPELINE,
TYPE_BIND_UNIFORM_SET,
TYPE_DISPATCH,
TYPE_DISPATCH_INDIRECT,
TYPE_SET_PUSH_CONSTANT,
TYPE_UNIFORM_SET_PREPARE_FOR_USE
};
Type type = TYPE_NONE;
};
struct DrawListInstruction {
enum Type {
TYPE_NONE,
TYPE_BIND_INDEX_BUFFER,
TYPE_BIND_PIPELINE,
TYPE_BIND_UNIFORM_SET,
TYPE_BIND_VERTEX_BUFFERS,
TYPE_CLEAR_ATTACHMENTS,
TYPE_DRAW,
TYPE_DRAW_INDEXED,
TYPE_EXECUTE_COMMANDS,
TYPE_NEXT_SUBPASS,
TYPE_SET_BLEND_CONSTANTS,
TYPE_SET_LINE_WIDTH,
TYPE_SET_PUSH_CONSTANT,
TYPE_SET_SCISSOR,
TYPE_SET_VIEWPORT,
TYPE_UNIFORM_SET_PREPARE_FOR_USE
};
Type type = TYPE_NONE;
};
struct RecordedCommand {
enum Type {
TYPE_NONE,
TYPE_BUFFER_CLEAR,
TYPE_BUFFER_COPY,
TYPE_BUFFER_GET_DATA,
TYPE_BUFFER_UPDATE,
TYPE_COMPUTE_LIST,
TYPE_DRAW_LIST,
TYPE_TEXTURE_CLEAR,
TYPE_TEXTURE_COPY,
TYPE_TEXTURE_GET_DATA,
TYPE_TEXTURE_RESOLVE,
TYPE_TEXTURE_UPDATE,
TYPE_CAPTURE_TIMESTAMP,
TYPE_MAX
};
Type type = TYPE_NONE;
int32_t adjacent_command_list_index = -1;
RDD::MemoryBarrier memory_barrier;
int32_t normalization_barrier_index = -1;
int normalization_barrier_count = 0;
int32_t transition_barrier_index = -1;
int32_t transition_barrier_count = 0;
#if USE_BUFFER_BARRIERS
int32_t buffer_barrier_index = -1;
int32_t buffer_barrier_count = 0;
#endif
int32_t label_index = -1;
BitField<RDD::PipelineStageBits> previous_stages;
BitField<RDD::PipelineStageBits> next_stages;
BitField<RDD::PipelineStageBits> self_stages;
};
struct RecordedBufferCopy {
RDD::BufferID source;
RDD::BufferCopyRegion region;
};
struct RecordedBufferToTextureCopy {
RDD::BufferID from_buffer;
RDD::BufferTextureCopyRegion region;
};
enum ResourceUsage {
RESOURCE_USAGE_NONE,
RESOURCE_USAGE_TRANSFER_FROM,
RESOURCE_USAGE_TRANSFER_TO,
RESOURCE_USAGE_UNIFORM_BUFFER_READ,
RESOURCE_USAGE_INDIRECT_BUFFER_READ,
RESOURCE_USAGE_TEXTURE_BUFFER_READ,
RESOURCE_USAGE_TEXTURE_BUFFER_READ_WRITE,
RESOURCE_USAGE_STORAGE_BUFFER_READ,
RESOURCE_USAGE_STORAGE_BUFFER_READ_WRITE,
RESOURCE_USAGE_VERTEX_BUFFER_READ,
RESOURCE_USAGE_INDEX_BUFFER_READ,
RESOURCE_USAGE_TEXTURE_SAMPLE,
RESOURCE_USAGE_STORAGE_IMAGE_READ,
RESOURCE_USAGE_STORAGE_IMAGE_READ_WRITE,
RESOURCE_USAGE_ATTACHMENT_COLOR_READ,
RESOURCE_USAGE_ATTACHMENT_COLOR_READ_WRITE,
RESOURCE_USAGE_ATTACHMENT_DEPTH_STENCIL_READ,
RESOURCE_USAGE_ATTACHMENT_DEPTH_STENCIL_READ_WRITE
};
struct ResourceTracker {
uint32_t reference_count = 0;
int64_t command_frame = -1;
int32_t read_full_command_list_index = -1;
int32_t read_slice_command_list_index = -1;
int32_t write_command_or_list_index = -1;
int32_t draw_list_index = -1;
int32_t compute_list_index = -1;
ResourceUsage usage = RESOURCE_USAGE_NONE;
BitField<RDD::BarrierAccessBits> usage_access;
RDD::BufferID buffer_driver_id;
RDD::TextureID texture_driver_id;
RDD::TextureSubresourceRange texture_subresources;
int32_t texture_slice_command_index = -1;
ResourceTracker *parent = nullptr;
ResourceTracker *dirty_shared_list = nullptr;
ResourceTracker *next_shared = nullptr;
Rect2i texture_slice_or_dirty_rect;
bool in_parent_dirty_list = false;
bool write_command_list_enabled = false;
_FORCE_INLINE_ void reset_if_outdated(int64_t new_command_frame) {
if (new_command_frame != command_frame) {
usage_access.clear();
command_frame = new_command_frame;
read_full_command_list_index = -1;
read_slice_command_list_index = -1;
write_command_or_list_index = -1;
draw_list_index = -1;
compute_list_index = -1;
texture_slice_command_index = -1;
write_command_list_enabled = false;
}
}
};
private:
struct InstructionList {
LocalVector<uint8_t> data;
LocalVector<ResourceTracker *> command_trackers;
LocalVector<ResourceUsage> command_tracker_usages;
BitField<RDD::PipelineStageBits> stages;
int32_t index = 0;
void clear() {
data.clear();
command_trackers.clear();
command_tracker_usages.clear();
stages.clear();
}
};
struct ComputeInstructionList : InstructionList {
// No extra contents.
};
struct DrawInstructionList : InstructionList {
RDD::RenderPassID render_pass;
RDD::FramebufferID framebuffer;
Rect2i region;
LocalVector<RDD::RenderPassClearValue> clear_values;
};
struct RecordedCommandSort {
uint32_t level = 0;
uint32_t priority = 0;
int32_t index = -1;
RecordedCommandSort() = default;
bool operator<(const RecordedCommandSort &p_other) const {
if (level < p_other.level) {
return true;
} else if (level > p_other.level) {
return false;
}
if (priority < p_other.priority) {
return true;
} else if (priority > p_other.priority) {
return false;
}
return index < p_other.index;
}
};
struct RecordedCommandListNode {
int32_t command_index = -1;
int32_t next_list_index = -1;
};
struct RecordedSliceListNode {
int32_t command_index = -1;
int32_t next_list_index = -1;
Rect2i subresources;
};
struct RecordedBufferClearCommand : RecordedCommand {
RDD::BufferID buffer;
uint32_t offset = 0;
uint32_t size = 0;
};
struct RecordedBufferCopyCommand : RecordedCommand {
RDD::BufferID source;
RDD::BufferID destination;
RDD::BufferCopyRegion region;
};
struct RecordedBufferGetDataCommand : RecordedCommand {
RDD::BufferID source;
RDD::BufferID destination;
RDD::BufferCopyRegion region;
};
struct RecordedBufferUpdateCommand : RecordedCommand {
RDD::BufferID destination;
uint32_t buffer_copies_count = 0;
_FORCE_INLINE_ RecordedBufferCopy *buffer_copies() {
return reinterpret_cast<RecordedBufferCopy *>(&this[1]);
}
_FORCE_INLINE_ const RecordedBufferCopy *buffer_copies() const {
return reinterpret_cast<const RecordedBufferCopy *>(&this[1]);
}
};
struct RecordedComputeListCommand : RecordedCommand {
uint32_t instruction_data_size = 0;
_FORCE_INLINE_ uint8_t *instruction_data() {
return reinterpret_cast<uint8_t *>(&this[1]);
}
_FORCE_INLINE_ const uint8_t *instruction_data() const {
return reinterpret_cast<const uint8_t *>(&this[1]);
}
};
struct RecordedDrawListCommand : RecordedCommand {
uint32_t instruction_data_size = 0;
RDD::RenderPassID render_pass;
RDD::FramebufferID framebuffer;
RDD::CommandBufferType command_buffer_type;
Rect2i region;
uint32_t clear_values_count = 0;
_FORCE_INLINE_ RDD::RenderPassClearValue *clear_values() {
return reinterpret_cast<RDD::RenderPassClearValue *>(&this[1]);
}
_FORCE_INLINE_ const RDD::RenderPassClearValue *clear_values() const {
return reinterpret_cast<const RDD::RenderPassClearValue *>(&this[1]);
}
_FORCE_INLINE_ uint8_t *instruction_data() {
return reinterpret_cast<uint8_t *>(&clear_values()[clear_values_count]);
}
_FORCE_INLINE_ const uint8_t *instruction_data() const {
return reinterpret_cast<const uint8_t *>(&clear_values()[clear_values_count]);
}
};
struct RecordedTextureClearCommand : RecordedCommand {
RDD::TextureID texture;
RDD::TextureSubresourceRange range;
Color color;
};
struct RecordedTextureCopyCommand : RecordedCommand {
RDD::TextureID from_texture;
RDD::TextureID to_texture;
RDD::TextureCopyRegion region;
};
struct RecordedTextureGetDataCommand : RecordedCommand {
RDD::TextureID from_texture;
RDD::BufferID to_buffer;
uint32_t buffer_texture_copy_regions_count = 0;
_FORCE_INLINE_ RDD::BufferTextureCopyRegion *buffer_texture_copy_regions() {
return reinterpret_cast<RDD::BufferTextureCopyRegion *>(&this[1]);
}
_FORCE_INLINE_ const RDD::BufferTextureCopyRegion *buffer_texture_copy_regions() const {
return reinterpret_cast<const RDD::BufferTextureCopyRegion *>(&this[1]);
}
};
struct RecordedTextureResolveCommand : RecordedCommand {
RDD::TextureID from_texture;
RDD::TextureID to_texture;
uint32_t src_layer = 0;
uint32_t src_mipmap = 0;
uint32_t dst_layer = 0;
uint32_t dst_mipmap = 0;
};
struct RecordedTextureUpdateCommand : RecordedCommand {
RDD::TextureID to_texture;
uint32_t buffer_to_texture_copies_count = 0;
_FORCE_INLINE_ RecordedBufferToTextureCopy *buffer_to_texture_copies() {
return reinterpret_cast<RecordedBufferToTextureCopy *>(&this[1]);
}
_FORCE_INLINE_ const RecordedBufferToTextureCopy *buffer_to_texture_copies() const {
return reinterpret_cast<const RecordedBufferToTextureCopy *>(&this[1]);
}
};
struct RecordedCaptureTimestampCommand : RecordedCommand {
RDD::QueryPoolID pool;
uint32_t index = 0;
};
struct DrawListBindIndexBufferInstruction : DrawListInstruction {
RDD::BufferID buffer;
RenderingDeviceCommons::IndexBufferFormat format;
uint32_t offset = 0;
};
struct DrawListBindPipelineInstruction : DrawListInstruction {
RDD::PipelineID pipeline;
};
struct DrawListBindUniformSetInstruction : DrawListInstruction {
RDD::UniformSetID uniform_set;
RDD::ShaderID shader;
uint32_t set_index = 0;
};
struct DrawListBindVertexBuffersInstruction : DrawListInstruction {
uint32_t vertex_buffers_count = 0;
_FORCE_INLINE_ RDD::BufferID *vertex_buffers() {
return reinterpret_cast<RDD::BufferID *>(&this[1]);
}
_FORCE_INLINE_ const RDD::BufferID *vertex_buffers() const {
return reinterpret_cast<const RDD::BufferID *>(&this[1]);
}
_FORCE_INLINE_ uint64_t *vertex_buffer_offsets() {
return reinterpret_cast<uint64_t *>(&vertex_buffers()[vertex_buffers_count]);
}
_FORCE_INLINE_ const uint64_t *vertex_buffer_offsets() const {
return reinterpret_cast<const uint64_t *>(&vertex_buffers()[vertex_buffers_count]);
}
};
struct DrawListClearAttachmentsInstruction : DrawListInstruction {
uint32_t attachments_clear_count = 0;
uint32_t attachments_clear_rect_count = 0;
_FORCE_INLINE_ RDD::AttachmentClear *attachments_clear() {
return reinterpret_cast<RDD::AttachmentClear *>(&this[1]);
}
_FORCE_INLINE_ const RDD::AttachmentClear *attachments_clear() const {
return reinterpret_cast<const RDD::AttachmentClear *>(&this[1]);
}
_FORCE_INLINE_ Rect2i *attachments_clear_rect() {
return reinterpret_cast<Rect2i *>(&attachments_clear()[attachments_clear_count]);
}
_FORCE_INLINE_ const Rect2i *attachments_clear_rect() const {
return reinterpret_cast<const Rect2i *>(&attachments_clear()[attachments_clear_count]);
}
};
struct DrawListDrawInstruction : DrawListInstruction {
uint32_t vertex_count = 0;
uint32_t instance_count = 0;
};
struct DrawListDrawIndexedInstruction : DrawListInstruction {
uint32_t index_count = 0;
uint32_t instance_count = 0;
uint32_t first_index = 0;
};
struct DrawListEndRenderPassInstruction : DrawListInstruction {
// No contents.
};
struct DrawListExecuteCommandsInstruction : DrawListInstruction {
RDD::CommandBufferID command_buffer;
};
struct DrawListSetPushConstantInstruction : DrawListInstruction {
uint32_t size = 0;
RDD::ShaderID shader;
_FORCE_INLINE_ uint8_t *data() {
return reinterpret_cast<uint8_t *>(&this[1]);
}
_FORCE_INLINE_ const uint8_t *data() const {
return reinterpret_cast<const uint8_t *>(&this[1]);
}
};
struct DrawListNextSubpassInstruction : DrawListInstruction {
RDD::CommandBufferType command_buffer_type;
};
struct DrawListSetBlendConstantsInstruction : DrawListInstruction {
Color color;
};
struct DrawListSetLineWidthInstruction : DrawListInstruction {
float width;
};
struct DrawListSetScissorInstruction : DrawListInstruction {
Rect2i rect;
};
struct DrawListSetViewportInstruction : DrawListInstruction {
Rect2i rect;
};
struct DrawListUniformSetPrepareForUseInstruction : DrawListInstruction {
RDD::UniformSetID uniform_set;
RDD::ShaderID shader;
uint32_t set_index = 0;
};
struct ComputeListBindPipelineInstruction : ComputeListInstruction {
RDD::PipelineID pipeline;
};
struct ComputeListBindUniformSetInstruction : ComputeListInstruction {
RDD::UniformSetID uniform_set;
RDD::ShaderID shader;
uint32_t set_index = 0;
};
struct ComputeListDispatchInstruction : ComputeListInstruction {
uint32_t x_groups = 0;
uint32_t y_groups = 0;
uint32_t z_groups = 0;
};
struct ComputeListDispatchIndirectInstruction : ComputeListInstruction {
RDD::BufferID buffer;
uint32_t offset = 0;
};
struct ComputeListSetPushConstantInstruction : ComputeListInstruction {
uint32_t size = 0;
RDD::ShaderID shader;
_FORCE_INLINE_ uint8_t *data() {
return reinterpret_cast<uint8_t *>(&this[1]);
}
_FORCE_INLINE_ const uint8_t *data() const {
return reinterpret_cast<const uint8_t *>(&this[1]);
}
};
struct ComputeListUniformSetPrepareForUseInstruction : ComputeListInstruction {
RDD::UniformSetID uniform_set;
RDD::ShaderID shader;
uint32_t set_index = 0;
};
struct BarrierGroup {
BitField<RDD::PipelineStageBits> src_stages;
BitField<RDD::PipelineStageBits> dst_stages;
RDD::MemoryBarrier memory_barrier;
LocalVector<RDD::TextureBarrier> normalization_barriers;
LocalVector<RDD::TextureBarrier> transition_barriers;
#if USE_BUFFER_BARRIERS
LocalVector<RDD::BufferBarrier> buffer_barriers;
#endif
void clear() {
src_stages.clear();
dst_stages.clear();
memory_barrier.src_access.clear();
memory_barrier.dst_access.clear();
normalization_barriers.clear();
transition_barriers.clear();
#if USE_BUFFER_BARRIERS
buffer_barriers.clear();
#endif
}
};
struct SecondaryCommandBuffer {
LocalVector<uint8_t> instruction_data;
RDD::CommandBufferID command_buffer;
RDD::CommandPoolID command_pool;
RDD::RenderPassID render_pass;
RDD::FramebufferID framebuffer;
WorkerThreadPool::TaskID task;
};
struct Frame {
TightLocalVector<SecondaryCommandBuffer> secondary_command_buffers;
uint32_t secondary_command_buffers_used = 0;
};
RDD *driver = nullptr;
int64_t tracking_frame = 0;
LocalVector<uint8_t> command_data;
LocalVector<uint32_t> command_data_offsets;
LocalVector<RDD::TextureBarrier> command_normalization_barriers;
LocalVector<RDD::TextureBarrier> command_transition_barriers;
LocalVector<RDD::BufferBarrier> command_buffer_barriers;
LocalVector<char> command_label_chars;
LocalVector<Color> command_label_colors;
LocalVector<uint32_t> command_label_offsets;
int32_t command_label_index = -1;
DrawInstructionList draw_instruction_list;
ComputeInstructionList compute_instruction_list;
uint32_t command_count = 0;
uint32_t command_label_count = 0;
LocalVector<RecordedCommandListNode> command_list_nodes;
LocalVector<RecordedSliceListNode> read_slice_list_nodes;
LocalVector<RecordedSliceListNode> write_slice_list_nodes;
int32_t command_timestamp_index = -1;
int32_t command_synchronization_index = -1;
bool command_synchronization_pending = false;
BarrierGroup barrier_group;
bool driver_honors_barriers = false;
TightLocalVector<Frame> frames;
uint32_t frame = 0;
#ifdef DEV_ENABLED
RBMap<ResourceTracker *, uint32_t> write_dependency_counters;
#endif
static bool _is_write_usage(ResourceUsage p_usage);
static RDD::TextureLayout _usage_to_image_layout(ResourceUsage p_usage);
static RDD::BarrierAccessBits _usage_to_access_bits(ResourceUsage p_usage);
int32_t _add_to_command_list(int32_t p_command_index, int32_t p_list_index);
void _add_adjacent_command(int32_t p_previous_command_index, int32_t p_command_index, RecordedCommand *r_command);
int32_t _add_to_slice_read_list(int32_t p_command_index, Rect2i p_subresources, int32_t p_list_index);
int32_t _add_to_write_list(int32_t p_command_index, Rect2i p_subresources, int32_t p_list_index);
RecordedCommand *_allocate_command(uint32_t p_command_size, int32_t &r_command_index);
DrawListInstruction *_allocate_draw_list_instruction(uint32_t p_instruction_size);
ComputeListInstruction *_allocate_compute_list_instruction(uint32_t p_instruction_size);
void _add_command_to_graph(ResourceTracker **p_resource_trackers, ResourceUsage *p_resource_usages, uint32_t p_resource_count, int32_t p_command_index, RecordedCommand *r_command);
void _add_texture_barrier_to_command(RDD::TextureID p_texture_id, BitField<RDD::BarrierAccessBits> p_src_access, BitField<RDD::BarrierAccessBits> p_dst_access, ResourceUsage p_prev_usage, ResourceUsage p_next_usage, RDD::TextureSubresourceRange p_subresources, LocalVector<RDD::TextureBarrier> &r_barrier_vector, int32_t &r_barrier_index, int32_t &r_barrier_count);
#if USE_BUFFER_BARRIERS
void _add_buffer_barrier_to_command(RDD::BufferID p_buffer_id, BitField<RDD::BarrierAccessBits> p_src_access, BitField<RDD::BarrierAccessBits> p_dst_access, int32_t &r_barrier_index, int32_t &r_barrier_count);
#endif
void _run_compute_list_command(RDD::CommandBufferID p_command_buffer, const uint8_t *p_instruction_data, uint32_t p_instruction_data_size);
void _run_draw_list_command(RDD::CommandBufferID p_command_buffer, const uint8_t *p_instruction_data, uint32_t p_instruction_data_size);
void _run_secondary_command_buffer_task(const SecondaryCommandBuffer *p_secondary);
void _wait_for_secondary_command_buffer_tasks();
void _run_render_commands(RDD::CommandBufferID p_command_buffer, int32_t p_level, const RecordedCommandSort *p_sorted_commands, uint32_t p_sorted_commands_count, int32_t &r_current_label_index, int32_t &r_current_label_level);
void _run_label_command_change(RDD::CommandBufferID p_command_buffer, int32_t p_new_label_index, int32_t p_new_level, bool p_ignore_previous_value, bool p_use_label_for_empty, const RecordedCommandSort *p_sorted_commands, uint32_t p_sorted_commands_count, int32_t &r_current_label_index, int32_t &r_current_label_level);
void _boost_priority_for_render_commands(RecordedCommandSort *p_sorted_commands, uint32_t p_sorted_commands_count, uint32_t &r_boosted_priority);
void _group_barriers_for_render_commands(RDD::CommandBufferID p_command_buffer, const RecordedCommandSort *p_sorted_commands, uint32_t p_sorted_commands_count, bool p_full_memory_barrier);
void _print_render_commands(const RecordedCommandSort *p_sorted_commands, uint32_t p_sorted_commands_count);
void _print_draw_list(const uint8_t *p_instruction_data, uint32_t p_instruction_data_size);
void _print_compute_list(const uint8_t *p_instruction_data, uint32_t p_instruction_data_size);
public:
RenderingDeviceGraph();
~RenderingDeviceGraph();
void initialize(RDD *p_driver, uint32_t p_frame_count, uint32_t p_secondary_command_buffers_per_frame);
void begin();
void add_buffer_clear(RDD::BufferID p_dst, ResourceTracker *p_dst_tracker, uint32_t p_offset, uint32_t p_size);
void add_buffer_copy(RDD::BufferID p_src, ResourceTracker *p_src_tracker, RDD::BufferID p_dst, ResourceTracker *p_dst_tracker, RDD::BufferCopyRegion p_region);
void add_buffer_get_data(RDD::BufferID p_src, ResourceTracker *p_src_tracker, RDD::BufferID p_dst, RDD::BufferCopyRegion p_region);
void add_buffer_update(RDD::BufferID p_dst, ResourceTracker *p_dst_tracker, VectorView<RecordedBufferCopy> p_buffer_copies);
void add_compute_list_begin();
void add_compute_list_bind_pipeline(RDD::PipelineID p_pipeline);
void add_compute_list_bind_uniform_set(RDD::ShaderID p_shader, RDD::UniformSetID p_uniform_set, uint32_t set_index);
void add_compute_list_dispatch(uint32_t p_x_groups, uint32_t p_y_groups, uint32_t p_z_groups);
void add_compute_list_dispatch_indirect(RDD::BufferID p_buffer, uint32_t p_offset);
void add_compute_list_set_push_constant(RDD::ShaderID p_shader, const void *p_data, uint32_t p_data_size);
void add_compute_list_uniform_set_prepare_for_use(RDD::ShaderID p_shader, RDD::UniformSetID p_uniform_set, uint32_t set_index);
void add_compute_list_usage(ResourceTracker *p_tracker, ResourceUsage p_usage);
void add_compute_list_usages(VectorView<ResourceTracker *> p_trackers, VectorView<ResourceUsage> p_usages);
void add_compute_list_end();
void add_draw_list_begin(RDD::RenderPassID p_render_pass, RDD::FramebufferID p_framebuffer, Rect2i p_region, VectorView<RDD::RenderPassClearValue> p_clear_values, bool p_uses_color, bool p_uses_depth);
void add_draw_list_bind_index_buffer(RDD::BufferID p_buffer, RDD::IndexBufferFormat p_format, uint32_t p_offset);
void add_draw_list_bind_pipeline(RDD::PipelineID p_pipeline, BitField<RDD::PipelineStageBits> p_pipeline_stage_bits);
void add_draw_list_bind_uniform_set(RDD::ShaderID p_shader, RDD::UniformSetID p_uniform_set, uint32_t set_index);
void add_draw_list_bind_vertex_buffers(VectorView<RDD::BufferID> p_vertex_buffers, VectorView<uint64_t> p_vertex_buffer_offsets);
void add_draw_list_clear_attachments(VectorView<RDD::AttachmentClear> p_attachments_clear, VectorView<Rect2i> p_attachments_clear_rect);
void add_draw_list_draw(uint32_t p_vertex_count, uint32_t p_instance_count);
void add_draw_list_draw_indexed(uint32_t p_index_count, uint32_t p_instance_count, uint32_t p_first_index);
void add_draw_list_execute_commands(RDD::CommandBufferID p_command_buffer);
void add_draw_list_next_subpass(RDD::CommandBufferType p_command_buffer_type);
void add_draw_list_set_blend_constants(const Color &p_color);
void add_draw_list_set_line_width(float p_width);
void add_draw_list_set_push_constant(RDD::ShaderID p_shader, const void *p_data, uint32_t p_data_size);
void add_draw_list_set_scissor(Rect2i p_rect);
void add_draw_list_set_viewport(Rect2i p_rect);
void add_draw_list_uniform_set_prepare_for_use(RDD::ShaderID p_shader, RDD::UniformSetID p_uniform_set, uint32_t set_index);
void add_draw_list_usage(ResourceTracker *p_tracker, ResourceUsage p_usage);
void add_draw_list_usages(VectorView<ResourceTracker *> p_trackers, VectorView<ResourceUsage> p_usages);
void add_draw_list_end();
void add_texture_clear(RDD::TextureID p_dst, ResourceTracker *p_dst_tracker, const Color &p_color, const RDD::TextureSubresourceRange &p_range);
void add_texture_copy(RDD::TextureID p_src, ResourceTracker *p_src_tracker, RDD::TextureID p_dst, ResourceTracker *p_dst_tracker, RDD::TextureCopyRegion p_region);
void add_texture_get_data(RDD::TextureID p_src, ResourceTracker *p_src_tracker, RDD::BufferID p_dst, VectorView<RDD::BufferTextureCopyRegion> p_buffer_texture_copy_regions);
void add_texture_resolve(RDD::TextureID p_src, ResourceTracker *p_src_tracker, RDD::TextureID p_dst, ResourceTracker *p_dst_tracker, uint32_t p_src_layer, uint32_t p_src_mipmap, uint32_t p_dst_layer, uint32_t p_dst_mipmap);
void add_texture_update(RDD::TextureID p_dst, ResourceTracker *p_dst_tracker, VectorView<RecordedBufferToTextureCopy> p_buffer_copies);
void add_capture_timestamp(RDD::QueryPoolID p_query_pool, uint32_t p_index);
void add_synchronization();
void begin_label(const String &p_label_name, const Color &p_color);
void end_label();
void end(RDD::CommandBufferID p_command_buffer, bool p_reorder_commands, bool p_full_barriers);
static ResourceTracker *resource_tracker_create();
static void resource_tracker_free(ResourceTracker *tracker);
};
using RDG = RenderingDeviceGraph;
#endif // RENDERING_DEVICE_GRAPH_H
Reference in New Issue View Git Blame Copy Permalink