godot/servers/rendering/rendering_device.cpp

/**************************************************************************/
/*  rendering_device.cpp                                                  */
/**************************************************************************/
/*                         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.                 */
/**************************************************************************/

#include "rendering_device.h"
#include "rendering_device.compat.inc"

#include "rendering_device_binds.h"

#include "core/config/project_settings.h"
#include "core/io/dir_access.h"

// TODO: Thread safety
// - Roll back thread safe attribute for RID_Owner members after the read-only/atomic update scheme is implemented.

#define FORCE_SEPARATE_PRESENT_QUEUE …
#define PRINT_FRAMEBUFFER_FORMAT …

#define ERR_RENDER_THREAD_MSG …
#define ERR_RENDER_THREAD_GUARD() …
#define ERR_RENDER_THREAD_GUARD_V(m_ret) …

/**************************/
/**** HELPER FUNCTIONS ****/
/**************************/

static String _get_device_vendor_name(const RenderingContextDriver::Device &p_device) { … }

static String _get_device_type_name(const RenderingContextDriver::Device &p_device) { … }

static uint32_t _get_device_type_score(const RenderingContextDriver::Device &p_device) { … }

/**************************/
/**** RENDERING DEVICE ****/
/**************************/

// When true, the command graph will attempt to reorder the rendering commands submitted by the user based on the dependencies detected from
// the commands automatically. This should improve rendering performance in most scenarios at the cost of some extra CPU overhead.
//
// This behavior can be disabled if it's suspected that the graph is not detecting dependencies correctly and more control over the order of
// the commands is desired (e.g. debugging).

#define RENDER_GRAPH_REORDER …

// Synchronization barriers are issued between the graph's levels only with the necessary amount of detail to achieve the correct result. If
// it's suspected that the graph is not doing this correctly, full barriers can be issued instead that will block all types of operations
// between the synchronization levels. This setting will have a very negative impact on performance when enabled, so it's only intended for
// debugging purposes.

#define RENDER_GRAPH_FULL_BARRIERS …

// The command graph can automatically issue secondary command buffers and record them on background threads when they reach an arbitrary
// size threshold. This can be very beneficial towards reducing the time the main thread takes to record all the rendering commands. However,
// this setting is not enabled by default as it's been shown to cause some strange issues with certain IHVs that have yet to be understood.

#define SECONDARY_COMMAND_BUFFERS_PER_FRAME …

RenderingDevice *RenderingDevice::singleton = …;

RenderingDevice *RenderingDevice::get_singleton() { … }

RenderingDevice::ShaderCompileToSPIRVFunction RenderingDevice::compile_to_spirv_function = …;
RenderingDevice::ShaderCacheFunction RenderingDevice::cache_function = …;
RenderingDevice::ShaderSPIRVGetCacheKeyFunction RenderingDevice::get_spirv_cache_key_function = …;

/***************************/
/**** ID INFRASTRUCTURE ****/
/***************************/

void RenderingDevice::_add_dependency(RID p_id, RID p_depends_on) { … }

void RenderingDevice::_free_dependencies(RID p_id) { … }

void RenderingDevice::shader_set_compile_to_spirv_function(ShaderCompileToSPIRVFunction p_function) { … }

void RenderingDevice::shader_set_spirv_cache_function(ShaderCacheFunction p_function) { … }

void RenderingDevice::shader_set_get_cache_key_function(ShaderSPIRVGetCacheKeyFunction p_function) { … }

Vector<uint8_t> RenderingDevice::shader_compile_spirv_from_source(ShaderStage p_stage, const String &p_source_code, ShaderLanguage p_language, String *r_error, bool p_allow_cache) { … }

String RenderingDevice::shader_get_spirv_cache_key() const { … }

RID RenderingDevice::shader_create_from_spirv(const Vector<ShaderStageSPIRVData> &p_spirv, const String &p_shader_name) { … }

/***************************/
/**** BUFFER MANAGEMENT ****/
/***************************/

RenderingDevice::Buffer *RenderingDevice::_get_buffer_from_owner(RID p_buffer) { … }

Error RenderingDevice::_buffer_initialize(Buffer *p_buffer, const uint8_t *p_data, size_t p_data_size, uint32_t p_required_align) { … }

Error RenderingDevice::_insert_staging_block() { … }

Error RenderingDevice::_staging_buffer_allocate(uint32_t p_amount, uint32_t p_required_align, uint32_t &r_alloc_offset, uint32_t &r_alloc_size, StagingRequiredAction &r_required_action, bool p_can_segment) { … }

void RenderingDevice::_staging_buffer_execute_required_action(StagingRequiredAction p_required_action) { … }

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) { … }

Error RenderingDevice::buffer_update(RID p_buffer, uint32_t p_offset, uint32_t p_size, const void *p_data) { … }

String RenderingDevice::get_perf_report() const { … }

void RenderingDevice::update_perf_report() { … }

Error RenderingDevice::buffer_clear(RID p_buffer, uint32_t p_offset, uint32_t p_size) { … }

Vector<uint8_t> RenderingDevice::buffer_get_data(RID p_buffer, uint32_t p_offset, uint32_t p_size) { … }

RID RenderingDevice::storage_buffer_create(uint32_t p_size_bytes, const Vector<uint8_t> &p_data, BitField<StorageBufferUsage> p_usage) { … }

RID RenderingDevice::texture_buffer_create(uint32_t p_size_elements, DataFormat p_format, const Vector<uint8_t> &p_data) { … }

/*****************/
/**** TEXTURE ****/
/*****************/

RID RenderingDevice::texture_create(const TextureFormat &p_format, const TextureView &p_view, const Vector<Vector<uint8_t>> &p_data) { … }

RID RenderingDevice::texture_create_shared(const TextureView &p_view, RID p_with_texture) { … }

RID RenderingDevice::texture_create_from_extension(TextureType p_type, DataFormat p_format, TextureSamples p_samples, BitField<RenderingDevice::TextureUsageBits> p_usage, uint64_t p_image, uint64_t p_width, uint64_t p_height, uint64_t p_depth, uint64_t p_layers) { … }

RID RenderingDevice::texture_create_shared_from_slice(const TextureView &p_view, RID p_with_texture, uint32_t p_layer, uint32_t p_mipmap, uint32_t p_mipmaps, TextureSliceType p_slice_type, uint32_t p_layers) { … }

static _ALWAYS_INLINE_ void _copy_region(uint8_t const *__restrict p_src, uint8_t *__restrict p_dst, uint32_t p_src_x, uint32_t p_src_y, uint32_t p_src_w, uint32_t p_src_h, uint32_t p_src_full_w, uint32_t p_dst_pitch, uint32_t p_unit_size) { … }

static _ALWAYS_INLINE_ void _copy_region_block_or_regular(const uint8_t *p_read_ptr, uint8_t *p_write_ptr, uint32_t p_x, uint32_t p_y, uint32_t p_width, uint32_t p_region_w, uint32_t p_region_h, uint32_t p_block_w, uint32_t p_block_h, uint32_t p_dst_pitch, uint32_t p_pixel_size, uint32_t p_block_size) { … }

uint32_t RenderingDevice::_texture_layer_count(Texture *p_texture) const { … }

uint32_t RenderingDevice::_texture_alignment(Texture *p_texture) const { … }

Error RenderingDevice::_texture_initialize(RID p_texture, uint32_t p_layer, const Vector<uint8_t> &p_data) { … }

Error RenderingDevice::texture_update(RID p_texture, uint32_t p_layer, const Vector<uint8_t> &p_data) { … }

void RenderingDevice::_texture_check_shared_fallback(Texture *p_texture) { … }

void RenderingDevice::_texture_update_shared_fallback(RID p_texture_rid, Texture *p_texture, bool p_for_writing) { … }

void RenderingDevice::_texture_free_shared_fallback(Texture *p_texture) { … }

void RenderingDevice::_texture_copy_shared(RID p_src_texture_rid, Texture *p_src_texture, RID p_dst_texture_rid, Texture *p_dst_texture) { … }

void RenderingDevice::_texture_create_reinterpret_buffer(Texture *p_texture) { … }

Vector<uint8_t> RenderingDevice::_texture_get_data(Texture *tex, uint32_t p_layer, bool p_2d) { … }

Vector<uint8_t> RenderingDevice::texture_get_data(RID p_texture, uint32_t p_layer) { … }

bool RenderingDevice::texture_is_shared(RID p_texture) { … }

bool RenderingDevice::texture_is_valid(RID p_texture) { … }

RD::TextureFormat RenderingDevice::texture_get_format(RID p_texture) { … }

Size2i RenderingDevice::texture_size(RID p_texture) { … }

#ifndef DISABLE_DEPRECATED
uint64_t RenderingDevice::texture_get_native_handle(RID p_texture) { … }
#endif

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) { … }

Error RenderingDevice::texture_resolve_multisample(RID p_from_texture, RID p_to_texture) { … }

void RenderingDevice::texture_set_discardable(RID p_texture, bool p_discardable) { … }

bool RenderingDevice::texture_is_discardable(RID p_texture) { … }

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) { … }

bool RenderingDevice::texture_is_format_supported_for_usage(DataFormat p_format, BitField<RenderingDevice::TextureUsageBits> p_usage) const { … }

/*********************/
/**** FRAMEBUFFER ****/
/*********************/

RDD::RenderPassID RenderingDevice::_render_pass_create(RenderingDeviceDriver *p_driver, const Vector<AttachmentFormat> &p_attachments, const Vector<FramebufferPass> &p_passes, VectorView<RDD::AttachmentLoadOp> p_load_ops, VectorView<RDD::AttachmentStoreOp> p_store_ops, uint32_t p_view_count, Vector<TextureSamples> *r_samples) { … }

RDD::RenderPassID RenderingDevice::_render_pass_create_from_graph(RenderingDeviceDriver *p_driver, VectorView<RDD::AttachmentLoadOp> p_load_ops, VectorView<RDD::AttachmentStoreOp> p_store_ops, void *p_user_data) { … }

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

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

RenderingDevice::FramebufferFormatID RenderingDevice::framebuffer_format_create_empty(TextureSamples p_samples) { … }

RenderingDevice::TextureSamples RenderingDevice::framebuffer_format_get_texture_samples(FramebufferFormatID p_format, uint32_t p_pass) { … }

RID RenderingDevice::framebuffer_create_empty(const Size2i &p_size, TextureSamples p_samples, FramebufferFormatID p_format_check) { … }

RID RenderingDevice::framebuffer_create(const Vector<RID> &p_texture_attachments, FramebufferFormatID p_format_check, uint32_t p_view_count) { … }

RID RenderingDevice::framebuffer_create_multipass(const Vector<RID> &p_texture_attachments, const Vector<FramebufferPass> &p_passes, FramebufferFormatID p_format_check, uint32_t p_view_count) { … }

RenderingDevice::FramebufferFormatID RenderingDevice::framebuffer_get_format(RID p_framebuffer) { … }

bool RenderingDevice::framebuffer_is_valid(RID p_framebuffer) const { … }

void RenderingDevice::framebuffer_set_invalidation_callback(RID p_framebuffer, InvalidationCallback p_callback, void *p_userdata) { … }

/*****************/
/**** SAMPLER ****/
/*****************/

RID RenderingDevice::sampler_create(const SamplerState &p_state) { … }

bool RenderingDevice::sampler_is_format_supported_for_filter(DataFormat p_format, SamplerFilter p_sampler_filter) const { … }

/***********************/
/**** VERTEX BUFFER ****/
/***********************/

RID RenderingDevice::vertex_buffer_create(uint32_t p_size_bytes, const Vector<uint8_t> &p_data, bool p_use_as_storage) { … }

// Internally reference counted, this ID is warranted to be unique for the same description, but needs to be freed as many times as it was allocated.
RenderingDevice::VertexFormatID RenderingDevice::vertex_format_create(const Vector<VertexAttribute> &p_vertex_descriptions) { … }

RID RenderingDevice::vertex_array_create(uint32_t p_vertex_count, VertexFormatID p_vertex_format, const Vector<RID> &p_src_buffers, const Vector<uint64_t> &p_offsets) { … }

RID RenderingDevice::index_buffer_create(uint32_t p_index_count, IndexBufferFormat p_format, const Vector<uint8_t> &p_data, bool p_use_restart_indices) { … }

RID RenderingDevice::index_array_create(RID p_index_buffer, uint32_t p_index_offset, uint32_t p_index_count) { … }

/****************/
/**** SHADER ****/
/****************/

static const char *SHADER_UNIFORM_NAMES[RenderingDevice::UNIFORM_TYPE_MAX] = …;

String RenderingDevice::_shader_uniform_debug(RID p_shader, int p_set) { … }

String RenderingDevice::shader_get_binary_cache_key() const { … }

Vector<uint8_t> RenderingDevice::shader_compile_binary_from_spirv(const Vector<ShaderStageSPIRVData> &p_spirv, const String &p_shader_name) { … }

RID RenderingDevice::shader_create_from_bytecode(const Vector<uint8_t> &p_shader_binary, RID p_placeholder) { … }

RID RenderingDevice::shader_create_placeholder() { … }

uint64_t RenderingDevice::shader_get_vertex_input_attribute_mask(RID p_shader) { … }

/******************/
/**** UNIFORMS ****/
/******************/

RID RenderingDevice::uniform_buffer_create(uint32_t p_size_bytes, const Vector<uint8_t> &p_data) { … }

void RenderingDevice::_uniform_set_update_shared(UniformSet *p_uniform_set) { … }

template RID RenderingDevice::uniform_set_create(const LocalVector<RD::Uniform> &p_uniforms, RID p_shader, uint32_t p_shader_set);

template RID RenderingDevice::uniform_set_create(const Vector<RD::Uniform> &p_uniforms, RID p_shader, uint32_t p_shader_set);

template <typename Collection>
RID RenderingDevice::uniform_set_create(const Collection &p_uniforms, RID p_shader, uint32_t p_shader_set) { … }

bool RenderingDevice::uniform_set_is_valid(RID p_uniform_set) { … }

void RenderingDevice::uniform_set_set_invalidation_callback(RID p_uniform_set, InvalidationCallback p_callback, void *p_userdata) { … }

/*******************/
/**** PIPELINES ****/
/*******************/

RID RenderingDevice::render_pipeline_create(RID p_shader, FramebufferFormatID p_framebuffer_format, VertexFormatID p_vertex_format, RenderPrimitive p_render_primitive, const PipelineRasterizationState &p_rasterization_state, const PipelineMultisampleState &p_multisample_state, const PipelineDepthStencilState &p_depth_stencil_state, const PipelineColorBlendState &p_blend_state, BitField<PipelineDynamicStateFlags> p_dynamic_state_flags, uint32_t p_for_render_pass, const Vector<PipelineSpecializationConstant> &p_specialization_constants) { … }

bool RenderingDevice::render_pipeline_is_valid(RID p_pipeline) { … }

RID RenderingDevice::compute_pipeline_create(RID p_shader, const Vector<PipelineSpecializationConstant> &p_specialization_constants) { … }

bool RenderingDevice::compute_pipeline_is_valid(RID p_pipeline) { … }

/****************/
/**** SCREEN ****/
/****************/

uint32_t RenderingDevice::_get_swap_chain_desired_count() const { … }

Error RenderingDevice::screen_create(DisplayServer::WindowID p_screen) { … }

Error RenderingDevice::screen_prepare_for_drawing(DisplayServer::WindowID p_screen) { … }

int RenderingDevice::screen_get_width(DisplayServer::WindowID p_screen) const { … }

int RenderingDevice::screen_get_height(DisplayServer::WindowID p_screen) const { … }

int RenderingDevice::screen_get_pre_rotation_degrees(DisplayServer::WindowID p_screen) const { … }

RenderingDevice::FramebufferFormatID RenderingDevice::screen_get_framebuffer_format(DisplayServer::WindowID p_screen) const { … }

Error RenderingDevice::screen_free(DisplayServer::WindowID p_screen) { … }

/*******************/
/**** DRAW LIST ****/
/*******************/

RenderingDevice::DrawListID RenderingDevice::draw_list_begin_for_screen(DisplayServer::WindowID p_screen, const Color &p_clear_color) { … }

RenderingDevice::DrawListID RenderingDevice::draw_list_begin(RID p_framebuffer, BitField<DrawFlags> p_draw_flags, const Vector<Color> &p_clear_color_values, float p_clear_depth_value, uint32_t p_clear_stencil_value, const Rect2 &p_region, uint32_t p_breadcrumb) { … }

#ifndef DISABLE_DEPRECATED
Error RenderingDevice::draw_list_begin_split(RID p_framebuffer, uint32_t p_splits, DrawListID *r_split_ids, 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) { … }
#endif

RenderingDevice::DrawList *RenderingDevice::_get_draw_list_ptr(DrawListID p_id) { … }

void RenderingDevice::draw_list_set_blend_constants(DrawListID p_list, const Color &p_color) { … }

void RenderingDevice::draw_list_bind_render_pipeline(DrawListID p_list, RID p_render_pipeline) { … }

void RenderingDevice::draw_list_bind_uniform_set(DrawListID p_list, RID p_uniform_set, uint32_t p_index) { … }

void RenderingDevice::draw_list_bind_vertex_array(DrawListID p_list, RID p_vertex_array) { … }

void RenderingDevice::draw_list_bind_index_array(DrawListID p_list, RID p_index_array) { … }

void RenderingDevice::draw_list_set_line_width(DrawListID p_list, float p_width) { … }

void RenderingDevice::draw_list_set_push_constant(DrawListID p_list, const void *p_data, uint32_t p_data_size) { … }

void RenderingDevice::draw_list_draw(DrawListID p_list, bool p_use_indices, uint32_t p_instances, uint32_t p_procedural_vertices) { … }

void RenderingDevice::draw_list_draw_indirect(DrawListID p_list, bool p_use_indices, RID p_buffer, uint32_t p_offset, uint32_t p_draw_count, uint32_t p_stride) { … }

void RenderingDevice::draw_list_enable_scissor(DrawListID p_list, const Rect2 &p_rect) { … }

void RenderingDevice::draw_list_disable_scissor(DrawListID p_list) { … }

uint32_t RenderingDevice::draw_list_get_current_pass() { … }

RenderingDevice::DrawListID RenderingDevice::draw_list_switch_to_next_pass() { … }

#ifndef DISABLE_DEPRECATED
Error RenderingDevice::draw_list_switch_to_next_pass_split(uint32_t p_splits, DrawListID *r_split_ids) { … }
#endif

Error RenderingDevice::_draw_list_allocate(const Rect2i &p_viewport, uint32_t p_subpass) { … }

void RenderingDevice::_draw_list_free(Rect2i *r_last_viewport) { … }

void RenderingDevice::draw_list_end() { … }

/***********************/
/**** COMPUTE LISTS ****/
/***********************/

RenderingDevice::ComputeListID RenderingDevice::compute_list_begin() { … }

void RenderingDevice::compute_list_bind_compute_pipeline(ComputeListID p_list, RID p_compute_pipeline) { … }

void RenderingDevice::compute_list_bind_uniform_set(ComputeListID p_list, RID p_uniform_set, uint32_t p_index) { … }

void RenderingDevice::compute_list_set_push_constant(ComputeListID p_list, const void *p_data, uint32_t p_data_size) { … }

void RenderingDevice::compute_list_dispatch(ComputeListID p_list, uint32_t p_x_groups, uint32_t p_y_groups, uint32_t p_z_groups) { … }

void RenderingDevice::compute_list_dispatch_threads(ComputeListID p_list, uint32_t p_x_threads, uint32_t p_y_threads, uint32_t p_z_threads) { … }

void RenderingDevice::compute_list_dispatch_indirect(ComputeListID p_list, RID p_buffer, uint32_t p_offset) { … }

void RenderingDevice::compute_list_add_barrier(ComputeListID p_list) { … }

void RenderingDevice::compute_list_end() { … }

#ifndef DISABLE_DEPRECATED
void RenderingDevice::barrier(BitField<BarrierMask> p_from, BitField<BarrierMask> p_to) { … }

void RenderingDevice::full_barrier() { … }
#endif

/*************************/
/**** TRANSFER WORKER ****/
/*************************/

static uint32_t _get_alignment_offset(uint32_t p_offset, uint32_t p_required_align) { … }

RenderingDevice::TransferWorker *RenderingDevice::_acquire_transfer_worker(uint32_t p_transfer_size, uint32_t p_required_align, uint32_t &r_staging_offset) { … }

void RenderingDevice::_release_transfer_worker(TransferWorker *p_transfer_worker) { … }

void RenderingDevice::_end_transfer_worker(TransferWorker *p_transfer_worker) { … }

void RenderingDevice::_submit_transfer_worker(TransferWorker *p_transfer_worker, VectorView<RDD::SemaphoreID> p_signal_semaphores) { … }

void RenderingDevice::_wait_for_transfer_worker(TransferWorker *p_transfer_worker) { … }

void RenderingDevice::_flush_barriers_for_transfer_worker(TransferWorker *p_transfer_worker) { … }

void RenderingDevice::_check_transfer_worker_operation(uint32_t p_transfer_worker_index, uint64_t p_transfer_worker_operation) { … }

void RenderingDevice::_check_transfer_worker_buffer(Buffer *p_buffer) { … }

void RenderingDevice::_check_transfer_worker_texture(Texture *p_texture) { … }

void RenderingDevice::_check_transfer_worker_vertex_array(VertexArray *p_vertex_array) { … }

void RenderingDevice::_check_transfer_worker_index_array(IndexArray *p_index_array) { … }

void RenderingDevice::_submit_transfer_workers(RDD::CommandBufferID p_draw_command_buffer) { … }

void RenderingDevice::_submit_transfer_barriers(RDD::CommandBufferID p_draw_command_buffer) { … }

void RenderingDevice::_wait_for_transfer_workers() { … }

void RenderingDevice::_free_transfer_workers() { … }

/***********************/
/**** COMMAND GRAPH ****/
/***********************/

bool RenderingDevice::_texture_make_mutable(Texture *p_texture, RID p_texture_id) { … }

bool RenderingDevice::_buffer_make_mutable(Buffer *p_buffer, RID p_buffer_id) { … }

bool RenderingDevice::_vertex_array_make_mutable(VertexArray *p_vertex_array, RID p_resource_id, RDG::ResourceTracker *p_resource_tracker) { … }

bool RenderingDevice::_index_array_make_mutable(IndexArray *p_index_array, RDG::ResourceTracker *p_resource_tracker) { … }

bool RenderingDevice::_uniform_set_make_mutable(UniformSet *p_uniform_set, RID p_resource_id, RDG::ResourceTracker *p_resource_tracker) { … }

bool RenderingDevice::_dependency_make_mutable(RID p_id, RID p_resource_id, RDG::ResourceTracker *p_resource_tracker) { … }

bool RenderingDevice::_dependencies_make_mutable_recursive(RID p_id, RDG::ResourceTracker *p_resource_tracker) { … }

bool RenderingDevice::_dependencies_make_mutable(RID p_id, RDG::ResourceTracker *p_resource_tracker) { … }

/**************************/
/**** FRAME MANAGEMENT ****/
/**************************/

void RenderingDevice::free(RID p_id) { … }

void RenderingDevice::_free_internal(RID p_id) { … }

// The full list of resources that can be named is in the VkObjectType enum.
// We just expose the resources that are owned and can be accessed easily.
void RenderingDevice::set_resource_name(RID p_id, const String &p_name) { … }

void RenderingDevice::draw_command_begin_label(String p_label_name, const Color &p_color) { … }

#ifndef DISABLE_DEPRECATED
void RenderingDevice::draw_command_insert_label(String p_label_name, const Color &p_color) { … }
#endif

void RenderingDevice::draw_command_end_label() { … }

String RenderingDevice::get_device_vendor_name() const { … }

String RenderingDevice::get_device_name() const { … }

RenderingDevice::DeviceType RenderingDevice::get_device_type() const { … }

String RenderingDevice::get_device_api_name() const { … }

bool RenderingDevice::is_composite_alpha_supported() const { … }

String RenderingDevice::get_device_api_version() const { … }

String RenderingDevice::get_device_pipeline_cache_uuid() const { … }

void RenderingDevice::swap_buffers() { … }

void RenderingDevice::submit() { … }

void RenderingDevice::sync() { … }

void RenderingDevice::_free_pending_resources(int p_frame) { … }

uint32_t RenderingDevice::get_frame_delay() const { … }

uint64_t RenderingDevice::get_memory_usage(MemoryType p_type) const { … }

void RenderingDevice::_begin_frame() { … }

void RenderingDevice::_end_frame() { … }

void RenderingDevice::_execute_frame(bool p_present) { … }

void RenderingDevice::_stall_for_previous_frames() { … }

void RenderingDevice::_flush_and_stall_for_all_frames() { … }

Error RenderingDevice::initialize(RenderingContextDriver *p_context, DisplayServer::WindowID p_main_window) { … }

Vector<uint8_t> RenderingDevice::_load_pipeline_cache() { … }

void RenderingDevice::_update_pipeline_cache(bool p_closing) { … }

void RenderingDevice::_save_pipeline_cache(void *p_data) { … }

template <typename T>
void RenderingDevice::_free_rids(T &p_owner, const char *p_type) { … }

void RenderingDevice::capture_timestamp(const String &p_name) { … }

uint64_t RenderingDevice::get_driver_resource(DriverResource p_resource, RID p_rid, uint64_t p_index) { … }

String RenderingDevice::get_driver_and_device_memory_report() const { … }

String RenderingDevice::get_tracked_object_name(uint32_t p_type_index) const { … }

uint64_t RenderingDevice::get_tracked_object_type_count() const { … }

uint64_t RenderingDevice::get_driver_total_memory() const { … }

uint64_t RenderingDevice::get_driver_allocation_count() const { … }

uint64_t RenderingDevice::get_driver_memory_by_object_type(uint32_t p_type) const { … }

uint64_t RenderingDevice::get_driver_allocs_by_object_type(uint32_t p_type) const { … }

uint64_t RenderingDevice::get_device_total_memory() const { … }

uint64_t RenderingDevice::get_device_allocation_count() const { … }

uint64_t RenderingDevice::get_device_memory_by_object_type(uint32_t type) const { … }

uint64_t RenderingDevice::get_device_allocs_by_object_type(uint32_t type) const { … }

uint32_t RenderingDevice::get_captured_timestamps_count() const { … }

uint64_t RenderingDevice::get_captured_timestamps_frame() const { … }

uint64_t RenderingDevice::get_captured_timestamp_gpu_time(uint32_t p_index) const { … }

uint64_t RenderingDevice::get_captured_timestamp_cpu_time(uint32_t p_index) const { … }

String RenderingDevice::get_captured_timestamp_name(uint32_t p_index) const { … }

uint64_t RenderingDevice::limit_get(Limit p_limit) const { … }

void RenderingDevice::finalize() { … }

void RenderingDevice::_set_max_fps(int p_max_fps) { … }

RenderingDevice *RenderingDevice::create_local_device() { … }

bool RenderingDevice::has_feature(const Features p_feature) const { … }

void RenderingDevice::_bind_methods() { … }

void RenderingDevice::make_current() { … }

RenderingDevice::~RenderingDevice() { … }

RenderingDevice::RenderingDevice() { … }

/*****************/
/**** BINDERS ****/
/*****************/

RID RenderingDevice::_texture_create(const Ref<RDTextureFormat> &p_format, const Ref<RDTextureView> &p_view, const TypedArray<PackedByteArray> &p_data) { … }

RID RenderingDevice::_texture_create_shared(const Ref<RDTextureView> &p_view, RID p_with_texture) { … }

RID RenderingDevice::_texture_create_shared_from_slice(const Ref<RDTextureView> &p_view, RID p_with_texture, uint32_t p_layer, uint32_t p_mipmap, uint32_t p_mipmaps, TextureSliceType p_slice_type) { … }

Ref<RDTextureFormat> RenderingDevice::_texture_get_format(RID p_rd_texture) { … }

RenderingDevice::FramebufferFormatID RenderingDevice::_framebuffer_format_create(const TypedArray<RDAttachmentFormat> &p_attachments, uint32_t p_view_count) { … }

RenderingDevice::FramebufferFormatID RenderingDevice::_framebuffer_format_create_multipass(const TypedArray<RDAttachmentFormat> &p_attachments, const TypedArray<RDFramebufferPass> &p_passes, uint32_t p_view_count) { … }

RID RenderingDevice::_framebuffer_create(const TypedArray<RID> &p_textures, FramebufferFormatID p_format_check, uint32_t p_view_count) { … }

RID RenderingDevice::_framebuffer_create_multipass(const TypedArray<RID> &p_textures, const TypedArray<RDFramebufferPass> &p_passes, FramebufferFormatID p_format_check, uint32_t p_view_count) { … }

RID RenderingDevice::_sampler_create(const Ref<RDSamplerState> &p_state) { … }

RenderingDevice::VertexFormatID RenderingDevice::_vertex_format_create(const TypedArray<RDVertexAttribute> &p_vertex_formats) { … }

RID RenderingDevice::_vertex_array_create(uint32_t p_vertex_count, VertexFormatID p_vertex_format, const TypedArray<RID> &p_src_buffers, const Vector<int64_t> &p_offsets) { … }

Ref<RDShaderSPIRV> RenderingDevice::_shader_compile_spirv_from_source(const Ref<RDShaderSource> &p_source, bool p_allow_cache) { … }

Vector<uint8_t> RenderingDevice::_shader_compile_binary_from_spirv(const Ref<RDShaderSPIRV> &p_spirv, const String &p_shader_name) { … }

RID RenderingDevice::_shader_create_from_spirv(const Ref<RDShaderSPIRV> &p_spirv, const String &p_shader_name) { … }

RID RenderingDevice::_uniform_set_create(const TypedArray<RDUniform> &p_uniforms, RID p_shader, uint32_t p_shader_set) { … }

Error RenderingDevice::_buffer_update_bind(RID p_buffer, uint32_t p_offset, uint32_t p_size, const Vector<uint8_t> &p_data) { … }

static Vector<RenderingDevice::PipelineSpecializationConstant> _get_spec_constants(const TypedArray<RDPipelineSpecializationConstant> &p_constants) { … }

RID RenderingDevice::_render_pipeline_create(RID p_shader, FramebufferFormatID p_framebuffer_format, VertexFormatID p_vertex_format, RenderPrimitive p_render_primitive, const Ref<RDPipelineRasterizationState> &p_rasterization_state, const Ref<RDPipelineMultisampleState> &p_multisample_state, const Ref<RDPipelineDepthStencilState> &p_depth_stencil_state, const Ref<RDPipelineColorBlendState> &p_blend_state, BitField<PipelineDynamicStateFlags> p_dynamic_state_flags, uint32_t p_for_render_pass, const TypedArray<RDPipelineSpecializationConstant> &p_specialization_constants) { … }

RID RenderingDevice::_compute_pipeline_create(RID p_shader, const TypedArray<RDPipelineSpecializationConstant> &p_specialization_constants = TypedArray<RDPipelineSpecializationConstant>()) { … }

#ifndef DISABLE_DEPRECATED
Vector<int64_t> RenderingDevice::_draw_list_begin_split(RID p_framebuffer, uint32_t p_splits, 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<int64_t> RenderingDevice::_draw_list_switch_to_next_pass_split(uint32_t p_splits) { … }
#endif

void RenderingDevice::_draw_list_set_push_constant(DrawListID p_list, const Vector<uint8_t> &p_data, uint32_t p_data_size) { … }

void RenderingDevice::_compute_list_set_push_constant(ComputeListID p_list, const Vector<uint8_t> &p_data, uint32_t p_data_size) { … }