Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

RenderingDevice¶

Inherits: Object

Abstraction for working with modern low-level graphics APIs.

Description¶

RenderingDevice is an abstraction for working with modern low-level graphics APIs such as Vulkan. Compared to RenderingServer (which works with Godot's own rendering subsystems), RenderingDevice is much lower-level and allows working more directly with the underlying graphics APIs. RenderingDevice is used in Godot to provide support for several modern low-level graphics APIs while reducing the amount of code duplication required. RenderingDevice can also be used in your own projects to perform things that are not exposed by RenderingServer or high-level nodes, such as using compute shaders.

On startup, Godot creates a global RenderingDevice which can be retrieved using RenderingServer.get_rendering_device. This global RenderingDevice performs drawing to the screen.

Local RenderingDevices: Using RenderingServer.create_local_rendering_device, you can create "secondary" rendering devices to perform drawing and GPU compute operations on separate threads.

Note: RenderingDevice assumes intermediate knowledge of modern graphics APIs such as Vulkan, Direct3D 12, Metal or WebGPU. These graphics APIs are lower-level than OpenGL or Direct3D 11, requiring you to perform what was previously done by the graphics driver itself. If you have difficulty understanding the concepts used in this class, follow the Vulkan Tutorial or Vulkan Guide. It's recommended to have existing modern OpenGL or Direct3D 11 knowledge before attempting to learn a low-level graphics API.

Note: RenderingDevice is not available when running in headless mode or when using the Compatibility rendering method.

Tutorials¶

Using compute shaders

Methods¶

void	barrier ( BitField<BarrierMask> from=32767, BitField<BarrierMask> to=32767 )
Error	buffer_clear ( RID buffer, int offset, int size_bytes, BitField<BarrierMask> post_barrier=32767 )
PackedByteArray	buffer_get_data ( RID buffer, int offset_bytes=0, int size_bytes=0 )
Error	buffer_update ( RID buffer, int offset, int size_bytes, PackedByteArray data, BitField<BarrierMask> post_barrier=32767 )
void	capture_timestamp ( String name )
void	compute_list_add_barrier ( int compute_list )
int	compute_list_begin ( bool allow_draw_overlap=false )
void	compute_list_bind_compute_pipeline ( int compute_list, RID compute_pipeline )
void	compute_list_bind_uniform_set ( int compute_list, RID uniform_set, int set_index )
void	compute_list_dispatch ( int compute_list, int x_groups, int y_groups, int z_groups )
void	compute_list_end ( BitField<BarrierMask> post_barrier=32767 )
void	compute_list_set_push_constant ( int compute_list, PackedByteArray buffer, int size_bytes )
RID	compute_pipeline_create ( RID shader, RDPipelineSpecializationConstant[] specialization_constants=[] )
bool	compute_pipeline_is_valid ( RID compute_pipeline )
RenderingDevice	create_local_device ( )
void	draw_command_begin_label ( String name, Color color )
void	draw_command_end_label ( )
void	draw_command_insert_label ( String name, Color color )
int	draw_list_begin ( RID framebuffer, InitialAction initial_color_action, FinalAction final_color_action, InitialAction initial_depth_action, FinalAction final_depth_action, PackedColorArray clear_color_values=PackedColorArray(), float clear_depth=1.0, int clear_stencil=0, Rect2 region=Rect2(0, 0, 0, 0), RID[] storage_textures=[] )
int	draw_list_begin_for_screen ( int screen=0, Color clear_color=Color(0, 0, 0, 1) )
PackedInt64Array	draw_list_begin_split ( RID framebuffer, int