godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2026-01-04 10:09:56 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.5
godot-docs-l10n/classes/es/class_renderingdevice.rst
Rémi Verschelde 369fd84a4f Sync classref with 4.5 branch
2025-12-19 14:34:07 +01:00

6924 lines
523 KiB
ReStructuredText
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

:github_url: hide
.. _class_RenderingDevice:
RenderingDevice
===============
**Hereda:** :ref:`Object<class_Object>`
Abstracción para trabajar con las modernas APIs gráficas de bajo nivel.
.. rst-class:: classref-introduction-group
Descripción
----------------------
**RenderingDevice** es una abstracción para trabajar con las modernas APIs gráficas de bajo nivel, como Vulkan. En comparación con :ref:`RenderingServer<class_RenderingServer>` (que trabaja con los propios subsistemas de renderizado de Godot), **RenderingDevice** es de un nivel mucho más bajo y permite trabajar más directamente con las APIs gráficas subyacentes. **RenderingDevice** se utiliza en Godot para dar soporte a varias APIs gráficas modernas de bajo nivel, al tiempo que se reduce la cantidad de duplicación de código necesaria. **RenderingDevice** también se puede utilizar en tus propios proyectos para realizar cosas que no están expuestas por :ref:`RenderingServer<class_RenderingServer>` o nodos de alto nivel, como el uso de shaders de cálculo.
Al inicio, Godot crea un **RenderingDevice** global que se puede recuperar utilizando :ref:`RenderingServer.get_rendering_device()<class_RenderingServer_method_get_rendering_device>`. Este **RenderingDevice** global realiza el dibujado en la pantalla.
\ **RenderingDevices Locales:** Usando :ref:`RenderingServer.create_local_rendering_device()<class_RenderingServer_method_create_local_rendering_device>`, puedes crear dispositivos de renderizado "secundarios" para realizar operaciones de dibujo y cálculo de GPU en hilos separados.
\ **Nota:** **RenderingDevice** asume un conocimiento intermedio de las APIs gráficas modernas como Vulkan, Direct3D 12, Metal o WebGPU. Estas APIs gráficas son de más bajo nivel que OpenGL o Direct3D 11, lo que requiere que realices lo que antes hacía el propio controlador de gráficos. Si tienes dificultades para entender los conceptos utilizados en esta clase, sigue el `Tutorial de Vulkan <https://vulkan-tutorial.com/>`__ o la `Guía de Vulkan <https://vkguide.dev/>`__. Se recomienda tener conocimientos existentes de OpenGL o Direct3D 11 modernos antes de intentar aprender una API de gráficos de bajo nivel.
\ **Nota:** **RenderingDevice** no está disponible cuando se ejecuta en modo headless o cuando se utiliza el método de renderizado de Compatibilidad.
.. rst-class:: classref-introduction-group
Tutoriales
--------------------
- :doc:`Usando shaders de cómputo <../tutorials/shaders/compute_shaders>`
.. rst-class:: classref-reftable-group
Métodos
--------------
.. table::
:widths: auto
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`barrier<class_RenderingDevice_method_barrier>`\ (\ from\: |bitfield|\[:ref:`BarrierMask<enum_RenderingDevice_BarrierMask>`\] = 32767, to\: |bitfield|\[:ref:`BarrierMask<enum_RenderingDevice_BarrierMask>`\] = 32767\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`buffer_clear<class_RenderingDevice_method_buffer_clear>`\ (\ buffer\: :ref:`RID<class_RID>`, offset\: :ref:`int<class_int>`, size_bytes\: :ref:`int<class_int>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`buffer_copy<class_RenderingDevice_method_buffer_copy>`\ (\ src_buffer\: :ref:`RID<class_RID>`, dst_buffer\: :ref:`RID<class_RID>`, src_offset\: :ref:`int<class_int>`, dst_offset\: :ref:`int<class_int>`, size\: :ref:`int<class_int>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`buffer_get_data<class_RenderingDevice_method_buffer_get_data>`\ (\ buffer\: :ref:`RID<class_RID>`, offset_bytes\: :ref:`int<class_int>` = 0, size_bytes\: :ref:`int<class_int>` = 0\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`buffer_get_data_async<class_RenderingDevice_method_buffer_get_data_async>`\ (\ buffer\: :ref:`RID<class_RID>`, callback\: :ref:`Callable<class_Callable>`, offset_bytes\: :ref:`int<class_int>` = 0, size_bytes\: :ref:`int<class_int>` = 0\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`buffer_get_device_address<class_RenderingDevice_method_buffer_get_device_address>`\ (\ buffer\: :ref:`RID<class_RID>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`buffer_update<class_RenderingDevice_method_buffer_update>`\ (\ buffer\: :ref:`RID<class_RID>`, offset\: :ref:`int<class_int>`, size_bytes\: :ref:`int<class_int>`, data\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`capture_timestamp<class_RenderingDevice_method_capture_timestamp>`\ (\ name\: :ref:`String<class_String>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`compute_list_add_barrier<class_RenderingDevice_method_compute_list_add_barrier>`\ (\ compute_list\: :ref:`int<class_int>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`compute_list_begin<class_RenderingDevice_method_compute_list_begin>`\ (\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`compute_list_bind_compute_pipeline<class_RenderingDevice_method_compute_list_bind_compute_pipeline>`\ (\ compute_list\: :ref:`int<class_int>`, compute_pipeline\: :ref:`RID<class_RID>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`compute_list_bind_uniform_set<class_RenderingDevice_method_compute_list_bind_uniform_set>`\ (\ compute_list\: :ref:`int<class_int>`, uniform_set\: :ref:`RID<class_RID>`, set_index\: :ref:`int<class_int>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`compute_list_dispatch<class_RenderingDevice_method_compute_list_dispatch>`\ (\ compute_list\: :ref:`int<class_int>`, x_groups\: :ref:`int<class_int>`, y_groups\: :ref:`int<class_int>`, z_groups\: :ref:`int<class_int>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`compute_list_dispatch_indirect<class_RenderingDevice_method_compute_list_dispatch_indirect>`\ (\ compute_list\: :ref:`int<class_int>`, buffer\: :ref:`RID<class_RID>`, offset\: :ref:`int<class_int>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`compute_list_end<class_RenderingDevice_method_compute_list_end>`\ (\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`compute_list_set_push_constant<class_RenderingDevice_method_compute_list_set_push_constant>`\ (\ compute_list\: :ref:`int<class_int>`, buffer\: :ref:`PackedByteArray<class_PackedByteArray>`, size_bytes\: :ref:`int<class_int>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`compute_pipeline_create<class_RenderingDevice_method_compute_pipeline_create>`\ (\ shader\: :ref:`RID<class_RID>`, specialization_constants\: :ref:`Array<class_Array>`\[:ref:`RDPipelineSpecializationConstant<class_RDPipelineSpecializationConstant>`\] = []\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`compute_pipeline_is_valid<class_RenderingDevice_method_compute_pipeline_is_valid>`\ (\ compute_pipeline\: :ref:`RID<class_RID>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RenderingDevice<class_RenderingDevice>` | :ref:`create_local_device<class_RenderingDevice_method_create_local_device>`\ (\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_command_begin_label<class_RenderingDevice_method_draw_command_begin_label>`\ (\ name\: :ref:`String<class_String>`, color\: :ref:`Color<class_Color>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_command_end_label<class_RenderingDevice_method_draw_command_end_label>`\ (\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_command_insert_label<class_RenderingDevice_method_draw_command_insert_label>`\ (\ name\: :ref:`String<class_String>`, color\: :ref:`Color<class_Color>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`draw_list_begin<class_RenderingDevice_method_draw_list_begin>`\ (\ framebuffer\: :ref:`RID<class_RID>`, draw_flags\: |bitfield|\[:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>`\] = 0, clear_color_values\: :ref:`PackedColorArray<class_PackedColorArray>` = PackedColorArray(), clear_depth_value\: :ref:`float<class_float>` = 1.0, clear_stencil_value\: :ref:`int<class_int>` = 0, region\: :ref:`Rect2<class_Rect2>` = Rect2(0, 0, 0, 0), breadcrumb\: :ref:`int<class_int>` = 0\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`draw_list_begin_for_screen<class_RenderingDevice_method_draw_list_begin_for_screen>`\ (\ screen\: :ref:`int<class_int>` = 0, clear_color\: :ref:`Color<class_Color>` = Color(0, 0, 0, 1)\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedInt64Array<class_PackedInt64Array>` | :ref:`draw_list_begin_split<class_RenderingDevice_method_draw_list_begin_split>`\ (\ framebuffer\: :ref:`RID<class_RID>`, splits\: :ref:`int<class_int>`, initial_color_action\: :ref:`InitialAction<enum_RenderingDevice_InitialAction>`, final_color_action\: :ref:`FinalAction<enum_RenderingDevice_FinalAction>`, initial_depth_action\: :ref:`InitialAction<enum_RenderingDevice_InitialAction>`, final_depth_action\: :ref:`FinalAction<enum_RenderingDevice_FinalAction>`, clear_color_values\: :ref:`PackedColorArray<class_PackedColorArray>` = PackedColorArray(), clear_depth\: :ref:`float<class_float>` = 1.0, clear_stencil\: :ref:`int<class_int>` = 0, region\: :ref:`Rect2<class_Rect2>` = Rect2(0, 0, 0, 0), storage_textures\: :ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\] = []\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_list_bind_index_array<class_RenderingDevice_method_draw_list_bind_index_array>`\ (\ draw_list\: :ref:`int<class_int>`, index_array\: :ref:`RID<class_RID>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_list_bind_render_pipeline<class_RenderingDevice_method_draw_list_bind_render_pipeline>`\ (\ draw_list\: :ref:`int<class_int>`, render_pipeline\: :ref:`RID<class_RID>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_list_bind_uniform_set<class_RenderingDevice_method_draw_list_bind_uniform_set>`\ (\ draw_list\: :ref:`int<class_int>`, uniform_set\: :ref:`RID<class_RID>`, set_index\: :ref:`int<class_int>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_list_bind_vertex_array<class_RenderingDevice_method_draw_list_bind_vertex_array>`\ (\ draw_list\: :ref:`int<class_int>`, vertex_array\: :ref:`RID<class_RID>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_list_disable_scissor<class_RenderingDevice_method_draw_list_disable_scissor>`\ (\ draw_list\: :ref:`int<class_int>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_list_draw<class_RenderingDevice_method_draw_list_draw>`\ (\ draw_list\: :ref:`int<class_int>`, use_indices\: :ref:`bool<class_bool>`, instances\: :ref:`int<class_int>`, procedural_vertex_count\: :ref:`int<class_int>` = 0\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_list_draw_indirect<class_RenderingDevice_method_draw_list_draw_indirect>`\ (\ draw_list\: :ref:`int<class_int>`, use_indices\: :ref:`bool<class_bool>`, buffer\: :ref:`RID<class_RID>`, offset\: :ref:`int<class_int>` = 0, draw_count\: :ref:`int<class_int>` = 1, stride\: :ref:`int<class_int>` = 0\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_list_enable_scissor<class_RenderingDevice_method_draw_list_enable_scissor>`\ (\ draw_list\: :ref:`int<class_int>`, rect\: :ref:`Rect2<class_Rect2>` = Rect2(0, 0, 0, 0)\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_list_end<class_RenderingDevice_method_draw_list_end>`\ (\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_list_set_blend_constants<class_RenderingDevice_method_draw_list_set_blend_constants>`\ (\ draw_list\: :ref:`int<class_int>`, color\: :ref:`Color<class_Color>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_list_set_push_constant<class_RenderingDevice_method_draw_list_set_push_constant>`\ (\ draw_list\: :ref:`int<class_int>`, buffer\: :ref:`PackedByteArray<class_PackedByteArray>`, size_bytes\: :ref:`int<class_int>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`draw_list_switch_to_next_pass<class_RenderingDevice_method_draw_list_switch_to_next_pass>`\ (\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedInt64Array<class_PackedInt64Array>` | :ref:`draw_list_switch_to_next_pass_split<class_RenderingDevice_method_draw_list_switch_to_next_pass_split>`\ (\ splits\: :ref:`int<class_int>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`framebuffer_create<class_RenderingDevice_method_framebuffer_create>`\ (\ textures\: :ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\], validate_with_format\: :ref:`int<class_int>` = -1, view_count\: :ref:`int<class_int>` = 1\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`framebuffer_create_empty<class_RenderingDevice_method_framebuffer_create_empty>`\ (\ size\: :ref:`Vector2i<class_Vector2i>`, samples\: :ref:`TextureSamples<enum_RenderingDevice_TextureSamples>` = 0, validate_with_format\: :ref:`int<class_int>` = -1\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`framebuffer_create_multipass<class_RenderingDevice_method_framebuffer_create_multipass>`\ (\ textures\: :ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\], passes\: :ref:`Array<class_Array>`\[:ref:`RDFramebufferPass<class_RDFramebufferPass>`\], validate_with_format\: :ref:`int<class_int>` = -1, view_count\: :ref:`int<class_int>` = 1\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`framebuffer_format_create<class_RenderingDevice_method_framebuffer_format_create>`\ (\ attachments\: :ref:`Array<class_Array>`\[:ref:`RDAttachmentFormat<class_RDAttachmentFormat>`\], view_count\: :ref:`int<class_int>` = 1\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`framebuffer_format_create_empty<class_RenderingDevice_method_framebuffer_format_create_empty>`\ (\ samples\: :ref:`TextureSamples<enum_RenderingDevice_TextureSamples>` = 0\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`framebuffer_format_create_multipass<class_RenderingDevice_method_framebuffer_format_create_multipass>`\ (\ attachments\: :ref:`Array<class_Array>`\[:ref:`RDAttachmentFormat<class_RDAttachmentFormat>`\], passes\: :ref:`Array<class_Array>`\[:ref:`RDFramebufferPass<class_RDFramebufferPass>`\], view_count\: :ref:`int<class_int>` = 1\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`TextureSamples<enum_RenderingDevice_TextureSamples>` | :ref:`framebuffer_format_get_texture_samples<class_RenderingDevice_method_framebuffer_format_get_texture_samples>`\ (\ format\: :ref:`int<class_int>`, render_pass\: :ref:`int<class_int>` = 0\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`framebuffer_get_format<class_RenderingDevice_method_framebuffer_get_format>`\ (\ framebuffer\: :ref:`RID<class_RID>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`framebuffer_is_valid<class_RenderingDevice_method_framebuffer_is_valid>`\ (\ framebuffer\: :ref:`RID<class_RID>`\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`free_rid<class_RenderingDevice_method_free_rid>`\ (\ rid\: :ref:`RID<class_RID>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`full_barrier<class_RenderingDevice_method_full_barrier>`\ (\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_captured_timestamp_cpu_time<class_RenderingDevice_method_get_captured_timestamp_cpu_time>`\ (\ index\: :ref:`int<class_int>`\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_captured_timestamp_gpu_time<class_RenderingDevice_method_get_captured_timestamp_gpu_time>`\ (\ index\: :ref:`int<class_int>`\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_captured_timestamp_name<class_RenderingDevice_method_get_captured_timestamp_name>`\ (\ index\: :ref:`int<class_int>`\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_captured_timestamps_count<class_RenderingDevice_method_get_captured_timestamps_count>`\ (\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_captured_timestamps_frame<class_RenderingDevice_method_get_captured_timestamps_frame>`\ (\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_device_allocation_count<class_RenderingDevice_method_get_device_allocation_count>`\ (\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_device_allocs_by_object_type<class_RenderingDevice_method_get_device_allocs_by_object_type>`\ (\ type\: :ref:`int<class_int>`\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_device_memory_by_object_type<class_RenderingDevice_method_get_device_memory_by_object_type>`\ (\ type\: :ref:`int<class_int>`\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_device_name<class_RenderingDevice_method_get_device_name>`\ (\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_device_pipeline_cache_uuid<class_RenderingDevice_method_get_device_pipeline_cache_uuid>`\ (\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_device_total_memory<class_RenderingDevice_method_get_device_total_memory>`\ (\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_device_vendor_name<class_RenderingDevice_method_get_device_vendor_name>`\ (\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_driver_allocation_count<class_RenderingDevice_method_get_driver_allocation_count>`\ (\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_driver_allocs_by_object_type<class_RenderingDevice_method_get_driver_allocs_by_object_type>`\ (\ type\: :ref:`int<class_int>`\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_driver_and_device_memory_report<class_RenderingDevice_method_get_driver_and_device_memory_report>`\ (\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_driver_memory_by_object_type<class_RenderingDevice_method_get_driver_memory_by_object_type>`\ (\ type\: :ref:`int<class_int>`\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_driver_resource<class_RenderingDevice_method_get_driver_resource>`\ (\ resource\: :ref:`DriverResource<enum_RenderingDevice_DriverResource>`, rid\: :ref:`RID<class_RID>`, index\: :ref:`int<class_int>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_driver_total_memory<class_RenderingDevice_method_get_driver_total_memory>`\ (\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_frame_delay<class_RenderingDevice_method_get_frame_delay>`\ (\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_memory_usage<class_RenderingDevice_method_get_memory_usage>`\ (\ type\: :ref:`MemoryType<enum_RenderingDevice_MemoryType>`\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_perf_report<class_RenderingDevice_method_get_perf_report>`\ (\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_tracked_object_name<class_RenderingDevice_method_get_tracked_object_name>`\ (\ type_index\: :ref:`int<class_int>`\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_tracked_object_type_count<class_RenderingDevice_method_get_tracked_object_type_count>`\ (\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has_feature<class_RenderingDevice_method_has_feature>`\ (\ feature\: :ref:`Features<enum_RenderingDevice_Features>`\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`index_array_create<class_RenderingDevice_method_index_array_create>`\ (\ index_buffer\: :ref:`RID<class_RID>`, index_offset\: :ref:`int<class_int>`, index_count\: :ref:`int<class_int>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`index_buffer_create<class_RenderingDevice_method_index_buffer_create>`\ (\ size_indices\: :ref:`int<class_int>`, format\: :ref:`IndexBufferFormat<enum_RenderingDevice_IndexBufferFormat>`, data\: :ref:`PackedByteArray<class_PackedByteArray>` = PackedByteArray(), use_restart_indices\: :ref:`bool<class_bool>` = false, creation_bits\: |bitfield|\[:ref:`BufferCreationBits<enum_RenderingDevice_BufferCreationBits>`\] = 0\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`limit_get<class_RenderingDevice_method_limit_get>`\ (\ limit\: :ref:`Limit<enum_RenderingDevice_Limit>`\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`render_pipeline_create<class_RenderingDevice_method_render_pipeline_create>`\ (\ shader\: :ref:`RID<class_RID>`, framebuffer_format\: :ref:`int<class_int>`, vertex_format\: :ref:`int<class_int>`, primitive\: :ref:`RenderPrimitive<enum_RenderingDevice_RenderPrimitive>`, rasterization_state\: :ref:`RDPipelineRasterizationState<class_RDPipelineRasterizationState>`, multisample_state\: :ref:`RDPipelineMultisampleState<class_RDPipelineMultisampleState>`, stencil_state\: :ref:`RDPipelineDepthStencilState<class_RDPipelineDepthStencilState>`, color_blend_state\: :ref:`RDPipelineColorBlendState<class_RDPipelineColorBlendState>`, dynamic_state_flags\: |bitfield|\[:ref:`PipelineDynamicStateFlags<enum_RenderingDevice_PipelineDynamicStateFlags>`\] = 0, for_render_pass\: :ref:`int<class_int>` = 0, specialization_constants\: :ref:`Array<class_Array>`\[:ref:`RDPipelineSpecializationConstant<class_RDPipelineSpecializationConstant>`\] = []\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`render_pipeline_is_valid<class_RenderingDevice_method_render_pipeline_is_valid>`\ (\ render_pipeline\: :ref:`RID<class_RID>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`sampler_create<class_RenderingDevice_method_sampler_create>`\ (\ state\: :ref:`RDSamplerState<class_RDSamplerState>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`sampler_is_format_supported_for_filter<class_RenderingDevice_method_sampler_is_format_supported_for_filter>`\ (\ format\: :ref:`DataFormat<enum_RenderingDevice_DataFormat>`, sampler_filter\: :ref:`SamplerFilter<enum_RenderingDevice_SamplerFilter>`\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`screen_get_framebuffer_format<class_RenderingDevice_method_screen_get_framebuffer_format>`\ (\ screen\: :ref:`int<class_int>` = 0\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`screen_get_height<class_RenderingDevice_method_screen_get_height>`\ (\ screen\: :ref:`int<class_int>` = 0\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`screen_get_width<class_RenderingDevice_method_screen_get_width>`\ (\ screen\: :ref:`int<class_int>` = 0\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_resource_name<class_RenderingDevice_method_set_resource_name>`\ (\ id\: :ref:`RID<class_RID>`, name\: :ref:`String<class_String>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`shader_compile_binary_from_spirv<class_RenderingDevice_method_shader_compile_binary_from_spirv>`\ (\ spirv_data\: :ref:`RDShaderSPIRV<class_RDShaderSPIRV>`, name\: :ref:`String<class_String>` = ""\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RDShaderSPIRV<class_RDShaderSPIRV>` | :ref:`shader_compile_spirv_from_source<class_RenderingDevice_method_shader_compile_spirv_from_source>`\ (\ shader_source\: :ref:`RDShaderSource<class_RDShaderSource>`, allow_cache\: :ref:`bool<class_bool>` = true\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`shader_create_from_bytecode<class_RenderingDevice_method_shader_create_from_bytecode>`\ (\ binary_data\: :ref:`PackedByteArray<class_PackedByteArray>`, placeholder_rid\: :ref:`RID<class_RID>` = RID()\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`shader_create_from_spirv<class_RenderingDevice_method_shader_create_from_spirv>`\ (\ spirv_data\: :ref:`RDShaderSPIRV<class_RDShaderSPIRV>`, name\: :ref:`String<class_String>` = ""\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`shader_create_placeholder<class_RenderingDevice_method_shader_create_placeholder>`\ (\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`shader_get_vertex_input_attribute_mask<class_RenderingDevice_method_shader_get_vertex_input_attribute_mask>`\ (\ shader\: :ref:`RID<class_RID>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`storage_buffer_create<class_RenderingDevice_method_storage_buffer_create>`\ (\ size_bytes\: :ref:`int<class_int>`, data\: :ref:`PackedByteArray<class_PackedByteArray>` = PackedByteArray(), usage\: |bitfield|\[:ref:`StorageBufferUsage<enum_RenderingDevice_StorageBufferUsage>`\] = 0, creation_bits\: |bitfield|\[:ref:`BufferCreationBits<enum_RenderingDevice_BufferCreationBits>`\] = 0\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`submit<class_RenderingDevice_method_submit>`\ (\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`sync<class_RenderingDevice_method_sync>`\ (\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`texture_buffer_create<class_RenderingDevice_method_texture_buffer_create>`\ (\ size_bytes\: :ref:`int<class_int>`, format\: :ref:`DataFormat<enum_RenderingDevice_DataFormat>`, data\: :ref:`PackedByteArray<class_PackedByteArray>` = PackedByteArray()\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`texture_clear<class_RenderingDevice_method_texture_clear>`\ (\ texture\: :ref:`RID<class_RID>`, color\: :ref:`Color<class_Color>`, base_mipmap\: :ref:`int<class_int>`, mipmap_count\: :ref:`int<class_int>`, base_layer\: :ref:`int<class_int>`, layer_count\: :ref:`int<class_int>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`texture_copy<class_RenderingDevice_method_texture_copy>`\ (\ from_texture\: :ref:`RID<class_RID>`, to_texture\: :ref:`RID<class_RID>`, from_pos\: :ref:`Vector3<class_Vector3>`, to_pos\: :ref:`Vector3<class_Vector3>`, size\: :ref:`Vector3<class_Vector3>`, src_mipmap\: :ref:`int<class_int>`, dst_mipmap\: :ref:`int<class_int>`, src_layer\: :ref:`int<class_int>`, dst_layer\: :ref:`int<class_int>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`texture_create<class_RenderingDevice_method_texture_create>`\ (\ format\: :ref:`RDTextureFormat<class_RDTextureFormat>`, view\: :ref:`RDTextureView<class_RDTextureView>`, data\: :ref:`Array<class_Array>`\[:ref:`PackedByteArray<class_PackedByteArray>`\] = []\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`texture_create_from_extension<class_RenderingDevice_method_texture_create_from_extension>`\ (\ type\: :ref:`TextureType<enum_RenderingDevice_TextureType>`, format\: :ref:`DataFormat<enum_RenderingDevice_DataFormat>`, samples\: :ref:`TextureSamples<enum_RenderingDevice_TextureSamples>`, usage_flags\: |bitfield|\[:ref:`TextureUsageBits<enum_RenderingDevice_TextureUsageBits>`\], image\: :ref:`int<class_int>`, width\: :ref:`int<class_int>`, height\: :ref:`int<class_int>`, depth\: :ref:`int<class_int>`, layers\: :ref:`int<class_int>`, mipmaps\: :ref:`int<class_int>` = 1\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`texture_create_shared<class_RenderingDevice_method_texture_create_shared>`\ (\ view\: :ref:`RDTextureView<class_RDTextureView>`, with_texture\: :ref:`RID<class_RID>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`texture_create_shared_from_slice<class_RenderingDevice_method_texture_create_shared_from_slice>`\ (\ view\: :ref:`RDTextureView<class_RDTextureView>`, with_texture\: :ref:`RID<class_RID>`, layer\: :ref:`int<class_int>`, mipmap\: :ref:`int<class_int>`, mipmaps\: :ref:`int<class_int>` = 1, slice_type\: :ref:`TextureSliceType<enum_RenderingDevice_TextureSliceType>` = 0\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`texture_get_data<class_RenderingDevice_method_texture_get_data>`\ (\ texture\: :ref:`RID<class_RID>`, layer\: :ref:`int<class_int>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`texture_get_data_async<class_RenderingDevice_method_texture_get_data_async>`\ (\ texture\: :ref:`RID<class_RID>`, layer\: :ref:`int<class_int>`, callback\: :ref:`Callable<class_Callable>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RDTextureFormat<class_RDTextureFormat>` | :ref:`texture_get_format<class_RenderingDevice_method_texture_get_format>`\ (\ texture\: :ref:`RID<class_RID>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`texture_get_native_handle<class_RenderingDevice_method_texture_get_native_handle>`\ (\ texture\: :ref:`RID<class_RID>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`texture_is_discardable<class_RenderingDevice_method_texture_is_discardable>`\ (\ texture\: :ref:`RID<class_RID>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`texture_is_format_supported_for_usage<class_RenderingDevice_method_texture_is_format_supported_for_usage>`\ (\ format\: :ref:`DataFormat<enum_RenderingDevice_DataFormat>`, usage_flags\: |bitfield|\[:ref:`TextureUsageBits<enum_RenderingDevice_TextureUsageBits>`\]\ ) |const| |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`texture_is_shared<class_RenderingDevice_method_texture_is_shared>`\ (\ texture\: :ref:`RID<class_RID>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`texture_is_valid<class_RenderingDevice_method_texture_is_valid>`\ (\ texture\: :ref:`RID<class_RID>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`texture_resolve_multisample<class_RenderingDevice_method_texture_resolve_multisample>`\ (\ from_texture\: :ref:`RID<class_RID>`, to_texture\: :ref:`RID<class_RID>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`texture_set_discardable<class_RenderingDevice_method_texture_set_discardable>`\ (\ texture\: :ref:`RID<class_RID>`, discardable\: :ref:`bool<class_bool>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`texture_update<class_RenderingDevice_method_texture_update>`\ (\ texture\: :ref:`RID<class_RID>`, layer\: :ref:`int<class_int>`, data\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`uniform_buffer_create<class_RenderingDevice_method_uniform_buffer_create>`\ (\ size_bytes\: :ref:`int<class_int>`, data\: :ref:`PackedByteArray<class_PackedByteArray>` = PackedByteArray(), creation_bits\: |bitfield|\[:ref:`BufferCreationBits<enum_RenderingDevice_BufferCreationBits>`\] = 0\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`uniform_set_create<class_RenderingDevice_method_uniform_set_create>`\ (\ uniforms\: :ref:`Array<class_Array>`\[:ref:`RDUniform<class_RDUniform>`\], shader\: :ref:`RID<class_RID>`, shader_set\: :ref:`int<class_int>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`uniform_set_is_valid<class_RenderingDevice_method_uniform_set_is_valid>`\ (\ uniform_set\: :ref:`RID<class_RID>`\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`vertex_array_create<class_RenderingDevice_method_vertex_array_create>`\ (\ vertex_count\: :ref:`int<class_int>`, vertex_format\: :ref:`int<class_int>`, src_buffers\: :ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\], offsets\: :ref:`PackedInt64Array<class_PackedInt64Array>` = PackedInt64Array()\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`vertex_buffer_create<class_RenderingDevice_method_vertex_buffer_create>`\ (\ size_bytes\: :ref:`int<class_int>`, data\: :ref:`PackedByteArray<class_PackedByteArray>` = PackedByteArray(), creation_bits\: |bitfield|\[:ref:`BufferCreationBits<enum_RenderingDevice_BufferCreationBits>`\] = 0\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`vertex_format_create<class_RenderingDevice_method_vertex_format_create>`\ (\ vertex_descriptions\: :ref:`Array<class_Array>`\[:ref:`RDVertexAttribute<class_RDVertexAttribute>`\]\ ) |
+------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Enumeraciones
--------------------------
.. _enum_RenderingDevice_DeviceType:
.. rst-class:: classref-enumeration
enum **DeviceType**: :ref:`🔗<enum_RenderingDevice_DeviceType>`
.. _class_RenderingDevice_constant_DEVICE_TYPE_OTHER:
.. rst-class:: classref-enumeration-constant
:ref:`DeviceType<enum_RenderingDevice_DeviceType>` **DEVICE_TYPE_OTHER** = ``0``
El tipo de dispositivo de renderizado no coincide con ninguno de los otros valores del enum o es desconocido.
.. _class_RenderingDevice_constant_DEVICE_TYPE_INTEGRATED_GPU:
.. rst-class:: classref-enumeration-constant
:ref:`DeviceType<enum_RenderingDevice_DeviceType>` **DEVICE_TYPE_INTEGRATED_GPU** = ``1``
El dispositivo de renderizado es una GPU integrada, que suele ser *(pero no siempre)* más lenta que las GPU dedicadas (:ref:`DEVICE_TYPE_DISCRETE_GPU<class_RenderingDevice_constant_DEVICE_TYPE_DISCRETE_GPU>`). En Android e iOS, el tipo de dispositivo de renderizado siempre se considera :ref:`DEVICE_TYPE_INTEGRATED_GPU<class_RenderingDevice_constant_DEVICE_TYPE_INTEGRATED_GPU>`.
.. _class_RenderingDevice_constant_DEVICE_TYPE_DISCRETE_GPU:
.. rst-class:: classref-enumeration-constant
:ref:`DeviceType<enum_RenderingDevice_DeviceType>` **DEVICE_TYPE_DISCRETE_GPU** = ``2``
El dispositivo de renderizado es una GPU dedicada, que suele ser *(pero no siempre)* más rápida que las GPU integradas (:ref:`DEVICE_TYPE_INTEGRATED_GPU<class_RenderingDevice_constant_DEVICE_TYPE_INTEGRATED_GPU>`).
.. _class_RenderingDevice_constant_DEVICE_TYPE_VIRTUAL_GPU:
.. rst-class:: classref-enumeration-constant
:ref:`DeviceType<enum_RenderingDevice_DeviceType>` **DEVICE_TYPE_VIRTUAL_GPU** = ``3``
Rendering device is an emulated GPU in a virtual environment. This is typically much slower than the host GPU, which means the expected performance level on a dedicated GPU will be roughly equivalent to :ref:`DEVICE_TYPE_INTEGRATED_GPU<class_RenderingDevice_constant_DEVICE_TYPE_INTEGRATED_GPU>`. Virtual machine GPU passthrough (such as VFIO) will not report the device type as :ref:`DEVICE_TYPE_VIRTUAL_GPU<class_RenderingDevice_constant_DEVICE_TYPE_VIRTUAL_GPU>`. Instead, the host GPU's device type will be reported as if the GPU was not emulated.
.. _class_RenderingDevice_constant_DEVICE_TYPE_CPU:
.. rst-class:: classref-enumeration-constant
:ref:`DeviceType<enum_RenderingDevice_DeviceType>` **DEVICE_TYPE_CPU** = ``4``
Rendering device is provided by software emulation (such as Lavapipe or `SwiftShader <https://github.com/google/swiftshader>`__). This is the slowest kind of rendering device available; it's typically much slower than :ref:`DEVICE_TYPE_INTEGRATED_GPU<class_RenderingDevice_constant_DEVICE_TYPE_INTEGRATED_GPU>`.
.. _class_RenderingDevice_constant_DEVICE_TYPE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`DeviceType<enum_RenderingDevice_DeviceType>` **DEVICE_TYPE_MAX** = ``5``
Representa el tamaño del enum :ref:`DeviceType<enum_RenderingDevice_DeviceType>`.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_DriverResource:
.. rst-class:: classref-enumeration
enum **DriverResource**: :ref:`🔗<enum_RenderingDevice_DriverResource>`
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_LOGICAL_DEVICE:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_LOGICAL_DEVICE** = ``0``
El objeto de dispositivo específico basado en un dispositivo físico (``rid`` ignorado).
- Vulkan: Recurso del controlador de dispositivo Vulkan (``VkDevice``).
- D3D12: Recurso del controlador de dispositivo D3D12 (``ID3D12Device``).
- Metal: Recurso del controlador de dispositivo Metal (``MTLDevice``).
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_PHYSICAL_DEVICE:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_PHYSICAL_DEVICE** = ``1``
Dispositivo físico en el que se basa el dispositivo lógico específico (``rid`` ignorado).
- Vulkan: ``VkPhysicalDevice``.
- D3D12: ``IDXGIAdapter``.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_TOPMOST_OBJECT:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_TOPMOST_OBJECT** = ``2``
Objeto de entrada de la API de gráficos de más alto nivel (``rid`` ignorado).
- Vulkan: ``VkInstance``.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_COMMAND_QUEUE:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_COMMAND_QUEUE** = ``3``
La cola de comandos principal de gráficos-cálculo (``rid`` ignorado).
- Vulkan: ``VkQueue``.
- Metal: ``MTLCommandQueue``.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_QUEUE_FAMILY:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_QUEUE_FAMILY** = ``4``
La familia específica a la que pertenece la cola principal (``rid`` ignorado).
- Vulkan: El índice de la familia de colas, un ``uint32_t``.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_TEXTURE:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_TEXTURE** = ``5``
- Vulkan: ``VkImage``.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_TEXTURE_VIEW:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_TEXTURE_VIEW** = ``6``
La vista de una textura propia o compartida.
- Vulkan: ``VkImageView``.
- D3D12: ``ID3D12Resource``.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_TEXTURE_DATA_FORMAT:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_TEXTURE_DATA_FORMAT** = ``7``
El ID nativo del formato de datos de la textura.
- Vulkan: ``VkFormat``.
- D3D12: ``DXGI_FORMAT``.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_SAMPLER:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_SAMPLER** = ``8``
- Vulkan: ``VkSampler``.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_UNIFORM_SET:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_UNIFORM_SET** = ``9``
- Vulkan: ``VkDescriptorSet``.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_BUFFER:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_BUFFER** = ``10``
Búfer de cualquier tipo (almacenamiento, vértice, etc.).
- Vulkan: ``VkBuffer``.
- D3D12: ``ID3D12Resource``.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_COMPUTE_PIPELINE:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_COMPUTE_PIPELINE** = ``11``
- Vulkan: ``VkPipeline``.
- Metal: ``MTLComputePipelineState``.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_RENDER_PIPELINE:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_RENDER_PIPELINE** = ``12``
- Vulkan: ``VkPipeline``.
- Metal: ``MTLRenderPipelineState``.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_VULKAN_DEVICE:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_VULKAN_DEVICE** = ``0``
**Obsoleto:** Use :ref:`DRIVER_RESOURCE_LOGICAL_DEVICE<class_RenderingDevice_constant_DRIVER_RESOURCE_LOGICAL_DEVICE>` instead.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_VULKAN_PHYSICAL_DEVICE:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_VULKAN_PHYSICAL_DEVICE** = ``1``
**Obsoleto:** Use :ref:`DRIVER_RESOURCE_PHYSICAL_DEVICE<class_RenderingDevice_constant_DRIVER_RESOURCE_PHYSICAL_DEVICE>` instead.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_VULKAN_INSTANCE:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_VULKAN_INSTANCE** = ``2``
**Obsoleto:** Use :ref:`DRIVER_RESOURCE_TOPMOST_OBJECT<class_RenderingDevice_constant_DRIVER_RESOURCE_TOPMOST_OBJECT>` instead.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_VULKAN_QUEUE:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_VULKAN_QUEUE** = ``3``
**Obsoleto:** Use :ref:`DRIVER_RESOURCE_COMMAND_QUEUE<class_RenderingDevice_constant_DRIVER_RESOURCE_COMMAND_QUEUE>` instead.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_VULKAN_QUEUE_FAMILY_INDEX:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_VULKAN_QUEUE_FAMILY_INDEX** = ``4``
**Obsoleto:** Use :ref:`DRIVER_RESOURCE_QUEUE_FAMILY<class_RenderingDevice_constant_DRIVER_RESOURCE_QUEUE_FAMILY>` instead.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_VULKAN_IMAGE:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_VULKAN_IMAGE** = ``5``
**Obsoleto:** Use :ref:`DRIVER_RESOURCE_TEXTURE<class_RenderingDevice_constant_DRIVER_RESOURCE_TEXTURE>` instead.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_VULKAN_IMAGE_VIEW:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_VULKAN_IMAGE_VIEW** = ``6``
**Obsoleto:** Use :ref:`DRIVER_RESOURCE_TEXTURE_VIEW<class_RenderingDevice_constant_DRIVER_RESOURCE_TEXTURE_VIEW>` instead.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_VULKAN_IMAGE_NATIVE_TEXTURE_FORMAT:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_VULKAN_IMAGE_NATIVE_TEXTURE_FORMAT** = ``7``
**Obsoleto:** Use :ref:`DRIVER_RESOURCE_TEXTURE_DATA_FORMAT<class_RenderingDevice_constant_DRIVER_RESOURCE_TEXTURE_DATA_FORMAT>` instead.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_VULKAN_SAMPLER:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_VULKAN_SAMPLER** = ``8``
**Obsoleto:** Use :ref:`DRIVER_RESOURCE_SAMPLER<class_RenderingDevice_constant_DRIVER_RESOURCE_SAMPLER>` instead.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_VULKAN_DESCRIPTOR_SET:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_VULKAN_DESCRIPTOR_SET** = ``9``
**Obsoleto:** Use :ref:`DRIVER_RESOURCE_UNIFORM_SET<class_RenderingDevice_constant_DRIVER_RESOURCE_UNIFORM_SET>` instead.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_VULKAN_BUFFER:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_VULKAN_BUFFER** = ``10``
**Obsoleto:** Use :ref:`DRIVER_RESOURCE_BUFFER<class_RenderingDevice_constant_DRIVER_RESOURCE_BUFFER>` instead.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_VULKAN_COMPUTE_PIPELINE:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_VULKAN_COMPUTE_PIPELINE** = ``11``
**Obsoleto:** Use :ref:`DRIVER_RESOURCE_COMPUTE_PIPELINE<class_RenderingDevice_constant_DRIVER_RESOURCE_COMPUTE_PIPELINE>` instead.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_VULKAN_RENDER_PIPELINE:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_VULKAN_RENDER_PIPELINE** = ``12``
**Obsoleto:** Use :ref:`DRIVER_RESOURCE_RENDER_PIPELINE<class_RenderingDevice_constant_DRIVER_RESOURCE_RENDER_PIPELINE>` instead.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_DataFormat:
.. rst-class:: classref-enumeration
enum **DataFormat**: :ref:`🔗<enum_RenderingDevice_DataFormat>`
.. _class_RenderingDevice_constant_DATA_FORMAT_R4G4_UNORM_PACK8:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R4G4_UNORM_PACK8** = ``0``
4-bit-per-channel red/green channel data format, packed into 8 bits. Values are in the ``[0.0, 1.0]`` range.
\ **Note:** More information on all data formats can be found on the `Identification of formats <https://registry.khronos.org/vulkan/specs/1.1/html/vkspec.html#_identification_of_formats>`__ section of the Vulkan specification, as well as the `VkFormat <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkFormat.html>`__ enum.
.. _class_RenderingDevice_constant_DATA_FORMAT_R4G4B4A4_UNORM_PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R4G4B4A4_UNORM_PACK16** = ``1``
Formato de datos de canal rojo/verde/azul/alfa de 4 bits por canal, empaquetado en 16 bits. Los valores están en el ``[0.0, 1.0]`` rango.
.. _class_RenderingDevice_constant_DATA_FORMAT_B4G4R4A4_UNORM_PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_B4G4R4A4_UNORM_PACK16** = ``2``
Formato de datos de canal azul/verde/rojo/alfa de 4 bits por canal, empaquetado en 16 bits. Los valores están en el ``[0.0, 1.0]`` rango.
.. _class_RenderingDevice_constant_DATA_FORMAT_R5G6B5_UNORM_PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R5G6B5_UNORM_PACK16** = ``3``
Formato de datos de canal rojo/verde/azul con 5 bits de rojo, 6 bits de verde y 5 bits de azul, empaquetado en 16 bits. Los valores están en el ``[0.0, 1.0]`` rango.
.. _class_RenderingDevice_constant_DATA_FORMAT_B5G6R5_UNORM_PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_B5G6R5_UNORM_PACK16** = ``4``
Formato de datos de canal azul/verde/rojo con 5 bits de azul, 6 bits de verde y 5 bits de rojo, empaquetado en 16 bits. Los valores están en el ``[0.0, 1.0]`` rango.
.. _class_RenderingDevice_constant_DATA_FORMAT_R5G5B5A1_UNORM_PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R5G5B5A1_UNORM_PACK16** = ``5``
Formato de datos de canal rojo/verde/azul/alfa con 5 bits de rojo, 6 bits de verde, 5 bits de azul y 1 bit de alfa, empaquetado en 16 bits. Los valores están en el ``[0.0, 1.0]`` rango.
.. _class_RenderingDevice_constant_DATA_FORMAT_B5G5R5A1_UNORM_PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_B5G5R5A1_UNORM_PACK16** = ``6``
Formato de datos del canal azul/verde/rojo/alfa con 5 bits de azul, 6 bits de verde, 5 bits de rojo y 1 bit de alfa, empaquetados en 16 bits. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_A1R5G5B5_UNORM_PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_A1R5G5B5_UNORM_PACK16** = ``7``
Formato de datos del canal alfa/rojo/verde/azul con 1 bit de alfa, 5 bits de rojo, 6 bits de verde y 5 bits de azul, empaquetados en 16 bits. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8_UNORM** = ``8``
Formato de datos del canal rojo de punto flotante sin signo de 8 bits por canal con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8_SNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8_SNORM** = ``9``
Formato de datos del canal rojo de punto flotante con signo de 8 bits por canal con valor normalizado. Los valores están en el rango ``[-1.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8_USCALED:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8_USCALED** = ``10``
Formato de datos del canal rojo de punto flotante sin signo de 8 bits por canal con valor escalado (el valor se convierte de entero a flotante). Los valores están en el rango ``[0.0, 255.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8_SSCALED:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8_SSCALED** = ``11``
Formato de datos del canal rojo de punto flotante con signo de 8 bits por canal con valor escalado (el valor se convierte de entero a flotante). Los valores están en el rango ``[-127.0, 127.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8_UINT** = ``12``
Formato de datos de canal rojo de 8 bits por canal, entero sin signo. Los valores están en el rango ``[0, 255]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8_SINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8_SINT** = ``13``
Formato de datos de canal rojo de 8 bits por canal, entero con signo. Los valores están en el rango ``[-127, 127]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8_SRGB:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8_SRGB** = ``14``
Formato de datos de canal rojo de 8 bits por canal, de punto flotante sin signo con valor normalizado y codificación sRGB no lineal. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8G8_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8G8_UNORM** = ``15``
Formato de datos de canal rojo/verde de 8 bits por canal, de punto flotante sin signo con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8G8_SNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8G8_SNORM** = ``16``
Formato de datos de canal rojo/verde de 8 bits por canal, de punto flotante con signo con valor normalizado. Los valores están en el rango ``[-1.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8G8_USCALED:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8G8_USCALED** = ``17``
Formato de datos de canal rojo/verde de 8 bits por canal, de punto flotante sin signo con valor escalado (el valor se convierte de entero a flotante). Los valores están en el rango ``[0.0, 255.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8G8_SSCALED:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8G8_SSCALED** = ``18``
Formato de datos de canal rojo/verde de 8 bits por canal, de punto flotante con signo con valor escalado (el valor se convierte de entero a flotante). Los valores están en el rango ``[-127.0, 127.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8G8_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8G8_UINT** = ``19``
Formato de datos de canal rojo/verde de 8 bits por canal, entero sin signo. Los valores están en el rango ``[0, 255]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8G8_SINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8G8_SINT** = ``20``
Formato de datos de canal rojo/verde de 8 bits por canal, entero con signo. Los valores están en el rango ``[-127, 127]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8G8_SRGB:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8G8_SRGB** = ``21``
Formato de datos de canal rojo/verde de 8 bits por canal, de punto flotante sin signo con valor normalizado y codificación sRGB no lineal. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8G8B8_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8G8B8_UNORM** = ``22``
Formato de datos de canal rojo/verde/azul de 8 bits por canal, de punto flotante sin signo con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8G8B8_SNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8G8B8_SNORM** = ``23``
Formato de datos de canal rojo/verde/azul de 8 bits por canal, de punto flotante con signo con valor normalizado. Los valores están en el rango ``[-1.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8G8B8_USCALED:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8G8B8_USCALED** = ``24``
Formato de datos de canal rojo/verde/azul de 8 bits por canal, de punto flotante sin signo con valor escalado (el valor se convierte de entero a flotante). Los valores están en el rango ``[0.0, 255.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8G8B8_SSCALED:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8G8B8_SSCALED** = ``25``
Formato de datos de canal rojo/verde/azul de 8 bits por canal, de punto flotante con signo con valor escalado (el valor se convierte de entero a flotante). Los valores están en el rango ``[-127.0, 127.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8G8B8_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8G8B8_UINT** = ``26``
Formato de datos de canal rojo/verde/azul de 8 bits por canal, entero sin signo. Los valores están en el rango ``[0, 255]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8G8B8_SINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8G8B8_SINT** = ``27``
Formato de datos de canal rojo/verde/azul de entero con signo de 8 bits por canal. Los valores están en el rango ``[-127, 127]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8G8B8_SRGB:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8G8B8_SRGB** = ``28``
Formato de datos de canal rojo/verde/azul de punto flotante sin signo de 8 bits por canal con valor normalizado y codificación sRGB no lineal. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_B8G8R8_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_B8G8R8_UNORM** = ``29``
Formato de datos de canal azul/verde/rojo de punto flotante sin signo de 8 bits por canal con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_B8G8R8_SNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_B8G8R8_SNORM** = ``30``
Formato de datos de canal azul/verde/rojo de punto flotante con signo de 8 bits por canal con valor normalizado. Los valores están en el rango ``[-1.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_B8G8R8_USCALED:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_B8G8R8_USCALED** = ``31``
Formato de datos de canal azul/verde/rojo de punto flotante sin signo de 8 bits por canal con valor escalado (el valor se convierte de entero a flotante). Los valores están en el rango ``[0.0, 255.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_B8G8R8_SSCALED:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_B8G8R8_SSCALED** = ``32``
Formato de datos de canal azul/verde/rojo de punto flotante con signo de 8 bits por canal con valor escalado (el valor se convierte de entero a flotante). Los valores están en el rango ``[-127.0, 127.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_B8G8R8_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_B8G8R8_UINT** = ``33``
Formato de datos de canal azul/verde/rojo de enteros sin signo de 8 bits por canal. Los valores están en el rango ``[0, 255]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_B8G8R8_SINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_B8G8R8_SINT** = ``34``
Formato de datos de canal azul/verde/rojo de enteros con signo de 8 bits por canal. Los valores están en el rango ``[-127, 127]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_B8G8R8_SRGB:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_B8G8R8_SRGB** = ``35``
Formato de datos azul/verde/rojo de punto flotante sin signo de 8 bits por canal con valor normalizado y codificación sRGB no lineal. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8G8B8A8_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8G8B8A8_UNORM** = ``36``
Formato de datos de canal rojo/verde/azul/alfa de punto flotante sin signo de 8 bits por canal con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8G8B8A8_SNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8G8B8A8_SNORM** = ``37``
Formato de datos de canal rojo/verde/azul/alfa de punto flotante con signo de 8 bits por canal con valor normalizado. Los valores están en el rango ``[-1.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8G8B8A8_USCALED:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8G8B8A8_USCALED** = ``38``
Formato de datos de canal rojo/verde/azul/alfa de punto flotante sin signo de 8 bits por canal con valor escalado (el valor se convierte de entero a flotante). Los valores están en el rango ``[0.0, 255.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8G8B8A8_SSCALED:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8G8B8A8_SSCALED** = ``39``
Formato de datos de canal rojo/verde/azul/alfa de punto flotante con signo de 8 bits por canal con valor escalado (el valor se convierte de entero a flotante). Los valores están en el rango ``[-127.0, 127.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8G8B8A8_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8G8B8A8_UINT** = ``40``
Formato de datos de canal rojo/verde/azul/alfa de entero sin signo de 8 bits por canal. Los valores están en el rango ``[0, 255]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8G8B8A8_SINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8G8B8A8_SINT** = ``41``
Formato de datos de canal rojo/verde/azul/alfa de entero con signo de 8 bits por canal. Los valores están en el rango ``[-127, 127]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8G8B8A8_SRGB:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8G8B8A8_SRGB** = ``42``
Formato de datos de canal rojo/verde/azul/alfa de punto flotante sin signo de 8 bits por canal con valor normalizado y codificación sRGB no lineal. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_B8G8R8A8_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_B8G8R8A8_UNORM** = ``43``
Formato de datos de canal azul/verde/rojo/alfa de punto flotante sin signo de 8 bits por canal con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_B8G8R8A8_SNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_B8G8R8A8_SNORM** = ``44``
Formato de datos de canal azul/verde/rojo/alfa de punto flotante con signo de 8 bits por canal con valor normalizado. Los valores están en el rango ``[-1.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_B8G8R8A8_USCALED:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_B8G8R8A8_USCALED** = ``45``
Formato de datos de canal azul/verde/rojo/alfa de punto flotante sin signo de 8 bits por canal con valor escalado (el valor se convierte de entero a flotante). Los valores están en el rango ``[0.0, 255.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_B8G8R8A8_SSCALED:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_B8G8R8A8_SSCALED** = ``46``
Formato de datos de canal azul/verde/rojo/alfa de punto flotante con signo de 8 bits por canal con valor escalado (el valor se convierte de entero a flotante). Los valores están en el rango ``[-127.0, 127.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_B8G8R8A8_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_B8G8R8A8_UINT** = ``47``
Formato de datos de canal azul/verde/rojo/alfa de entero sin signo de 8 bits por canal. Los valores están en el rango ``[0, 255]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_B8G8R8A8_SINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_B8G8R8A8_SINT** = ``48``
Formato de datos de canal azul/verde/rojo/alfa de entero con signo de 8 bits por canal. Los valores están en el rango ``[-127, 127]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_B8G8R8A8_SRGB:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_B8G8R8A8_SRGB** = ``49``
Formato de datos de canal azul/verde/rojo/alfa de punto flotante sin signo de 8 bits por canal con valor normalizado y codificación sRGB no lineal. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_A8B8G8R8_UNORM_PACK32:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_A8B8G8R8_UNORM_PACK32** = ``50``
Formato de datos de canal alfa/rojo/verde/azul de punto flotante sin signo de 8 bits por canal con valor normalizado, empaquetado en 32 bits. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_A8B8G8R8_SNORM_PACK32:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_A8B8G8R8_SNORM_PACK32** = ``51``
Formato de datos de canal alfa/rojo/verde/azul de punto flotante con signo de 8 bits por canal con valor normalizado, empaquetado en 32 bits. Los valores están en el rango ``[-1.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_A8B8G8R8_USCALED_PACK32:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_A8B8G8R8_USCALED_PACK32** = ``52``
Formato de datos de canal alfa/rojo/verde/azul de 8 bits por canal de punto flotante sin signo con valor escalado (el valor se convierte de entero a flotante), empaquetado en 32 bits. Los valores están en el rango ``[0.0, 255.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_A8B8G8R8_SSCALED_PACK32:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_A8B8G8R8_SSCALED_PACK32** = ``53``
Formato de datos de canal alfa/rojo/verde/azul de 8 bits por canal de punto flotante con signo con valor escalado (el valor se convierte de entero a flotante), empaquetado en 32 bits. Los valores están en el rango ``[-127.0, 127.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_A8B8G8R8_UINT_PACK32:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_A8B8G8R8_UINT_PACK32** = ``54``
Formato de datos de canal alfa/rojo/verde/azul de entero sin signo de 8 bits por canal, empaquetado en 32 bits. Los valores están en el rango ``[0, 255]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_A8B8G8R8_SINT_PACK32:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_A8B8G8R8_SINT_PACK32** = ``55``
Formato de datos de canal alfa/rojo/verde/azul de entero con signo de 8 bits por canal, empaquetado en 32 bits. Los valores están en el rango ``[-127, 127]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_A8B8G8R8_SRGB_PACK32:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_A8B8G8R8_SRGB_PACK32** = ``56``
Formato de datos de canal alfa/rojo/verde/azul de 8 bits por canal de punto flotante sin signo con valor normalizado y codificación sRGB no lineal, empaquetado en 32 bits. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_A2R10G10B10_UNORM_PACK32:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_A2R10G10B10_UNORM_PACK32** = ``57``
Formato de datos de canal alfa/rojo/verde/azul de punto flotante sin signo con valor normalizado, empaquetado en 32 bits. El formato contiene 2 bits de alfa, 10 bits de rojo, 10 bits de verde y 10 bits de azul. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_A2R10G10B10_SNORM_PACK32:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_A2R10G10B10_SNORM_PACK32** = ``58``
Formato de datos de canal alfa/rojo/verde/azul de punto flotante con signo con valor normalizado, empaquetado en 32 bits. El formato contiene 2 bits de alfa, 10 bits de rojo, 10 bits de verde y 10 bits de azul. Los valores están en el rango ``[-1.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_A2R10G10B10_USCALED_PACK32:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_A2R10G10B10_USCALED_PACK32** = ``59``
Formato de datos de canal alfa/rojo/verde/azul de punto flotante sin signo con valor normalizado, empaquetado en 32 bits. El formato contiene 2 bits de alfa, 10 bits de rojo, 10 bits de verde y 10 bits de azul. Los valores están en el rango ``[0.0, 1023.0]`` para rojo/verde/azul y ``[0.0, 3.0]`` para alfa.
.. _class_RenderingDevice_constant_DATA_FORMAT_A2R10G10B10_SSCALED_PACK32:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_A2R10G10B10_SSCALED_PACK32** = ``60``
Formato de datos de canal alfa/rojo/verde/azul de punto flotante con signo y valor normalizado, empaquetado en 32 bits. El formato contiene 2 bits de alfa, 10 bits de rojo, 10 bits de verde y 10 bits de azul. Los valores están en el rango ``[-511.0, 511.0]`` para rojo/verde/azul y ``[-1.0, 1.0]`` para alfa.
.. _class_RenderingDevice_constant_DATA_FORMAT_A2R10G10B10_UINT_PACK32:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_A2R10G10B10_UINT_PACK32** = ``61``
Formato de datos de canal alfa/rojo/verde/azul de entero sin signo con valor normalizado, empaquetado en 32 bits. El formato contiene 2 bits de alfa, 10 bits de rojo, 10 bits de verde y 10 bits de azul. Los valores están en el rango ``[0, 1023]`` para rojo/verde/azul y ``[0, 3]`` para alfa.
.. _class_RenderingDevice_constant_DATA_FORMAT_A2R10G10B10_SINT_PACK32:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_A2R10G10B10_SINT_PACK32** = ``62``
Formato de datos de canal alfa/rojo/verde/azul de entero con signo con valor normalizado, empaquetado en 32 bits. El formato contiene 2 bits de alfa, 10 bits de rojo, 10 bits de verde y 10 bits de azul. Los valores están en el rango ``[-511, 511]`` para rojo/verde/azul y ``[-1, 1]`` para alfa.
.. _class_RenderingDevice_constant_DATA_FORMAT_A2B10G10R10_UNORM_PACK32:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_A2B10G10R10_UNORM_PACK32** = ``63``
Formato de datos de canal alfa/azul/verde/rojo de punto flotante sin signo con valor normalizado, empaquetado en 32 bits. El formato contiene 2 bits de alfa, 10 bits de azul, 10 bits de verde y 10 bits de rojo. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_A2B10G10R10_SNORM_PACK32:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_A2B10G10R10_SNORM_PACK32** = ``64``
Formato de datos de canal alfa/azul/verde/rojo de punto flotante con signo con valor normalizado, empaquetado en 32 bits. El formato contiene 2 bits de alfa, 10 bits de azul, 10 bits de verde y 10 bits de rojo. Los valores están en el rango ``[-1.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_A2B10G10R10_USCALED_PACK32:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_A2B10G10R10_USCALED_PACK32** = ``65``
Formato de datos de canal alfa/azul/verde/rojo de punto flotante sin signo con valor normalizado, empaquetado en 32 bits. El formato contiene 2 bits de alfa, 10 bits de azul, 10 bits de verde y 10 bits de rojo. Los valores están en el rango ``[0.0, 1023.0]`` para azul/verde/rojo y ``[0.0, 3.0]`` para alfa.
.. _class_RenderingDevice_constant_DATA_FORMAT_A2B10G10R10_SSCALED_PACK32:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_A2B10G10R10_SSCALED_PACK32** = ``66``
Formato de datos de canal alfa/azul/verde/rojo de punto flotante con signo con valor normalizado, empaquetado en 32 bits. El formato contiene 2 bits para alfa, 10 bits para azul, 10 bits para verde y 10 bits para rojo. Los valores están en el rango ``[-511.0, 511.0]`` para azul/verde/rojo y en el rango ``[-1.0, 1.0]`` para alfa.
.. _class_RenderingDevice_constant_DATA_FORMAT_A2B10G10R10_UINT_PACK32:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_A2B10G10R10_UINT_PACK32** = ``67``
Formato de datos de canal alfa/azul/verde/rojo entero sin signo con valor normalizado, empaquetado en 32 bits. El formato contiene 2 bits para alfa, 10 bits para azul, 10 bits para verde y 10 bits para rojo. Los valores están en el rango ``[0, 1023]`` para azul/verde/rojo y en el rango ``[0, 3]`` para alfa.
.. _class_RenderingDevice_constant_DATA_FORMAT_A2B10G10R10_SINT_PACK32:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_A2B10G10R10_SINT_PACK32** = ``68``
Formato de datos de canal alfa/azul/verde/rojo entero con signo con valor normalizado, empaquetado en 32 bits. El formato contiene 2 bits para alfa, 10 bits para azul, 10 bits para verde y 10 bits para rojo. Los valores están en el rango ``[-511, 511]`` para azul/verde/rojo y en el rango ``[-1, 1]`` para alfa.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16_UNORM** = ``69``
Formato de datos de canal rojo de punto flotante sin signo de 16 bits por canal con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16_SNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16_SNORM** = ``70``
Formato de datos de canal rojo de punto flotante con signo de 16 bits por canal con valor normalizado. Los valores están en el rango ``[-1.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16_USCALED:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16_USCALED** = ``71``
Formato de datos de canal rojo de punto flotante sin signo de 16 bits por canal con valor escalado (el valor se convierte de entero a flotante). Los valores están en el rango ``[0.0, 65535.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16_SSCALED:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16_SSCALED** = ``72``
Formato de datos de canal rojo de punto flotante con signo de 16 bits por canal con valor escalado (el valor se convierte de entero a flotante). Los valores están en el rango ``[-32767.0, 32767.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16_UINT** = ``73``
Formato de datos de canal rojo entero sin signo de 16 bits por canal. Los valores están en el rango ``[0.0, 65535]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16_SINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16_SINT** = ``74``
Formato de datos de canal rojo entero con signo de 16 bits por canal. Los valores están en el rango ``[-32767, 32767]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16_SFLOAT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16_SFLOAT** = ``75``
Formato de datos de canal rojo de punto flotante con signo de 16 bits por canal con el valor almacenado tal cual.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16_UNORM** = ``76``
Formato de datos de canal rojo/verde de punto flotante sin signo de 16 bits por canal con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16_SNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16_SNORM** = ``77``
Formato de datos de canal rojo/verde de punto flotante con signo de 16 bits por canal con valor normalizado. Los valores están en el rango ``[-1.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16_USCALED:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16_USCALED** = ``78``
Formato de datos de canal rojo/verde de punto flotante sin signo de 16 bits por canal con valor escalado (el valor se convierte de entero a flotante). Los valores están en el rango ``[0.0, 65535.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16_SSCALED:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16_SSCALED** = ``79``
Formato de datos de canal rojo/verde de punto flotante con signo de 16 bits por canal con valor escalado (el valor se convierte de entero a flotante). Los valores están en el rango ``[-32767.0, 32767.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16_UINT** = ``80``
Formato de datos de canal rojo/verde de entero sin signo de 16 bits por canal. Los valores están en el rango ``[0.0, 65535]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16_SINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16_SINT** = ``81``
Formato de datos de canal rojo/verde de entero con signo de 16 bits por canal. Los valores están en el rango ``[-32767, 32767]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16_SFLOAT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16_SFLOAT** = ``82``
Formato de datos de canal rojo/verde de punto flotante con signo de 16 bits por canal con el valor almacenado tal cual.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16B16_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16B16_UNORM** = ``83``
Formato de datos de canal rojo/verde/azul de punto flotante sin signo de 16 bits por canal con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16B16_SNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16B16_SNORM** = ``84``
Formato de datos de canal rojo/verde/azul de punto flotante con signo de 16 bits por canal con valor normalizado. Los valores están en el rango ``[-1.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16B16_USCALED:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16B16_USCALED** = ``85``
Formato de datos de canal rojo/verde/azul de punto flotante sin signo de 16 bits por canal con valor escalado (el valor se convierte de entero a flotante). Los valores están en el rango ``[0.0, 65535.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16B16_SSCALED:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16B16_SSCALED** = ``86``
Formato de datos de canal rojo/verde/azul de punto flotante con signo de 16 bits por canal con valor escalado (el valor se convierte de entero a flotante). Los valores están en el rango ``[-32767.0, 32767.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16B16_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16B16_UINT** = ``87``
Formato de datos de canal rojo/verde/azul de entero sin signo de 16 bits por canal. Los valores están en el rango ``[0.0, 65535]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16B16_SINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16B16_SINT** = ``88``
Formato de datos de canal rojo/verde/azul de entero con signo de 16 bits por canal. Los valores están en el rango ``[-32767, 32767]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16B16_SFLOAT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16B16_SFLOAT** = ``89``
Formato de datos de canal rojo/verde/azul de punto flotante con signo de 16 bits por canal con el valor almacenado tal cual.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16B16A16_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16B16A16_UNORM** = ``90``
Formato de datos de canal rojo/verde/azul/alfa de punto flotante sin signo de 16 bits por canal con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16B16A16_SNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16B16A16_SNORM** = ``91``
Formato de datos de canal rojo/verde/azul/alfa de punto flotante con signo de 16 bits por canal con valor normalizado. Los valores están en el rango ``[-1.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16B16A16_USCALED:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16B16A16_USCALED** = ``92``
Formato de datos de canal rojo/verde/azul/alfa de punto flotante sin signo de 16 bits por canal con valor escalado (el valor se convierte de entero a flotante). Los valores están en el rango ``[0.0, 65535.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16B16A16_SSCALED:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16B16A16_SSCALED** = ``93``
Formato de datos de canal rojo/verde/azul/alfa de punto flotante con signo de 16 bits por canal con valor escalado (el valor se convierte de entero a flotante). Los valores están en el rango ``[-32767.0, 32767.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16B16A16_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16B16A16_UINT** = ``94``
Formato de datos de canal rojo/verde/azul/alfa de entero sin signo de 16 bits por canal. Los valores están en el rango ``[0.0, 65535]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16B16A16_SINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16B16A16_SINT** = ``95``
Formato de datos de canal rojo/verde/azul/alfa de entero con signo de 16 bits por canal. Los valores están en el rango ``[-32767, 32767]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16B16A16_SFLOAT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16B16A16_SFLOAT** = ``96``
Formato de datos de canal rojo/verde/azul/alfa de punto flotante con signo de 16 bits por canal con el valor almacenado tal cual.
.. _class_RenderingDevice_constant_DATA_FORMAT_R32_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R32_UINT** = ``97``
Formato de datos de canal rojo de entero sin signo de 32 bits por canal. Los valores están en el rango ``[0, 2^32 - 1]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R32_SINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R32_SINT** = ``98``
Formato de datos de canal rojo de entero con signo de 32 bits por canal. Los valores están en el rango ``[2^31 + 1, 2^31 - 1]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R32_SFLOAT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R32_SFLOAT** = ``99``
Formato de datos de canal rojo de punto flotante con signo de 32 bits por canal con el valor almacenado tal cual.
.. _class_RenderingDevice_constant_DATA_FORMAT_R32G32_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R32G32_UINT** = ``100``
Formato de datos de canal rojo/verde de entero sin signo de 32 bits por canal. Los valores están en el rango ``[0, 2^32 - 1]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R32G32_SINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R32G32_SINT** = ``101``
Formato de datos de canal rojo/verde de entero con signo de 32 bits por canal. Los valores están en el rango ``[2^31 + 1, 2^31 - 1]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R32G32_SFLOAT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R32G32_SFLOAT** = ``102``
Formato de datos de canal rojo/verde de punto flotante con signo de 32 bits por canal con el valor almacenado tal cual.
.. _class_RenderingDevice_constant_DATA_FORMAT_R32G32B32_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R32G32B32_UINT** = ``103``
Formato de datos de canal rojo/verde/azul de entero sin signo de 32 bits por canal. Los valores están en el rango ``[0, 2^32 - 1]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R32G32B32_SINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R32G32B32_SINT** = ``104``
Formato de datos de canal rojo/verde/azul de entero con signo de 32 bits por canal. Los valores están en el rango ``[2^31 + 1, 2^31 - 1]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R32G32B32_SFLOAT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R32G32B32_SFLOAT** = ``105``
Formato de datos de canal rojo/verde/azul de punto flotante con signo de 32 bits por canal con el valor almacenado tal cual.
.. _class_RenderingDevice_constant_DATA_FORMAT_R32G32B32A32_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R32G32B32A32_UINT** = ``106``
Formato de datos de canal rojo/verde/azul/alfa de entero sin signo de 32 bits por canal. Los valores están en el rango ``[0, 2^32 - 1]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R32G32B32A32_SINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R32G32B32A32_SINT** = ``107``
Formato de datos de canal rojo/verde/azul/alfa de enteros con signo de 32 bits por canal. Los valores están en el rango ``[2^31 + 1, 2^31 - 1]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R32G32B32A32_SFLOAT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R32G32B32A32_SFLOAT** = ``108``
Formato de datos de canal rojo/verde/azul/alfa de punto flotante con signo de 32 bits por canal con el valor almacenado tal cual.
.. _class_RenderingDevice_constant_DATA_FORMAT_R64_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R64_UINT** = ``109``
Formato de datos de canal rojo de enteros sin signo de 64 bits por canal. Los valores están en el rango ``[0, 2^64 - 1]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R64_SINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R64_SINT** = ``110``
Formato de datos de canal rojo de enteros con signo de 64 bits por canal. Los valores están en el rango ``[2^63 + 1, 2^63 - 1]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R64_SFLOAT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R64_SFLOAT** = ``111``
Formato de datos de canal rojo de punto flotante con signo de 64 bits por canal con el valor almacenado tal cual.
.. _class_RenderingDevice_constant_DATA_FORMAT_R64G64_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R64G64_UINT** = ``112``
Formato de datos de canal rojo/verde de enteros sin signo de 64 bits por canal. Los valores están en el rango ``[0, 2^64 - 1]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R64G64_SINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R64G64_SINT** = ``113``
Formato de datos de canal rojo/verde de enteros con signo de 64 bits por canal. Los valores están en el rango ``[2^63 + 1, 2^63 - 1]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R64G64_SFLOAT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R64G64_SFLOAT** = ``114``
Formato de datos de canal rojo/verde de punto flotante con signo de 64 bits por canal con el valor almacenado tal cual.
.. _class_RenderingDevice_constant_DATA_FORMAT_R64G64B64_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R64G64B64_UINT** = ``115``
Formato de datos de canal rojo/verde/azul de enteros sin signo de 64 bits por canal. Los valores están en el rango ``[0, 2^64 - 1]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R64G64B64_SINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R64G64B64_SINT** = ``116``
Formato de datos de canal rojo/verde/azul de enteros con signo de 64 bits por canal. Los valores están en el rango ``[2^63 + 1, 2^63 - 1]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R64G64B64_SFLOAT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R64G64B64_SFLOAT** = ``117``
Formato de datos de canal rojo/verde/azul de punto flotante con signo de 64 bits por canal con el valor almacenado tal cual.
.. _class_RenderingDevice_constant_DATA_FORMAT_R64G64B64A64_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R64G64B64A64_UINT** = ``118``
Formato de datos de canal rojo/verde/azul/alfa de enteros sin signo de 64 bits por canal. Los valores están en el rango ``[0, 2^64 - 1]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R64G64B64A64_SINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R64G64B64A64_SINT** = ``119``
Formato de datos de canal rojo/verde/azul/alfa de enteros con signo de 64 bits por canal. Los valores están en el rango ``[2^63 + 1, 2^63 - 1]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R64G64B64A64_SFLOAT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R64G64B64A64_SFLOAT** = ``120``
Formato de datos de canal rojo/verde/azul/alfa de punto flotante con signo de 64 bits por canal con el valor almacenado tal cual.
.. _class_RenderingDevice_constant_DATA_FORMAT_B10G11R11_UFLOAT_PACK32:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_B10G11R11_UFLOAT_PACK32** = ``121``
Formato de datos azul/verde/rojo de punto flotante sin signo con el valor almacenado tal cual, empaquetado en 32 bits. La precisión del formato es de 10 bits de canal azul, 11 bits de canal verde y 11 bits de canal rojo.
.. _class_RenderingDevice_constant_DATA_FORMAT_E5B9G9R9_UFLOAT_PACK32:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_E5B9G9R9_UFLOAT_PACK32** = ``122``
Formato de datos de exposición/azul/verde/rojo de punto flotante sin signo con el valor almacenado tal cual, empaquetado en 32 bits. La precisión del formato es de 5 bits de exposición, 9 bits de canal azul, 9 bits de canal verde y 9 bits de canal rojo.
.. _class_RenderingDevice_constant_DATA_FORMAT_D16_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_D16_UNORM** = ``123``
Formato de datos de profundidad de punto flotante sin signo de 16 bits con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_X8_D24_UNORM_PACK32:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_X8_D24_UNORM_PACK32** = ``124``
Formato de datos de profundidad de punto flotante sin signo de 24 bits con valor normalizado, más 8 bits no utilizados, empaquetados en 32 bits. Los valores para la profundidad están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_D32_SFLOAT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_D32_SFLOAT** = ``125``
Formato de datos de profundidad de punto flotante con signo de 32 bits con el valor almacenado tal cual.
.. _class_RenderingDevice_constant_DATA_FORMAT_S8_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_S8_UINT** = ``126``
Formato de datos de plantilla de entero sin signo de 8 bits.
.. _class_RenderingDevice_constant_DATA_FORMAT_D16_UNORM_S8_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_D16_UNORM_S8_UINT** = ``127``
Formato de datos de profundidad de punto flotante sin signo de 16 bits con valor normalizado, más 8 bits de plantilla en formato de entero sin signo. Los valores para la profundidad están en el rango ``[0.0, 1.0]``. Los valores para la plantilla están en el rango ``[0, 255]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_D24_UNORM_S8_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_D24_UNORM_S8_UINT** = ``128``
Formato de datos de profundidad de punto flotante sin signo de 24 bits con valor normalizado, más 8 bits de plantilla en formato de entero sin signo. Los valores para la profundidad están en el rango ``[0.0, 1.0]``. Los valores para la plantilla están en el rango ``[0, 255]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_D32_SFLOAT_S8_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_D32_SFLOAT_S8_UINT** = ``129``
Formato de datos de profundidad de punto flotante con signo de 32 bits con el valor almacenado tal cual, más 8 bits de plantilla en formato de entero sin signo. Los valores para la plantilla están en el rango ``[0, 255]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_BC1_RGB_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_BC1_RGB_UNORM_BLOCK** = ``130``
Formato de datos de canal rojo/verde/azul sin signo comprimido en VRAM con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``. La precisión del formato es de 5 bits del canal rojo, 6 bits del canal verde y 5 bits del canal azul. Usando compresión de textura BC1 (también conocida como S3TC DXT1).
.. _class_RenderingDevice_constant_DATA_FORMAT_BC1_RGB_SRGB_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_BC1_RGB_SRGB_BLOCK** = ``131``
Formato de datos de canal rojo/verde/azul sin signo comprimido en VRAM con valor normalizado y codificación sRGB no lineal. Los valores están en el rango ``[0.0, 1.0]``. La precisión del formato es de 5 bits del canal rojo, 6 bits del canal verde y 5 bits del canal azul. Usando compresión de textura BC1 (también conocida como S3TC DXT1).
.. _class_RenderingDevice_constant_DATA_FORMAT_BC1_RGBA_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_BC1_RGBA_UNORM_BLOCK** = ``132``
Formato de datos de canal rojo/verde/azul/alfa sin signo comprimido en VRAM con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``. La precisión del formato es de 5 bits del canal rojo, 6 bits del canal verde, 5 bits del canal azul y 1 bit del canal alfa. Usando compresión de textura BC1 (también conocida como S3TC DXT1).
.. _class_RenderingDevice_constant_DATA_FORMAT_BC1_RGBA_SRGB_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_BC1_RGBA_SRGB_BLOCK** = ``133``
Formato de datos de canal rojo/verde/azul/alfa sin signo comprimido en VRAM con valor normalizado y codificación sRGB no lineal. Los valores están en el rango ``[0.0, 1.0]``. La precisión del formato es de 5 bits del canal rojo, 6 bits del canal verde, 5 bits del canal azul y 1 bit del canal alfa. Usando compresión de textura BC1 (también conocida como S3TC DXT1).
.. _class_RenderingDevice_constant_DATA_FORMAT_BC2_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_BC2_UNORM_BLOCK** = ``134``
Formato de datos de canal rojo/verde/azul/alfa sin signo comprimido en VRAM con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``. La precisión del formato es de 5 bits del canal rojo, 6 bits del canal verde, 5 bits del canal azul y 4 bits del canal alfa. Usando compresión de textura BC2 (también conocida como S3TC DXT3).
.. _class_RenderingDevice_constant_DATA_FORMAT_BC2_SRGB_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_BC2_SRGB_BLOCK** = ``135``
Formato de datos de canal rojo/verde/azul/alfa sin signo comprimido en VRAM con valor normalizado y codificación sRGB no lineal. Los valores están en el rango ``[0.0, 1.0]``. La precisión del formato es de 5 bits del canal rojo, 6 bits del canal verde, 5 bits del canal azul y 4 bits del canal alfa. Utiliza la compresión de texturas BC2 (también conocida como S3TC DXT3).
.. _class_RenderingDevice_constant_DATA_FORMAT_BC3_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_BC3_UNORM_BLOCK** = ``136``
Formato de datos de canal rojo/verde/azul/alfa sin signo comprimido en VRAM con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``. La precisión del formato es de 5 bits del canal rojo, 6 bits del canal verde, 5 bits del canal azul y 8 bits del canal alfa. Utiliza la compresión de texturas BC3 (también conocida como S3TC DXT5).
.. _class_RenderingDevice_constant_DATA_FORMAT_BC3_SRGB_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_BC3_SRGB_BLOCK** = ``137``
Formato de datos de canal rojo/verde/azul/alfa sin signo comprimido en VRAM con valor normalizado y codificación sRGB no lineal. Los valores están en el rango ``[0.0, 1.0]``. La precisión del formato es de 5 bits del canal rojo, 6 bits del canal verde, 5 bits del canal azul y 8 bits del canal alfa. Utiliza la compresión de texturas BC3 (también conocida como S3TC DXT5).
.. _class_RenderingDevice_constant_DATA_FORMAT_BC4_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_BC4_UNORM_BLOCK** = ``138``
Formato de datos de canal rojo sin signo comprimido en VRAM con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``. La precisión del formato es de 8 bits del canal rojo. Utiliza la compresión de texturas BC4.
.. _class_RenderingDevice_constant_DATA_FORMAT_BC4_SNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_BC4_SNORM_BLOCK** = ``139``
Formato de datos de canal rojo con signo comprimido en VRAM con valor normalizado. Los valores están en el rango ``[-1.0, 1.0]``. La precisión del formato es de 8 bits del canal rojo. Utiliza la compresión de texturas BC4.
.. _class_RenderingDevice_constant_DATA_FORMAT_BC5_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_BC5_UNORM_BLOCK** = ``140``
Formato de datos de canal rojo/verde sin signo comprimido en VRAM con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``. La precisión del formato es de 8 bits del canal rojo y 8 bits del canal verde. Utiliza la compresión de texturas BC5 (también conocida como S3TC RGTC).
.. _class_RenderingDevice_constant_DATA_FORMAT_BC5_SNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_BC5_SNORM_BLOCK** = ``141``
Formato de datos de canal rojo/verde con signo comprimido en VRAM con valor normalizado. Los valores están en el rango ``[-1.0, 1.0]``. La precisión del formato es de 8 bits del canal rojo y 8 bits del canal verde. Utiliza la compresión de texturas BC5 (también conocida como S3TC RGTC).
.. _class_RenderingDevice_constant_DATA_FORMAT_BC6H_UFLOAT_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_BC6H_UFLOAT_BLOCK** = ``142``
Formato de datos de canal rojo/verde/azul sin signo comprimido en VRAM con el valor de punto flotante almacenado tal cual. La precisión del formato está entre 10 y 13 bits para los canales rojo/verde/azul. Utiliza la compresión de texturas BC6H (también conocida como BPTC HDR).
.. _class_RenderingDevice_constant_DATA_FORMAT_BC6H_SFLOAT_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_BC6H_SFLOAT_BLOCK** = ``143``
Formato de datos de canal rojo/verde/azul con signo comprimido en VRAM con el valor de punto flotante almacenado tal cual. La precisión del formato está entre 10 y 13 bits para los canales rojo/verde/azul. Utiliza la compresión de texturas BC6H (también conocida como BPTC HDR).
.. _class_RenderingDevice_constant_DATA_FORMAT_BC7_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_BC7_UNORM_BLOCK** = ``144``
Formato de datos de canal rojo/verde/azul/alfa sin signo comprimido en VRAM con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``. La precisión del formato está entre 4 y 7 bits para los canales rojo/verde/azul y entre 0 y 8 bits para el canal alfa. También conocido como BPTC LDR.
.. _class_RenderingDevice_constant_DATA_FORMAT_BC7_SRGB_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_BC7_SRGB_BLOCK** = ``145``
Formato de datos de canal rojo/verde/azul/alfa sin signo comprimido en VRAM con valor normalizado y codificación sRGB no lineal. Los valores están en el rango ``[0.0, 1.0]``. La precisión del formato está entre 4 y 7 bits para los canales rojo/verde/azul y entre 0 y 8 bits para el canal alfa. También conocido como BPTC LDR.
.. _class_RenderingDevice_constant_DATA_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ETC2_R8G8B8_UNORM_BLOCK** = ``146``
Formato de datos de canal rojo/verde/azul sin signo comprimido en VRAM con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión de texturas ETC2.
.. _class_RenderingDevice_constant_DATA_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ETC2_R8G8B8_SRGB_BLOCK** = ``147``
Formato de datos de canal rojo/verde/azul sin signo comprimido en VRAM con valor normalizado y codificación sRGB no lineal. Los valores están en el rango ``[0.0, 1.0]``. Utiliza compresión de texturas ETC2.
.. _class_RenderingDevice_constant_DATA_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK** = ``148``
Formato de datos de canal rojo/verde/azul/alfa sin signo comprimido en VRAM con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``. Rojo/verde/azul utilizan 8 bits de precisión cada uno, con alfa utilizando 1 bit de precisión. Utiliza la compresión de texturas ETC2.
.. _class_RenderingDevice_constant_DATA_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK** = ``149``
Formato de datos de canal rojo/verde/azul/alfa sin signo comprimido en VRAM con valor normalizado y codificación sRGB no lineal. Los valores están en el rango ``[0.0, 1.0]``. Rojo/verde/azul utilizan 8 bits de precisión cada uno, con alfa utilizando 1 bit de precisión. Utiliza la compresión de texturas ETC2.
.. _class_RenderingDevice_constant_DATA_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK** = ``150``
Formato de datos de canal rojo/verde/azul/alfa sin signo comprimido en VRAM con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``. Rojo/verde/azul utilizan 8 bits de precisión cada uno, con alfa utilizando 8 bits de precisión. Utiliza la compresión de texturas ETC2.
.. _class_RenderingDevice_constant_DATA_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK** = ``151``
Formato de datos de canal rojo/verde/azul/alfa sin signo comprimido en VRAM con valor normalizado y codificación sRGB no lineal. Los valores están en el rango ``[0.0, 1.0]``. Rojo/verde/azul utilizan 8 bits de precisión cada uno, con alfa utilizando 8 bits de precisión. Utiliza la compresión de texturas ETC2.
.. _class_RenderingDevice_constant_DATA_FORMAT_EAC_R11_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_EAC_R11_UNORM_BLOCK** = ``152``
Formato de datos de canal rojo sin signo comprimido en VRAM de 11 bits con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión de texturas ETC2.
.. _class_RenderingDevice_constant_DATA_FORMAT_EAC_R11_SNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_EAC_R11_SNORM_BLOCK** = ``153``
Formato de datos de canal rojo con signo comprimido en VRAM de 11 bits con valor normalizado. Los valores están en el rango ``[-1.0, 1.0]``. Utiliza la compresión de texturas ETC2.
.. _class_RenderingDevice_constant_DATA_FORMAT_EAC_R11G11_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_EAC_R11G11_UNORM_BLOCK** = ``154``
Formato de datos de canal rojo/verde sin signo comprimido en VRAM de 11 bits con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión de texturas ETC2.
.. _class_RenderingDevice_constant_DATA_FORMAT_EAC_R11G11_SNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_EAC_R11G11_SNORM_BLOCK** = ``155``
Formato de datos de canal rojo/verde con signo comprimido en VRAM de 11 bits con valor normalizado. Los valores están en el rango ``[-1.0, 1.0]``. Utiliza la compresión de texturas ETC2.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_4x4_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_4x4_UNORM_BLOCK** = ``156``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado, empaquetado en bloques de 4×4 (máxima calidad). Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_4x4_SRGB_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_4x4_SRGB_BLOCK** = ``157``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado y codificación sRGB no lineal, empaquetado en bloques de 4×4 (máxima calidad). Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_5x4_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_5x4_UNORM_BLOCK** = ``158``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado, empaquetado en bloques de 5×4. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_5x4_SRGB_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_5x4_SRGB_BLOCK** = ``159``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado y codificación sRGB no lineal, empaquetado en bloques de 5×4. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_5x5_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_5x5_UNORM_BLOCK** = ``160``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado, empaquetado en bloques de 5×5. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_5x5_SRGB_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_5x5_SRGB_BLOCK** = ``161``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado y codificación sRGB no lineal, empaquetado en bloques de 5×5. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_6x5_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_6x5_UNORM_BLOCK** = ``162``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado, empaquetado en bloques de 6×5. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_6x5_SRGB_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_6x5_SRGB_BLOCK** = ``163``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado y codificación sRGB no lineal, empaquetado en bloques de 6×5. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_6x6_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_6x6_UNORM_BLOCK** = ``164``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado, empaquetado en bloques de 6×6. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_6x6_SRGB_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_6x6_SRGB_BLOCK** = ``165``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado y codificación sRGB no lineal, empaquetado en bloques de 6×6. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_8x5_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_8x5_UNORM_BLOCK** = ``166``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado, empaquetado en bloques de 8×5. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_8x5_SRGB_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_8x5_SRGB_BLOCK** = ``167``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado y codificación sRGB no lineal, empaquetado en bloques de 8×5. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_8x6_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_8x6_UNORM_BLOCK** = ``168``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado, empaquetado en bloques de 8×6. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_8x6_SRGB_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_8x6_SRGB_BLOCK** = ``169``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado y codificación sRGB no lineal, empaquetado en bloques de 8×6. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_8x8_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_8x8_UNORM_BLOCK** = ``170``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado, empaquetado en bloques de 8×8. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_8x8_SRGB_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_8x8_SRGB_BLOCK** = ``171``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado y codificación sRGB no lineal, empaquetado en bloques de 8×8. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_10x5_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_10x5_UNORM_BLOCK** = ``172``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado, empaquetado en bloques de 10×5. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_10x5_SRGB_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_10x5_SRGB_BLOCK** = ``173``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado y codificación sRGB no lineal, empaquetado en bloques de 10×5. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_10x6_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_10x6_UNORM_BLOCK** = ``174``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado, empaquetado en bloques de 10×6. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_10x6_SRGB_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_10x6_SRGB_BLOCK** = ``175``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado y codificación sRGB no lineal, empaquetado en bloques de 10×6. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_10x8_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_10x8_UNORM_BLOCK** = ``176``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado, empaquetado en bloques de 10×8. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_10x8_SRGB_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_10x8_SRGB_BLOCK** = ``177``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado y codificación sRGB no lineal, empaquetado en bloques de 10×8. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_10x10_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_10x10_UNORM_BLOCK** = ``178``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado, empaquetado en bloques de 10×10. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_10x10_SRGB_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_10x10_SRGB_BLOCK** = ``179``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado y codificación sRGB no lineal, empaquetado en bloques de 10×10. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_12x10_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_12x10_UNORM_BLOCK** = ``180``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado, empaquetado en bloques de 12×10. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_12x10_SRGB_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_12x10_SRGB_BLOCK** = ``181``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado y codificación sRGB no lineal, empaquetado en bloques de 12×10. Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_12x12_UNORM_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_12x12_UNORM_BLOCK** = ``182``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado, empaquetado en bloques de 12 (calidad más baja). Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_12x12_SRGB_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_12x12_SRGB_BLOCK** = ``183``
Formato de datos de punto flotante sin signo comprimido en VRAM con valor normalizado y codificación sRGB no lineal, empaquetado en bloques de 12 (calidad más baja). Los valores están en el rango ``[0.0, 1.0]``. Utiliza la compresión ASTC.
.. _class_RenderingDevice_constant_DATA_FORMAT_G8B8G8R8_422_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G8B8G8R8_422_UNORM** = ``184``
Formato de datos de canal verde/azul/rojo de punto flotante sin signo de 8 bits por canal con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal reducida a la mitad (es decir, 2 píxeles adyacentes horizontalmente compartirán el mismo valor para el canal azul/rojo).
.. _class_RenderingDevice_constant_DATA_FORMAT_B8G8R8G8_422_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_B8G8R8G8_422_UNORM** = ``185``
Formato de datos de canal azul/verde/rojo de punto flotante sin signo de 8 bits por canal con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal reducida a la mitad (es decir, 2 píxeles adyacentes horizontalmente compartirán el mismo valor para el canal azul/rojo).
.. _class_RenderingDevice_constant_DATA_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G8_B8_R8_3PLANE_420_UNORM** = ``186``
Datos de canal verde/azul/rojo en punto flotante sin signo de 8 bits por canal con valor normalizado, almacenados en 3 planos separados (verde + azul+ rojo). Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal y vertical reducida a la mitad (es decir, 2×2 píxeles adyacentes compartirán el mismo valor para el canal azul/rojo).
.. _class_RenderingDevice_constant_DATA_FORMAT_G8_B8R8_2PLANE_420_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G8_B8R8_2PLANE_420_UNORM** = ``187``
Datos de canal verde/azul/rojo en punto flotante sin signo de 8 bits por canal con valor normalizado, almacenados en 2 planos separados (verde + azul/rojo). Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal y vertical reducida a la mitad (es decir, 2×2 píxeles adyacentes compartirán el mismo valor para el canal azul/rojo).
.. _class_RenderingDevice_constant_DATA_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G8_B8_R8_3PLANE_422_UNORM** = ``188``
Datos de canal verde/azul/rojo en punto flotante sin signo de 8 bits por canal con valor normalizado, almacenados en 2 planos separados (verde + azul + rojo). Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal reducida a la mitad (es decir, 2 píxeles adyacentes horizontalmente compartirán el mismo valor para el canal azul/rojo).
.. _class_RenderingDevice_constant_DATA_FORMAT_G8_B8R8_2PLANE_422_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G8_B8R8_2PLANE_422_UNORM** = ``189``
Datos de canal verde/azul/rojo en punto flotante sin signo de 8 bits por canal con valor normalizado, almacenados en 2 planos separados (verde + azul/rojo). Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal reducida a la mitad (es decir, 2 píxeles adyacentes horizontalmente compartirán el mismo valor para el canal azul/rojo).
.. _class_RenderingDevice_constant_DATA_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G8_B8_R8_3PLANE_444_UNORM** = ``190``
Datos de canal verde/azul/rojo en punto flotante sin signo de 8 bits por canal con valor normalizado, almacenados en 3 planos separados. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R10X6_UNORM_PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R10X6_UNORM_PACK16** = ``191``
Datos de canal rojo en punto flotante sin signo de 10 bits por canal con valor normalizado, más 6 bits no utilizados, empaquetados en 16 bits. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R10X6G10X6_UNORM_2PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R10X6G10X6_UNORM_2PACK16** = ``192``
Datos de canal rojo/verde en punto flotante sin signo de 10 bits por canal con valor normalizado, más 6 bits no utilizados después de cada canal, empaquetados en 2×16 bits. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16** = ``193``
Datos de canal rojo/verde/azul/alfa en punto flotante sin signo de 10 bits por canal con valor normalizado, más 6 bits no utilizados después de cada canal, empaquetados en 4×16 bits. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16** = ``194``
Datos de canal verde/azul/verde/rojo en punto flotante sin signo de 10 bits por canal con valor normalizado, más 6 bits no utilizados después de cada canal, empaquetados en 4×16 bits. Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal reducida a la mitad (es decir, 2 píxeles adyacentes horizontalmente compartirán el mismo valor para el canal azul/rojo). El canal verde se enumera dos veces, pero contiene valores diferentes para permitir que se represente a resolución completa.
.. _class_RenderingDevice_constant_DATA_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16** = ``195``
Datos de canal azul/verde/rojo/verde en punto flotante sin signo de 10 bits por canal con valor normalizado, más 6 bits no utilizados después de cada canal, empaquetados en 4×16 bits. Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal reducida a la mitad (es decir, 2 píxeles adyacentes horizontalmente compartirán el mismo valor para el canal azul/rojo). El canal verde se enumera dos veces, pero contiene valores diferentes para permitir que se represente a resolución completa.
.. _class_RenderingDevice_constant_DATA_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16** = ``196``
Datos de canal verde/azul/rojo en punto flotante sin signo de 10 bits por canal con valor normalizado, más 6 bits no utilizados después de cada canal. Empaquetado en 3×16 bits y almacenado en 2 planos separados (verde + azul + rojo). Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal y vertical reducida a la mitad (es decir, 2×2 píxeles adyacentes compartirán el mismo valor para el canal azul/rojo).
.. _class_RenderingDevice_constant_DATA_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16** = ``197``
Datos de canal verde/azul/rojo en punto flotante sin signo de 10 bits por canal con valor normalizado, más 6 bits no utilizados después de cada canal. Empaquetado en 3×16 bits y almacenado en 2 planos separados (verde + azul/rojo). Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal y vertical reducida a la mitad (es decir, 2×2 píxeles adyacentes compartirán el mismo valor para el canal azul/rojo).
.. _class_RenderingDevice_constant_DATA_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16** = ``198``
Datos de canal verde/azul/rojo en punto flotante sin signo de 10 bits por canal con valor normalizado, más 6 bits no utilizados después de cada canal. Empaquetado en 3×16 bits y almacenado en 3 planos separados (verde + azul + rojo). Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal reducida a la mitad (es decir, 2 píxeles adyacentes horizontalmente compartirán el mismo valor para el canal azul/rojo).
.. _class_RenderingDevice_constant_DATA_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16** = ``199``
Datos de canal verde/azul/rojo en punto flotante sin signo de 10 bits por canal con valor normalizado, más 6 bits no utilizados después de cada canal. Empaquetado en 3×16 bits y almacenado en 3 planos separados (verde + azul/rojo). Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal reducida a la mitad (es decir, 2 píxeles adyacentes horizontalmente compartirán el mismo valor para el canal azul/rojo).
.. _class_RenderingDevice_constant_DATA_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16** = ``200``
Datos de canal verde/azul/rojo en punto flotante sin signo de 10 bits por canal con valor normalizado, más 6 bits no utilizados después de cada canal. Empaquetado en 3×16 bits y almacenado en 3 planos separados (verde + azul + rojo). Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R12X4_UNORM_PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R12X4_UNORM_PACK16** = ``201``
Datos de canal rojo en punto flotante sin signo de 12 bits por canal con valor normalizado, más 6 bits no utilizados, empaquetados en 16 bits. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R12X4G12X4_UNORM_2PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R12X4G12X4_UNORM_2PACK16** = ``202``
Datos de canal rojo/verde en punto flotante sin signo de 12 bits por canal con valor normalizado, más 6 bits no utilizados después de cada canal, empaquetados en 2×16 bits. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16** = ``203``
Datos de canal rojo/verde/azul/alfa en punto flotante sin signo de 12 bits por canal con valor normalizado, más 6 bits no utilizados después de cada canal, empaquetados en 4×16 bits. Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16** = ``204``
Datos de canal verde/azul/verde/rojo en punto flotante sin signo de 12 bits por canal con valor normalizado, más 6 bits no utilizados después de cada canal, empaquetados en 4×16 bits. Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal reducida a la mitad (es decir, 2 píxeles adyacentes horizontalmente compartirán el mismo valor para el canal azul/rojo). El canal verde se enumera dos veces, pero contiene valores diferentes para permitir que se represente a resolución completa.
.. _class_RenderingDevice_constant_DATA_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16** = ``205``
Datos de canal azul/verde/rojo/verde en punto flotante sin signo de 12 bits por canal con valor normalizado, más 6 bits no utilizados después de cada canal, empaquetados en 4×16 bits. Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal reducida a la mitad (es decir, 2 píxeles adyacentes horizontalmente compartirán el mismo valor para el canal azul/rojo). El canal verde se enumera dos veces, pero contiene valores diferentes para permitir que se represente a resolución completa.
.. _class_RenderingDevice_constant_DATA_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16** = ``206``
Datos de canal verde/azul/rojo en punto flotante sin signo de 12 bits por canal con valor normalizado, más 6 bits no utilizados después de cada canal. Empaquetado en 3×16 bits y almacenado en 2 planos separados (verde + azul + rojo). Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal y vertical reducida a la mitad (es decir, 2×2 píxeles adyacentes compartirán el mismo valor para el canal azul/rojo).
.. _class_RenderingDevice_constant_DATA_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16** = ``207``
Datos de canal verde/azul/rojo en punto flotante sin signo de 12 bits por canal con valor normalizado, más 6 bits no utilizados después de cada canal. Empaquetado en 3×16 bits y almacenado en 2 planos separados (verde + azul/rojo). Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal y vertical reducida a la mitad (es decir, 2×2 píxeles adyacentes compartirán el mismo valor para el canal azul/rojo).
.. _class_RenderingDevice_constant_DATA_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16** = ``208``
Datos de canal verde/azul/rojo en punto flotante sin signo de 12 bits por canal con valor normalizado, más 6 bits no utilizados después de cada canal. Empaquetado en 3×16 bits y almacenado en 3 planos separados (verde + azul + rojo). Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal reducida a la mitad (es decir, 2 píxeles adyacentes horizontalmente compartirán el mismo valor para el canal azul/rojo).
.. _class_RenderingDevice_constant_DATA_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16** = ``209``
Datos de canal verde/azul/rojo en punto flotante sin signo de 12 bits por canal con valor normalizado, más 6 bits no utilizados después de cada canal. Empaquetado en 3×16 bits y almacenado en 3 planos separados (verde + azul/rojo). Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal reducida a la mitad (es decir, 2 píxeles adyacentes horizontalmente compartirán el mismo valor para el canal azul/rojo).
.. _class_RenderingDevice_constant_DATA_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16** = ``210``
Datos de canal verde/azul/rojo en punto flotante sin signo de 12 bits por canal con valor normalizado, más 6 bits no utilizados después de cada canal. Empaquetado en 3×16 bits y almacenado en 3 planos separados (verde + azul + rojo). Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_G16B16G16R16_422_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G16B16G16R16_422_UNORM** = ``211``
Formato de datos de canal verde/azul/rojo de punto flotante sin signo de 16 bits por canal con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal reducida a la mitad (es decir, 2 píxeles adyacentes horizontalmente compartirán el mismo valor para el canal azul/rojo).
.. _class_RenderingDevice_constant_DATA_FORMAT_B16G16R16G16_422_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_B16G16R16G16_422_UNORM** = ``212``
Formato de datos de canal azul/verde/rojo de punto flotante sin signo de 16 bits por canal con valor normalizado. Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal reducida a la mitad (es decir, 2 píxeles adyacentes horizontalmente compartirán el mismo valor para el canal azul/rojo).
.. _class_RenderingDevice_constant_DATA_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G16_B16_R16_3PLANE_420_UNORM** = ``213``
Datos de canal verde/azul/rojo en punto flotante sin signo de 16 bits por canal con valor normalizado, más 6 bits no utilizados después de cada canal. Almacenado en 2 planos separados (verde + azul + rojo). Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal y vertical reducida a la mitad (es decir, 2×2 píxeles adyacentes compartirán el mismo valor para el canal azul/rojo).
.. _class_RenderingDevice_constant_DATA_FORMAT_G16_B16R16_2PLANE_420_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G16_B16R16_2PLANE_420_UNORM** = ``214``
Datos de canal verde/azul/rojo en punto flotante sin signo de 16 bits por canal con valor normalizado, más 6 bits no utilizados después de cada canal. Almacenado en 2 planos separados (verde + azul/rojo). Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal y vertical reducida a la mitad (es decir, 2×2 píxeles adyacentes compartirán el mismo valor para el canal azul/rojo).
.. _class_RenderingDevice_constant_DATA_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G16_B16_R16_3PLANE_422_UNORM** = ``215``
Datos de canal verde/azul/rojo en punto flotante sin signo de 16 bits por canal con valor normalizado, más 6 bits no utilizados después de cada canal. Almacenado en 3 planos separados (verde + azul + rojo). Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal reducida a la mitad (es decir, 2 píxeles adyacentes horizontalmente compartirán el mismo valor para el canal azul/rojo).
.. _class_RenderingDevice_constant_DATA_FORMAT_G16_B16R16_2PLANE_422_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G16_B16R16_2PLANE_422_UNORM** = ``216``
Datos de canal verde/azul/rojo en punto flotante sin signo de 16 bits por canal con valor normalizado, más 6 bits no utilizados después de cada canal. Almacenado en 3 planos separados (verde + azul/rojo). Los valores están en el rango ``[0.0, 1.0]``. Los datos de los canales azul y rojo se almacenan con una resolución horizontal reducida a la mitad (es decir, 2 píxeles adyacentes horizontalmente compartirán el mismo valor para el canal azul/rojo).
.. _class_RenderingDevice_constant_DATA_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_G16_B16_R16_3PLANE_444_UNORM** = ``217``
Datos de canal verde/azul/rojo en punto flotante sin signo de 16 bits por canal con valor normalizado, más 6 bits no utilizados después de cada canal. Almacenado en 3 planos separados (verde + azul + rojo). Los valores están en el rango ``[0.0, 1.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_4x4_SFLOAT_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_4x4_SFLOAT_BLOCK** = ``218``
.. container:: contribute
There is currently no description for this enum. Please help us by `contributing one <https://contributing.godotengine.org/en/latest/documentation/class_reference.html>`__!
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_5x4_SFLOAT_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_5x4_SFLOAT_BLOCK** = ``219``
.. container:: contribute
There is currently no description for this enum. Please help us by `contributing one <https://contributing.godotengine.org/en/latest/documentation/class_reference.html>`__!
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_5x5_SFLOAT_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_5x5_SFLOAT_BLOCK** = ``220``
.. container:: contribute
There is currently no description for this enum. Please help us by `contributing one <https://contributing.godotengine.org/en/latest/documentation/class_reference.html>`__!
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_6x5_SFLOAT_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_6x5_SFLOAT_BLOCK** = ``221``
.. container:: contribute
There is currently no description for this enum. Please help us by `contributing one <https://contributing.godotengine.org/en/latest/documentation/class_reference.html>`__!
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_6x6_SFLOAT_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_6x6_SFLOAT_BLOCK** = ``222``
.. container:: contribute
There is currently no description for this enum. Please help us by `contributing one <https://contributing.godotengine.org/en/latest/documentation/class_reference.html>`__!
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_8x5_SFLOAT_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_8x5_SFLOAT_BLOCK** = ``223``
.. container:: contribute
There is currently no description for this enum. Please help us by `contributing one <https://contributing.godotengine.org/en/latest/documentation/class_reference.html>`__!
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_8x6_SFLOAT_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_8x6_SFLOAT_BLOCK** = ``224``
.. container:: contribute
There is currently no description for this enum. Please help us by `contributing one <https://contributing.godotengine.org/en/latest/documentation/class_reference.html>`__!
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_8x8_SFLOAT_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_8x8_SFLOAT_BLOCK** = ``225``
.. container:: contribute
There is currently no description for this enum. Please help us by `contributing one <https://contributing.godotengine.org/en/latest/documentation/class_reference.html>`__!
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_10x5_SFLOAT_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_10x5_SFLOAT_BLOCK** = ``226``
.. container:: contribute
There is currently no description for this enum. Please help us by `contributing one <https://contributing.godotengine.org/en/latest/documentation/class_reference.html>`__!
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_10x6_SFLOAT_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_10x6_SFLOAT_BLOCK** = ``227``
.. container:: contribute
There is currently no description for this enum. Please help us by `contributing one <https://contributing.godotengine.org/en/latest/documentation/class_reference.html>`__!
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_10x8_SFLOAT_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_10x8_SFLOAT_BLOCK** = ``228``
.. container:: contribute
There is currently no description for this enum. Please help us by `contributing one <https://contributing.godotengine.org/en/latest/documentation/class_reference.html>`__!
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_10x10_SFLOAT_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_10x10_SFLOAT_BLOCK** = ``229``
.. container:: contribute
There is currently no description for this enum. Please help us by `contributing one <https://contributing.godotengine.org/en/latest/documentation/class_reference.html>`__!
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_12x10_SFLOAT_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_12x10_SFLOAT_BLOCK** = ``230``
.. container:: contribute
There is currently no description for this enum. Please help us by `contributing one <https://contributing.godotengine.org/en/latest/documentation/class_reference.html>`__!
.. _class_RenderingDevice_constant_DATA_FORMAT_ASTC_12x12_SFLOAT_BLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_ASTC_12x12_SFLOAT_BLOCK** = ``231``
.. container:: contribute
There is currently no description for this enum. Please help us by `contributing one <https://contributing.godotengine.org/en/latest/documentation/class_reference.html>`__!
.. _class_RenderingDevice_constant_DATA_FORMAT_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_MAX** = ``232``
Representa el tamaño del enum :ref:`DataFormat<enum_RenderingDevice_DataFormat>`.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_BarrierMask:
.. rst-class:: classref-enumeration
flags **BarrierMask**: :ref:`🔗<enum_RenderingDevice_BarrierMask>`
.. _class_RenderingDevice_constant_BARRIER_MASK_VERTEX:
.. rst-class:: classref-enumeration-constant
:ref:`BarrierMask<enum_RenderingDevice_BarrierMask>` **BARRIER_MASK_VERTEX** = ``1``
Vertex shader barrier mask.
.. _class_RenderingDevice_constant_BARRIER_MASK_FRAGMENT:
.. rst-class:: classref-enumeration-constant
:ref:`BarrierMask<enum_RenderingDevice_BarrierMask>` **BARRIER_MASK_FRAGMENT** = ``8``
Fragment shader barrier mask.
.. _class_RenderingDevice_constant_BARRIER_MASK_COMPUTE:
.. rst-class:: classref-enumeration-constant
:ref:`BarrierMask<enum_RenderingDevice_BarrierMask>` **BARRIER_MASK_COMPUTE** = ``2``
Compute barrier mask.
.. _class_RenderingDevice_constant_BARRIER_MASK_TRANSFER:
.. rst-class:: classref-enumeration-constant
:ref:`BarrierMask<enum_RenderingDevice_BarrierMask>` **BARRIER_MASK_TRANSFER** = ``4``
Transfer barrier mask.
.. _class_RenderingDevice_constant_BARRIER_MASK_RASTER:
.. rst-class:: classref-enumeration-constant
:ref:`BarrierMask<enum_RenderingDevice_BarrierMask>` **BARRIER_MASK_RASTER** = ``9``
Raster barrier mask (vertex and fragment). Equivalent to ``BARRIER_MASK_VERTEX | BARRIER_MASK_FRAGMENT``.
.. _class_RenderingDevice_constant_BARRIER_MASK_ALL_BARRIERS:
.. rst-class:: classref-enumeration-constant
:ref:`BarrierMask<enum_RenderingDevice_BarrierMask>` **BARRIER_MASK_ALL_BARRIERS** = ``32767``
Barrier mask for all types (vertex, fragment, compute, transfer).
.. _class_RenderingDevice_constant_BARRIER_MASK_NO_BARRIER:
.. rst-class:: classref-enumeration-constant
:ref:`BarrierMask<enum_RenderingDevice_BarrierMask>` **BARRIER_MASK_NO_BARRIER** = ``32768``
No barrier for any type.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_TextureType:
.. rst-class:: classref-enumeration
enum **TextureType**: :ref:`🔗<enum_RenderingDevice_TextureType>`
.. _class_RenderingDevice_constant_TEXTURE_TYPE_1D:
.. rst-class:: classref-enumeration-constant
:ref:`TextureType<enum_RenderingDevice_TextureType>` **TEXTURE_TYPE_1D** = ``0``
Textura unidimensional.
.. _class_RenderingDevice_constant_TEXTURE_TYPE_2D:
.. rst-class:: classref-enumeration-constant
:ref:`TextureType<enum_RenderingDevice_TextureType>` **TEXTURE_TYPE_2D** = ``1``
Textura bidimensional.
.. _class_RenderingDevice_constant_TEXTURE_TYPE_3D:
.. rst-class:: classref-enumeration-constant
:ref:`TextureType<enum_RenderingDevice_TextureType>` **TEXTURE_TYPE_3D** = ``2``
Textura tridimensional.
.. _class_RenderingDevice_constant_TEXTURE_TYPE_CUBE:
.. rst-class:: classref-enumeration-constant
:ref:`TextureType<enum_RenderingDevice_TextureType>` **TEXTURE_TYPE_CUBE** = ``3``
Textura del :ref:`Cubemap<class_Cubemap>`.
.. _class_RenderingDevice_constant_TEXTURE_TYPE_1D_ARRAY:
.. rst-class:: classref-enumeration-constant
:ref:`TextureType<enum_RenderingDevice_TextureType>` **TEXTURE_TYPE_1D_ARRAY** = ``4``
Arreglo de texturas unidimensionales.
.. _class_RenderingDevice_constant_TEXTURE_TYPE_2D_ARRAY:
.. rst-class:: classref-enumeration-constant
:ref:`TextureType<enum_RenderingDevice_TextureType>` **TEXTURE_TYPE_2D_ARRAY** = ``5``
Arreglo de texturas bidimensionales.
.. _class_RenderingDevice_constant_TEXTURE_TYPE_CUBE_ARRAY:
.. rst-class:: classref-enumeration-constant
:ref:`TextureType<enum_RenderingDevice_TextureType>` **TEXTURE_TYPE_CUBE_ARRAY** = ``6``
Array of :ref:`Cubemap<class_Cubemap>` textures.
.. _class_RenderingDevice_constant_TEXTURE_TYPE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`TextureType<enum_RenderingDevice_TextureType>` **TEXTURE_TYPE_MAX** = ``7``
Representa el tamaño del enum :ref:`TextureType<enum_RenderingDevice_TextureType>`.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_TextureSamples:
.. rst-class:: classref-enumeration
enum **TextureSamples**: :ref:`🔗<enum_RenderingDevice_TextureSamples>`
.. _class_RenderingDevice_constant_TEXTURE_SAMPLES_1:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSamples<enum_RenderingDevice_TextureSamples>` **TEXTURE_SAMPLES_1** = ``0``
Realiza 1 muestreo de textura (este es el más rápido pero de menor calidad para el suavizado).
.. _class_RenderingDevice_constant_TEXTURE_SAMPLES_2:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSamples<enum_RenderingDevice_TextureSamples>` **TEXTURE_SAMPLES_2** = ``1``
Realiza 2 muestreos de textura.
.. _class_RenderingDevice_constant_TEXTURE_SAMPLES_4:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSamples<enum_RenderingDevice_TextureSamples>` **TEXTURE_SAMPLES_4** = ``2``
Realiza 4 muestreos de textura.
.. _class_RenderingDevice_constant_TEXTURE_SAMPLES_8:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSamples<enum_RenderingDevice_TextureSamples>` **TEXTURE_SAMPLES_8** = ``3``
Realiza 8 muestreos de textura. No compatible con GPUs móviles (incluyendo Apple Silicon).
.. _class_RenderingDevice_constant_TEXTURE_SAMPLES_16:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSamples<enum_RenderingDevice_TextureSamples>` **TEXTURE_SAMPLES_16** = ``4``
Realiza 16 muestreos de textura. No compatible con GPUs móviles y muchas GPUs de escritorio.
.. _class_RenderingDevice_constant_TEXTURE_SAMPLES_32:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSamples<enum_RenderingDevice_TextureSamples>` **TEXTURE_SAMPLES_32** = ``5``
Realiza 32 muestreos de textura. No compatible con la mayoría de las GPUs.
.. _class_RenderingDevice_constant_TEXTURE_SAMPLES_64:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSamples<enum_RenderingDevice_TextureSamples>` **TEXTURE_SAMPLES_64** = ``6``
Realiza 64 muestreos de textura (este es el más lento pero de mayor calidad para el suavizado). No compatible con la mayoría de las GPUs.
.. _class_RenderingDevice_constant_TEXTURE_SAMPLES_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSamples<enum_RenderingDevice_TextureSamples>` **TEXTURE_SAMPLES_MAX** = ``7``
Representa el tamaño del enum :ref:`TextureSamples<enum_RenderingDevice_TextureSamples>`.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_TextureUsageBits:
.. rst-class:: classref-enumeration
flags **TextureUsageBits**: :ref:`🔗<enum_RenderingDevice_TextureUsageBits>`
.. _class_RenderingDevice_constant_TEXTURE_USAGE_SAMPLING_BIT:
.. rst-class:: classref-enumeration-constant
:ref:`TextureUsageBits<enum_RenderingDevice_TextureUsageBits>` **TEXTURE_USAGE_SAMPLING_BIT** = ``1``
La textura se puede muestrear.
.. _class_RenderingDevice_constant_TEXTURE_USAGE_COLOR_ATTACHMENT_BIT:
.. rst-class:: classref-enumeration-constant
:ref:`TextureUsageBits<enum_RenderingDevice_TextureUsageBits>` **TEXTURE_USAGE_COLOR_ATTACHMENT_BIT** = ``2``
Texture can be used as a color attachment in a framebuffer.
.. _class_RenderingDevice_constant_TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT:
.. rst-class:: classref-enumeration-constant
:ref:`TextureUsageBits<enum_RenderingDevice_TextureUsageBits>` **TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT** = ``4``
Texture can be used as a depth/stencil attachment in a framebuffer.
.. _class_RenderingDevice_constant_TEXTURE_USAGE_STORAGE_BIT:
.. rst-class:: classref-enumeration-constant
:ref:`TextureUsageBits<enum_RenderingDevice_TextureUsageBits>` **TEXTURE_USAGE_STORAGE_BIT** = ``8``
La textura se puede usar como una `imagen de almacenamiento <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#descriptorsets-storageimage>`__.
.. _class_RenderingDevice_constant_TEXTURE_USAGE_STORAGE_ATOMIC_BIT:
.. rst-class:: classref-enumeration-constant
:ref:`TextureUsageBits<enum_RenderingDevice_TextureUsageBits>` **TEXTURE_USAGE_STORAGE_ATOMIC_BIT** = ``16``
La textura se puede usar como una `imagen de almacenamiento <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#descriptorsets-storageimage>`__ con soporte para operaciones atómicas.
.. _class_RenderingDevice_constant_TEXTURE_USAGE_CPU_READ_BIT:
.. rst-class:: classref-enumeration-constant
:ref:`TextureUsageBits<enum_RenderingDevice_TextureUsageBits>` **TEXTURE_USAGE_CPU_READ_BIT** = ``32``
La textura se puede leer de nuevo en la CPU usando :ref:`texture_get_data()<class_RenderingDevice_method_texture_get_data>` más rápido que sin este bit, ya que siempre se mantiene en la memoria del sistema.
.. _class_RenderingDevice_constant_TEXTURE_USAGE_CAN_UPDATE_BIT:
.. rst-class:: classref-enumeration-constant
:ref:`TextureUsageBits<enum_RenderingDevice_TextureUsageBits>` **TEXTURE_USAGE_CAN_UPDATE_BIT** = ``64``
La textura se puede actualizar usando :ref:`texture_update()<class_RenderingDevice_method_texture_update>`.
.. _class_RenderingDevice_constant_TEXTURE_USAGE_CAN_COPY_FROM_BIT:
.. rst-class:: classref-enumeration-constant
:ref:`TextureUsageBits<enum_RenderingDevice_TextureUsageBits>` **TEXTURE_USAGE_CAN_COPY_FROM_BIT** = ``128``
La textura puede ser una fuente para :ref:`texture_copy()<class_RenderingDevice_method_texture_copy>`.
.. _class_RenderingDevice_constant_TEXTURE_USAGE_CAN_COPY_TO_BIT:
.. rst-class:: classref-enumeration-constant
:ref:`TextureUsageBits<enum_RenderingDevice_TextureUsageBits>` **TEXTURE_USAGE_CAN_COPY_TO_BIT** = ``256``
La textura puede ser un destino para :ref:`texture_copy()<class_RenderingDevice_method_texture_copy>`.
.. _class_RenderingDevice_constant_TEXTURE_USAGE_INPUT_ATTACHMENT_BIT:
.. rst-class:: classref-enumeration-constant
:ref:`TextureUsageBits<enum_RenderingDevice_TextureUsageBits>` **TEXTURE_USAGE_INPUT_ATTACHMENT_BIT** = ``512``
Texture can be used as a `input attachment <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#descriptorsets-inputattachment>`__ in a framebuffer.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_TextureSwizzle:
.. rst-class:: classref-enumeration
enum **TextureSwizzle**: :ref:`🔗<enum_RenderingDevice_TextureSwizzle>`
.. _class_RenderingDevice_constant_TEXTURE_SWIZZLE_IDENTITY:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSwizzle<enum_RenderingDevice_TextureSwizzle>` **TEXTURE_SWIZZLE_IDENTITY** = ``0``
Devuelve el valor muestreado tal cual.
.. _class_RenderingDevice_constant_TEXTURE_SWIZZLE_ZERO:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSwizzle<enum_RenderingDevice_TextureSwizzle>` **TEXTURE_SWIZZLE_ZERO** = ``1``
Siempre devuelve ``0.0`` al muestrear.
.. _class_RenderingDevice_constant_TEXTURE_SWIZZLE_ONE:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSwizzle<enum_RenderingDevice_TextureSwizzle>` **TEXTURE_SWIZZLE_ONE** = ``2``
Siempre devuelve ``1.0`` al muestrear.
.. _class_RenderingDevice_constant_TEXTURE_SWIZZLE_R:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSwizzle<enum_RenderingDevice_TextureSwizzle>` **TEXTURE_SWIZZLE_R** = ``3``
Muestrea el canal de color rojo.
.. _class_RenderingDevice_constant_TEXTURE_SWIZZLE_G:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSwizzle<enum_RenderingDevice_TextureSwizzle>` **TEXTURE_SWIZZLE_G** = ``4``
Muestrea el canal de color verde.
.. _class_RenderingDevice_constant_TEXTURE_SWIZZLE_B:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSwizzle<enum_RenderingDevice_TextureSwizzle>` **TEXTURE_SWIZZLE_B** = ``5``
Muestrea el canal de color azul.
.. _class_RenderingDevice_constant_TEXTURE_SWIZZLE_A:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSwizzle<enum_RenderingDevice_TextureSwizzle>` **TEXTURE_SWIZZLE_A** = ``6``
Muestrea el canal alfa.
.. _class_RenderingDevice_constant_TEXTURE_SWIZZLE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSwizzle<enum_RenderingDevice_TextureSwizzle>` **TEXTURE_SWIZZLE_MAX** = ``7``
Representa el tamaño del enum :ref:`TextureSwizzle<enum_RenderingDevice_TextureSwizzle>`.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_TextureSliceType:
.. rst-class:: classref-enumeration
enum **TextureSliceType**: :ref:`🔗<enum_RenderingDevice_TextureSliceType>`
.. _class_RenderingDevice_constant_TEXTURE_SLICE_2D:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSliceType<enum_RenderingDevice_TextureSliceType>` **TEXTURE_SLICE_2D** = ``0``
Capa de textura bidimensional.
.. _class_RenderingDevice_constant_TEXTURE_SLICE_CUBEMAP:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSliceType<enum_RenderingDevice_TextureSliceType>` **TEXTURE_SLICE_CUBEMAP** = ``1``
Capa de textura cubemap.
.. _class_RenderingDevice_constant_TEXTURE_SLICE_3D:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSliceType<enum_RenderingDevice_TextureSliceType>` **TEXTURE_SLICE_3D** = ``2``
Capa de textura tridimensional.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_SamplerFilter:
.. rst-class:: classref-enumeration
enum **SamplerFilter**: :ref:`🔗<enum_RenderingDevice_SamplerFilter>`
.. _class_RenderingDevice_constant_SAMPLER_FILTER_NEAREST:
.. rst-class:: classref-enumeration-constant
:ref:`SamplerFilter<enum_RenderingDevice_SamplerFilter>` **SAMPLER_FILTER_NEAREST** = ``0``
Filtro de muestreador de vecino más cercano. El muestreo a resoluciones más altas que la original resultará en una apariencia pixelada.
.. _class_RenderingDevice_constant_SAMPLER_FILTER_LINEAR:
.. rst-class:: classref-enumeration-constant
:ref:`SamplerFilter<enum_RenderingDevice_SamplerFilter>` **SAMPLER_FILTER_LINEAR** = ``1``
Filtro de muestreador bilineal. El muestreo a resoluciones más altas que la original resultará en una apariencia borrosa.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_SamplerRepeatMode:
.. rst-class:: classref-enumeration
enum **SamplerRepeatMode**: :ref:`🔗<enum_RenderingDevice_SamplerRepeatMode>`
.. _class_RenderingDevice_constant_SAMPLER_REPEAT_MODE_REPEAT:
.. rst-class:: classref-enumeration-constant
:ref:`SamplerRepeatMode<enum_RenderingDevice_SamplerRepeatMode>` **SAMPLER_REPEAT_MODE_REPEAT** = ``0``
Muestreo con repetición habilitada.
.. _class_RenderingDevice_constant_SAMPLER_REPEAT_MODE_MIRRORED_REPEAT:
.. rst-class:: classref-enumeration-constant
:ref:`SamplerRepeatMode<enum_RenderingDevice_SamplerRepeatMode>` **SAMPLER_REPEAT_MODE_MIRRORED_REPEAT** = ``1``
Muestreo con repetición reflejada habilitada. Al muestrear fuera del rango ``[0.0, 1.0]``, devuelve una versión reflejada del muestreador. Esta versión reflejada se refleja de nuevo si se muestrea más lejos, con el patrón repitiéndose indefinidamente.
.. _class_RenderingDevice_constant_SAMPLER_REPEAT_MODE_CLAMP_TO_EDGE:
.. rst-class:: classref-enumeration-constant
:ref:`SamplerRepeatMode<enum_RenderingDevice_SamplerRepeatMode>` **SAMPLER_REPEAT_MODE_CLAMP_TO_EDGE** = ``2``
Muestreo con repetición deshabilitada. Al muestrear fuera del rango ``[0.0, 1.0]``, devuelve el color del último píxel en el borde.
.. _class_RenderingDevice_constant_SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER:
.. rst-class:: classref-enumeration-constant
:ref:`SamplerRepeatMode<enum_RenderingDevice_SamplerRepeatMode>` **SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER** = ``3``
Muestreo con repetición deshabilitada. Al muestrear fuera del rango ``[0.0, 1.0]``, devuelve el color especificado en :ref:`RDSamplerState.border_color<class_RDSamplerState_property_border_color>`.
.. _class_RenderingDevice_constant_SAMPLER_REPEAT_MODE_MIRROR_CLAMP_TO_EDGE:
.. rst-class:: classref-enumeration-constant
:ref:`SamplerRepeatMode<enum_RenderingDevice_SamplerRepeatMode>` **SAMPLER_REPEAT_MODE_MIRROR_CLAMP_TO_EDGE** = ``4``
Muestreo con repetición reflejada habilitada, pero solo una vez. Al muestrear en el rango ``[-1.0, 0.0]``, devuelve una versión reflejada del muestreador. Al muestrear fuera del rango ``[-1.0, 1.0]``, devuelve el color del último píxel en el borde.
.. _class_RenderingDevice_constant_SAMPLER_REPEAT_MODE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`SamplerRepeatMode<enum_RenderingDevice_SamplerRepeatMode>` **SAMPLER_REPEAT_MODE_MAX** = ``5``
Representa el tamaño del enum :ref:`SamplerRepeatMode<enum_RenderingDevice_SamplerRepeatMode>`.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_SamplerBorderColor:
.. rst-class:: classref-enumeration
enum **SamplerBorderColor**: :ref:`🔗<enum_RenderingDevice_SamplerBorderColor>`
.. _class_RenderingDevice_constant_SAMPLER_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK:
.. rst-class:: classref-enumeration-constant
:ref:`SamplerBorderColor<enum_RenderingDevice_SamplerBorderColor>` **SAMPLER_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK** = ``0``
Devuelve un color negro transparente de punto flotante al muestrear fuera del rango ``[0.0, 1.0]``. Solo es efectivo si el modo de repetición del muestreador es :ref:`SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER<class_RenderingDevice_constant_SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER>`.
.. _class_RenderingDevice_constant_SAMPLER_BORDER_COLOR_INT_TRANSPARENT_BLACK:
.. rst-class:: classref-enumeration-constant
:ref:`SamplerBorderColor<enum_RenderingDevice_SamplerBorderColor>` **SAMPLER_BORDER_COLOR_INT_TRANSPARENT_BLACK** = ``1``
Return an integer transparent black color when sampling outside the ``[0.0, 1.0]`` range. Only effective if the sampler repeat mode is :ref:`SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER<class_RenderingDevice_constant_SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER>`.
.. _class_RenderingDevice_constant_SAMPLER_BORDER_COLOR_FLOAT_OPAQUE_BLACK:
.. rst-class:: classref-enumeration-constant
:ref:`SamplerBorderColor<enum_RenderingDevice_SamplerBorderColor>` **SAMPLER_BORDER_COLOR_FLOAT_OPAQUE_BLACK** = ``2``
Devuelve un color negro opaco de punto flotante al muestrear fuera del rango ``[0.0, 1.0]``. Solo es efectivo si el modo de repetición del muestreador es :ref:`SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER<class_RenderingDevice_constant_SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER>`.
.. _class_RenderingDevice_constant_SAMPLER_BORDER_COLOR_INT_OPAQUE_BLACK:
.. rst-class:: classref-enumeration-constant
:ref:`SamplerBorderColor<enum_RenderingDevice_SamplerBorderColor>` **SAMPLER_BORDER_COLOR_INT_OPAQUE_BLACK** = ``3``
Return an integer opaque black color when sampling outside the ``[0.0, 1.0]`` range. Only effective if the sampler repeat mode is :ref:`SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER<class_RenderingDevice_constant_SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER>`.
.. _class_RenderingDevice_constant_SAMPLER_BORDER_COLOR_FLOAT_OPAQUE_WHITE:
.. rst-class:: classref-enumeration-constant
:ref:`SamplerBorderColor<enum_RenderingDevice_SamplerBorderColor>` **SAMPLER_BORDER_COLOR_FLOAT_OPAQUE_WHITE** = ``4``
Devuelve un color blanco opaco de punto flotante al muestrear fuera del rango ``[0.0, 1.0]``. Solo es efectivo si el modo de repetición del muestreador es :ref:`SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER<class_RenderingDevice_constant_SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER>`.
.. _class_RenderingDevice_constant_SAMPLER_BORDER_COLOR_INT_OPAQUE_WHITE:
.. rst-class:: classref-enumeration-constant
:ref:`SamplerBorderColor<enum_RenderingDevice_SamplerBorderColor>` **SAMPLER_BORDER_COLOR_INT_OPAQUE_WHITE** = ``5``
Return an integer opaque white color when sampling outside the ``[0.0, 1.0]`` range. Only effective if the sampler repeat mode is :ref:`SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER<class_RenderingDevice_constant_SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER>`.
.. _class_RenderingDevice_constant_SAMPLER_BORDER_COLOR_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`SamplerBorderColor<enum_RenderingDevice_SamplerBorderColor>` **SAMPLER_BORDER_COLOR_MAX** = ``6``
Representa el tamaño del enum :ref:`SamplerBorderColor<enum_RenderingDevice_SamplerBorderColor>`.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_VertexFrequency:
.. rst-class:: classref-enumeration
enum **VertexFrequency**: :ref:`🔗<enum_RenderingDevice_VertexFrequency>`
.. _class_RenderingDevice_constant_VERTEX_FREQUENCY_VERTEX:
.. rst-class:: classref-enumeration-constant
:ref:`VertexFrequency<enum_RenderingDevice_VertexFrequency>` **VERTEX_FREQUENCY_VERTEX** = ``0``
El direccionamiento de los atributos de vértice es una función del vértice. Esto se utiliza para especificar la velocidad a la que se extraen los atributos de vértice de los búferes.
.. _class_RenderingDevice_constant_VERTEX_FREQUENCY_INSTANCE:
.. rst-class:: classref-enumeration-constant
:ref:`VertexFrequency<enum_RenderingDevice_VertexFrequency>` **VERTEX_FREQUENCY_INSTANCE** = ``1``
El direccionamiento de los atributos de vértice es una función del índice de la instancia. Esto se utiliza para especificar la velocidad a la que se extraen los atributos de vértice de los búferes.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_IndexBufferFormat:
.. rst-class:: classref-enumeration
enum **IndexBufferFormat**: :ref:`🔗<enum_RenderingDevice_IndexBufferFormat>`
.. _class_RenderingDevice_constant_INDEX_BUFFER_FORMAT_UINT16:
.. rst-class:: classref-enumeration-constant
:ref:`IndexBufferFormat<enum_RenderingDevice_IndexBufferFormat>` **INDEX_BUFFER_FORMAT_UINT16** = ``0``
Búfer de índices en formato de entero sin signo de 16 bits. Esto limita el índice máximo que se puede especificar como ``65535``.
.. _class_RenderingDevice_constant_INDEX_BUFFER_FORMAT_UINT32:
.. rst-class:: classref-enumeration-constant
:ref:`IndexBufferFormat<enum_RenderingDevice_IndexBufferFormat>` **INDEX_BUFFER_FORMAT_UINT32** = ``1``
Búfer de índices en formato de entero sin signo de 32 bits. Esto limita el índice máximo que se puede especificar como ``4294967295``.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_StorageBufferUsage:
.. rst-class:: classref-enumeration
flags **StorageBufferUsage**: :ref:`🔗<enum_RenderingDevice_StorageBufferUsage>`
.. _class_RenderingDevice_constant_STORAGE_BUFFER_USAGE_DISPATCH_INDIRECT:
.. rst-class:: classref-enumeration-constant
:ref:`StorageBufferUsage<enum_RenderingDevice_StorageBufferUsage>` **STORAGE_BUFFER_USAGE_DISPATCH_INDIRECT** = ``1``
.. container:: contribute
There is currently no description for this enum. Please help us by `contributing one <https://contributing.godotengine.org/en/latest/documentation/class_reference.html>`__!
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_BufferCreationBits:
.. rst-class:: classref-enumeration
flags **BufferCreationBits**: :ref:`🔗<enum_RenderingDevice_BufferCreationBits>`
.. _class_RenderingDevice_constant_BUFFER_CREATION_DEVICE_ADDRESS_BIT:
.. rst-class:: classref-enumeration-constant
:ref:`BufferCreationBits<enum_RenderingDevice_BufferCreationBits>` **BUFFER_CREATION_DEVICE_ADDRESS_BIT** = ``1``
Optionally, set this flag if you wish to use :ref:`buffer_get_device_address()<class_RenderingDevice_method_buffer_get_device_address>` functionality. You must first check the GPU supports it:
.. tabs::
.. code-tab:: gdscript
rd = RenderingServer.get_rendering_device()
if rd.has_feature(RenderingDevice.SUPPORTS_BUFFER_DEVICE_ADDRESS):
storage_buffer = rd.storage_buffer_create(bytes.size(), bytes, RenderingDevice.STORAGE_BUFFER_USAGE_SHADER_DEVICE_ADDRESS)
storage_buffer_address = rd.buffer_get_device_address(storage_buffer)
.. _class_RenderingDevice_constant_BUFFER_CREATION_AS_STORAGE_BIT:
.. rst-class:: classref-enumeration-constant
:ref:`BufferCreationBits<enum_RenderingDevice_BufferCreationBits>` **BUFFER_CREATION_AS_STORAGE_BIT** = ``2``
Set this flag so that it is created as storage. This is useful if Compute Shaders need access (for reading or writing) to the buffer, e.g. skeletal animations are processed in Compute Shaders which need access to vertex buffers, to be later consumed by vertex shaders as part of the regular rasterization pipeline.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_UniformType:
.. rst-class:: classref-enumeration
enum **UniformType**: :ref:`🔗<enum_RenderingDevice_UniformType>`
.. _class_RenderingDevice_constant_UNIFORM_TYPE_SAMPLER:
.. rst-class:: classref-enumeration-constant
:ref:`UniformType<enum_RenderingDevice_UniformType>` **UNIFORM_TYPE_SAMPLER** = ``0``
Uniforme de muestreador.
.. _class_RenderingDevice_constant_UNIFORM_TYPE_SAMPLER_WITH_TEXTURE:
.. rst-class:: classref-enumeration-constant
:ref:`UniformType<enum_RenderingDevice_UniformType>` **UNIFORM_TYPE_SAMPLER_WITH_TEXTURE** = ``1``
Uniforme de muestreador con una textura.
.. _class_RenderingDevice_constant_UNIFORM_TYPE_TEXTURE:
.. rst-class:: classref-enumeration-constant
:ref:`UniformType<enum_RenderingDevice_UniformType>` **UNIFORM_TYPE_TEXTURE** = ``2``
Uniforme de textura.
.. _class_RenderingDevice_constant_UNIFORM_TYPE_IMAGE:
.. rst-class:: classref-enumeration-constant
:ref:`UniformType<enum_RenderingDevice_UniformType>` **UNIFORM_TYPE_IMAGE** = ``3``
Uniforme de imagen.
.. _class_RenderingDevice_constant_UNIFORM_TYPE_TEXTURE_BUFFER:
.. rst-class:: classref-enumeration-constant
:ref:`UniformType<enum_RenderingDevice_UniformType>` **UNIFORM_TYPE_TEXTURE_BUFFER** = ``4``
Uniforme de búfer de textura.
.. _class_RenderingDevice_constant_UNIFORM_TYPE_SAMPLER_WITH_TEXTURE_BUFFER:
.. rst-class:: classref-enumeration-constant
:ref:`UniformType<enum_RenderingDevice_UniformType>` **UNIFORM_TYPE_SAMPLER_WITH_TEXTURE_BUFFER** = ``5``
Uniforme de muestreador con un búfer de textura.
.. _class_RenderingDevice_constant_UNIFORM_TYPE_IMAGE_BUFFER:
.. rst-class:: classref-enumeration-constant
:ref:`UniformType<enum_RenderingDevice_UniformType>` **UNIFORM_TYPE_IMAGE_BUFFER** = ``6``
Uniforme de búfer de imagen.
.. _class_RenderingDevice_constant_UNIFORM_TYPE_UNIFORM_BUFFER:
.. rst-class:: classref-enumeration-constant
:ref:`UniformType<enum_RenderingDevice_UniformType>` **UNIFORM_TYPE_UNIFORM_BUFFER** = ``7``
Uniforme de búfer de uniformes.
.. _class_RenderingDevice_constant_UNIFORM_TYPE_STORAGE_BUFFER:
.. rst-class:: classref-enumeration-constant
:ref:`UniformType<enum_RenderingDevice_UniformType>` **UNIFORM_TYPE_STORAGE_BUFFER** = ``8``
Uniforme de `búfer de almacenamiento <https://vkguide.dev/docs/chapter-4/storage_buffers/>`__.
.. _class_RenderingDevice_constant_UNIFORM_TYPE_INPUT_ATTACHMENT:
.. rst-class:: classref-enumeration-constant
:ref:`UniformType<enum_RenderingDevice_UniformType>` **UNIFORM_TYPE_INPUT_ATTACHMENT** = ``9``
Input attachment uniform.
.. _class_RenderingDevice_constant_UNIFORM_TYPE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`UniformType<enum_RenderingDevice_UniformType>` **UNIFORM_TYPE_MAX** = ``10``
Representa el tamaño del enum :ref:`UniformType<enum_RenderingDevice_UniformType>`.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_RenderPrimitive:
.. rst-class:: classref-enumeration
enum **RenderPrimitive**: :ref:`🔗<enum_RenderingDevice_RenderPrimitive>`
.. _class_RenderingDevice_constant_RENDER_PRIMITIVE_POINTS:
.. rst-class:: classref-enumeration-constant
:ref:`RenderPrimitive<enum_RenderingDevice_RenderPrimitive>` **RENDER_PRIMITIVE_POINTS** = ``0``
Primitiva de renderizado de puntos (con tamaño constante, independientemente de la distancia a la cámara).
.. _class_RenderingDevice_constant_RENDER_PRIMITIVE_LINES:
.. rst-class:: classref-enumeration-constant
:ref:`RenderPrimitive<enum_RenderingDevice_RenderPrimitive>` **RENDER_PRIMITIVE_LINES** = ``1``
Primitiva de renderizado de lista de líneas. Las líneas se dibujan separadas unas de otras.
.. _class_RenderingDevice_constant_RENDER_PRIMITIVE_LINES_WITH_ADJACENCY:
.. rst-class:: classref-enumeration-constant
:ref:`RenderPrimitive<enum_RenderingDevice_RenderPrimitive>` **RENDER_PRIMITIVE_LINES_WITH_ADJACENCY** = ``2``
`Primitiva de renderizado de lista de líneas con adyacencia. <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#drawing-line-lists-with-adjacency>`__\
\ **Nota:** La adyacencia solo es útil con los shaders de geometría, que Godot no expone.
.. _class_RenderingDevice_constant_RENDER_PRIMITIVE_LINESTRIPS:
.. rst-class:: classref-enumeration-constant
:ref:`RenderPrimitive<enum_RenderingDevice_RenderPrimitive>` **RENDER_PRIMITIVE_LINESTRIPS** = ``3``
Primitiva de renderizado de tira de líneas. Las líneas dibujadas se conectan al vértice anterior.
.. _class_RenderingDevice_constant_RENDER_PRIMITIVE_LINESTRIPS_WITH_ADJACENCY:
.. rst-class:: classref-enumeration-constant
:ref:`RenderPrimitive<enum_RenderingDevice_RenderPrimitive>` **RENDER_PRIMITIVE_LINESTRIPS_WITH_ADJACENCY** = ``4``
`Primitiva de renderizado de tira de líneas con adyacencia. <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#drawing-line-strips-with-adjacency>`__\
\ **Nota:** La adyacencia solo es útil con los shaders de geometría, que Godot no expone.
.. _class_RenderingDevice_constant_RENDER_PRIMITIVE_TRIANGLES:
.. rst-class:: classref-enumeration-constant
:ref:`RenderPrimitive<enum_RenderingDevice_RenderPrimitive>` **RENDER_PRIMITIVE_TRIANGLES** = ``5``
Primitiva de renderizado de lista de triángulos. Los triángulos se dibujan separados unos de otros.
.. _class_RenderingDevice_constant_RENDER_PRIMITIVE_TRIANGLES_WITH_ADJACENCY:
.. rst-class:: classref-enumeration-constant
:ref:`RenderPrimitive<enum_RenderingDevice_RenderPrimitive>` **RENDER_PRIMITIVE_TRIANGLES_WITH_ADJACENCY** = ``6``
`Triangle list rendering primitive with adjacency. <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#drawing-triangle-lists-with-adjacency>`__\
\ **Note:** Adjacency is only useful with geometry shaders, which Godot does not expose.
.. _class_RenderingDevice_constant_RENDER_PRIMITIVE_TRIANGLE_STRIPS:
.. rst-class:: classref-enumeration-constant
:ref:`RenderPrimitive<enum_RenderingDevice_RenderPrimitive>` **RENDER_PRIMITIVE_TRIANGLE_STRIPS** = ``7``
Triangle strip rendering primitive. Triangles drawn are connected to the previous triangle.
.. _class_RenderingDevice_constant_RENDER_PRIMITIVE_TRIANGLE_STRIPS_WITH_AJACENCY:
.. rst-class:: classref-enumeration-constant
:ref:`RenderPrimitive<enum_RenderingDevice_RenderPrimitive>` **RENDER_PRIMITIVE_TRIANGLE_STRIPS_WITH_AJACENCY** = ``8``
`Triangle strip rendering primitive with adjacency. <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#drawing-triangle-strips-with-adjacency>`__\
\ **Note:** Adjacency is only useful with geometry shaders, which Godot does not expose.
.. _class_RenderingDevice_constant_RENDER_PRIMITIVE_TRIANGLE_STRIPS_WITH_RESTART_INDEX:
.. rst-class:: classref-enumeration-constant
:ref:`RenderPrimitive<enum_RenderingDevice_RenderPrimitive>` **RENDER_PRIMITIVE_TRIANGLE_STRIPS_WITH_RESTART_INDEX** = ``9``
Triangle strip rendering primitive with *primitive restart* enabled. Triangles drawn are connected to the previous triangle, but a primitive restart index can be specified before drawing to create a second triangle strip after the specified index.
\ **Note:** Only compatible with indexed draws.
.. _class_RenderingDevice_constant_RENDER_PRIMITIVE_TESSELATION_PATCH:
.. rst-class:: classref-enumeration-constant
:ref:`RenderPrimitive<enum_RenderingDevice_RenderPrimitive>` **RENDER_PRIMITIVE_TESSELATION_PATCH** = ``10``
Primitiva de renderizado de parche de teselación. Solo es útil con shaders de teselación, que pueden usarse para deformar estos parches.
.. _class_RenderingDevice_constant_RENDER_PRIMITIVE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`RenderPrimitive<enum_RenderingDevice_RenderPrimitive>` **RENDER_PRIMITIVE_MAX** = ``11``
Representa el tamaño del enum :ref:`RenderPrimitive<enum_RenderingDevice_RenderPrimitive>`.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_PolygonCullMode:
.. rst-class:: classref-enumeration
enum **PolygonCullMode**: :ref:`🔗<enum_RenderingDevice_PolygonCullMode>`
.. _class_RenderingDevice_constant_POLYGON_CULL_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`PolygonCullMode<enum_RenderingDevice_PolygonCullMode>` **POLYGON_CULL_DISABLED** = ``0``
Do not use polygon front face or backface culling.
.. _class_RenderingDevice_constant_POLYGON_CULL_FRONT:
.. rst-class:: classref-enumeration-constant
:ref:`PolygonCullMode<enum_RenderingDevice_PolygonCullMode>` **POLYGON_CULL_FRONT** = ``1``
Use polygon frontface culling (faces pointing towards the camera are hidden).
.. _class_RenderingDevice_constant_POLYGON_CULL_BACK:
.. rst-class:: classref-enumeration-constant
:ref:`PolygonCullMode<enum_RenderingDevice_PolygonCullMode>` **POLYGON_CULL_BACK** = ``2``
Use polygon backface culling (faces pointing away from the camera are hidden).
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_PolygonFrontFace:
.. rst-class:: classref-enumeration
enum **PolygonFrontFace**: :ref:`🔗<enum_RenderingDevice_PolygonFrontFace>`
.. _class_RenderingDevice_constant_POLYGON_FRONT_FACE_CLOCKWISE:
.. rst-class:: classref-enumeration-constant
:ref:`PolygonFrontFace<enum_RenderingDevice_PolygonFrontFace>` **POLYGON_FRONT_FACE_CLOCKWISE** = ``0``
Clockwise winding order to determine which face of a polygon is its front face.
.. _class_RenderingDevice_constant_POLYGON_FRONT_FACE_COUNTER_CLOCKWISE:
.. rst-class:: classref-enumeration-constant
:ref:`PolygonFrontFace<enum_RenderingDevice_PolygonFrontFace>` **POLYGON_FRONT_FACE_COUNTER_CLOCKWISE** = ``1``
Counter-clockwise winding order to determine which face of a polygon is its front face.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_StencilOperation:
.. rst-class:: classref-enumeration
enum **StencilOperation**: :ref:`🔗<enum_RenderingDevice_StencilOperation>`
.. _class_RenderingDevice_constant_STENCIL_OP_KEEP:
.. rst-class:: classref-enumeration-constant
:ref:`StencilOperation<enum_RenderingDevice_StencilOperation>` **STENCIL_OP_KEEP** = ``0``
Keep the current stencil value.
.. _class_RenderingDevice_constant_STENCIL_OP_ZERO:
.. rst-class:: classref-enumeration-constant
:ref:`StencilOperation<enum_RenderingDevice_StencilOperation>` **STENCIL_OP_ZERO** = ``1``
Set the stencil value to ``0``.
.. _class_RenderingDevice_constant_STENCIL_OP_REPLACE:
.. rst-class:: classref-enumeration-constant
:ref:`StencilOperation<enum_RenderingDevice_StencilOperation>` **STENCIL_OP_REPLACE** = ``2``
Replace the existing stencil value with the new one.
.. _class_RenderingDevice_constant_STENCIL_OP_INCREMENT_AND_CLAMP:
.. rst-class:: classref-enumeration-constant
:ref:`StencilOperation<enum_RenderingDevice_StencilOperation>` **STENCIL_OP_INCREMENT_AND_CLAMP** = ``3``
Increment the existing stencil value and clamp to the maximum representable unsigned value if reached. Stencil bits are considered as an unsigned integer.
.. _class_RenderingDevice_constant_STENCIL_OP_DECREMENT_AND_CLAMP:
.. rst-class:: classref-enumeration-constant
:ref:`StencilOperation<enum_RenderingDevice_StencilOperation>` **STENCIL_OP_DECREMENT_AND_CLAMP** = ``4``
Decrement the existing stencil value and clamp to the minimum value if reached. Stencil bits are considered as an unsigned integer.
.. _class_RenderingDevice_constant_STENCIL_OP_INVERT:
.. rst-class:: classref-enumeration-constant
:ref:`StencilOperation<enum_RenderingDevice_StencilOperation>` **STENCIL_OP_INVERT** = ``5``
Bitwise-invert the existing stencil value.
.. _class_RenderingDevice_constant_STENCIL_OP_INCREMENT_AND_WRAP:
.. rst-class:: classref-enumeration-constant
:ref:`StencilOperation<enum_RenderingDevice_StencilOperation>` **STENCIL_OP_INCREMENT_AND_WRAP** = ``6``
Increment the stencil value and wrap around to ``0`` if reaching the maximum representable unsigned. Stencil bits are considered as an unsigned integer.
.. _class_RenderingDevice_constant_STENCIL_OP_DECREMENT_AND_WRAP:
.. rst-class:: classref-enumeration-constant
:ref:`StencilOperation<enum_RenderingDevice_StencilOperation>` **STENCIL_OP_DECREMENT_AND_WRAP** = ``7``
Decrement the stencil value and wrap around to the maximum representable unsigned if reaching the minimum. Stencil bits are considered as an unsigned integer.
.. _class_RenderingDevice_constant_STENCIL_OP_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`StencilOperation<enum_RenderingDevice_StencilOperation>` **STENCIL_OP_MAX** = ``8``
Representa el tamaño del enum :ref:`StencilOperation<enum_RenderingDevice_StencilOperation>`.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_CompareOperator:
.. rst-class:: classref-enumeration
enum **CompareOperator**: :ref:`🔗<enum_RenderingDevice_CompareOperator>`
.. _class_RenderingDevice_constant_COMPARE_OP_NEVER:
.. rst-class:: classref-enumeration-constant
:ref:`CompareOperator<enum_RenderingDevice_CompareOperator>` **COMPARE_OP_NEVER** = ``0``
Comparación "Nunca" (opuesto de :ref:`COMPARE_OP_ALWAYS<class_RenderingDevice_constant_COMPARE_OP_ALWAYS>`).
.. _class_RenderingDevice_constant_COMPARE_OP_LESS:
.. rst-class:: classref-enumeration-constant
:ref:`CompareOperator<enum_RenderingDevice_CompareOperator>` **COMPARE_OP_LESS** = ``1``
Comparación "menor que".
.. _class_RenderingDevice_constant_COMPARE_OP_EQUAL:
.. rst-class:: classref-enumeration-constant
:ref:`CompareOperator<enum_RenderingDevice_CompareOperator>` **COMPARE_OP_EQUAL** = ``2``
Comparación "igual".
.. _class_RenderingDevice_constant_COMPARE_OP_LESS_OR_EQUAL:
.. rst-class:: classref-enumeration-constant
:ref:`CompareOperator<enum_RenderingDevice_CompareOperator>` **COMPARE_OP_LESS_OR_EQUAL** = ``3``
Comparación "Menor o igual que".
.. _class_RenderingDevice_constant_COMPARE_OP_GREATER:
.. rst-class:: classref-enumeration-constant
:ref:`CompareOperator<enum_RenderingDevice_CompareOperator>` **COMPARE_OP_GREATER** = ``4``
Comparación "mayor que".
.. _class_RenderingDevice_constant_COMPARE_OP_NOT_EQUAL:
.. rst-class:: classref-enumeration-constant
:ref:`CompareOperator<enum_RenderingDevice_CompareOperator>` **COMPARE_OP_NOT_EQUAL** = ``5``
Comparación "No es igual a".
.. _class_RenderingDevice_constant_COMPARE_OP_GREATER_OR_EQUAL:
.. rst-class:: classref-enumeration-constant
:ref:`CompareOperator<enum_RenderingDevice_CompareOperator>` **COMPARE_OP_GREATER_OR_EQUAL** = ``6``
Comparación "Mayor o igual que".
.. _class_RenderingDevice_constant_COMPARE_OP_ALWAYS:
.. rst-class:: classref-enumeration-constant
:ref:`CompareOperator<enum_RenderingDevice_CompareOperator>` **COMPARE_OP_ALWAYS** = ``7``
Comparación "Siempre" (opuesto de :ref:`COMPARE_OP_NEVER<class_RenderingDevice_constant_COMPARE_OP_NEVER>`).
.. _class_RenderingDevice_constant_COMPARE_OP_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`CompareOperator<enum_RenderingDevice_CompareOperator>` **COMPARE_OP_MAX** = ``8``
Representa el tamaño del enum :ref:`CompareOperator<enum_RenderingDevice_CompareOperator>`.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_LogicOperation:
.. rst-class:: classref-enumeration
enum **LogicOperation**: :ref:`🔗<enum_RenderingDevice_LogicOperation>`
.. _class_RenderingDevice_constant_LOGIC_OP_CLEAR:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_CLEAR** = ``0``
Operación lógica de borrado (el resultado siempre es ``0``). Véase también :ref:`LOGIC_OP_SET<class_RenderingDevice_constant_LOGIC_OP_SET>`.
.. _class_RenderingDevice_constant_LOGIC_OP_AND:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_AND** = ``1``
Operación lógica AND.
.. _class_RenderingDevice_constant_LOGIC_OP_AND_REVERSE:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_AND_REVERSE** = ``2``
Operación lógica AND con el operando *destino* invertido. Véase también :ref:`LOGIC_OP_AND_INVERTED<class_RenderingDevice_constant_LOGIC_OP_AND_INVERTED>`.
.. _class_RenderingDevice_constant_LOGIC_OP_COPY:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_COPY** = ``3``
Operación lógica de copia (mantiene el valor de la *fuente* tal cual). Véase también :ref:`LOGIC_OP_COPY_INVERTED<class_RenderingDevice_constant_LOGIC_OP_COPY_INVERTED>` y :ref:`LOGIC_OP_NO_OP<class_RenderingDevice_constant_LOGIC_OP_NO_OP>`.
.. _class_RenderingDevice_constant_LOGIC_OP_AND_INVERTED:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_AND_INVERTED** = ``4``
Operación lógica AND con el operando *fuente* invertido. Véase también :ref:`LOGIC_OP_AND_REVERSE<class_RenderingDevice_constant_LOGIC_OP_AND_REVERSE>`.
.. _class_RenderingDevice_constant_LOGIC_OP_NO_OP:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_NO_OP** = ``5``
Operación lógica no-op (mantiene el valor del *destino* tal como está). Véase también :ref:`LOGIC_OP_COPY<class_RenderingDevice_constant_LOGIC_OP_COPY>`.
.. _class_RenderingDevice_constant_LOGIC_OP_XOR:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_XOR** = ``6``
Operación lógica OR exclusiva (XOR).
.. _class_RenderingDevice_constant_LOGIC_OP_OR:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_OR** = ``7``
Operación lógica OR.
.. _class_RenderingDevice_constant_LOGIC_OP_NOR:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_NOR** = ``8``
Operación lógica Not-OR (NOR).
.. _class_RenderingDevice_constant_LOGIC_OP_EQUIVALENT:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_EQUIVALENT** = ``9``
Operación lógica Not-XOR (XNOR).
.. _class_RenderingDevice_constant_LOGIC_OP_INVERT:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_INVERT** = ``10``
Operación lógica de inversión.
.. _class_RenderingDevice_constant_LOGIC_OP_OR_REVERSE:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_OR_REVERSE** = ``11``
Operación lógica OR con el operando *destino* invertido. Véase también :ref:`LOGIC_OP_OR_REVERSE<class_RenderingDevice_constant_LOGIC_OP_OR_REVERSE>`.
.. _class_RenderingDevice_constant_LOGIC_OP_COPY_INVERTED:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_COPY_INVERTED** = ``12``
Operación lógica NOT (invierte el valor). Véase también :ref:`LOGIC_OP_COPY<class_RenderingDevice_constant_LOGIC_OP_COPY>`.
.. _class_RenderingDevice_constant_LOGIC_OP_OR_INVERTED:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_OR_INVERTED** = ``13``
Operación lógica OR con el operando *fuente* invertido. Véase también :ref:`LOGIC_OP_OR_REVERSE<class_RenderingDevice_constant_LOGIC_OP_OR_REVERSE>`.
.. _class_RenderingDevice_constant_LOGIC_OP_NAND:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_NAND** = ``14``
Operación lógica Not-AND (NAND).
.. _class_RenderingDevice_constant_LOGIC_OP_SET:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_SET** = ``15``
Operación lógica SET (el resultado siempre es ``1``). Véase también :ref:`LOGIC_OP_CLEAR<class_RenderingDevice_constant_LOGIC_OP_CLEAR>`.
.. _class_RenderingDevice_constant_LOGIC_OP_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_MAX** = ``16``
Representa el tamaño del enum :ref:`LogicOperation<enum_RenderingDevice_LogicOperation>`.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_BlendFactor:
.. rst-class:: classref-enumeration
enum **BlendFactor**: :ref:`🔗<enum_RenderingDevice_BlendFactor>`
.. _class_RenderingDevice_constant_BLEND_FACTOR_ZERO:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_ZERO** = ``0``
Factor de mezcla constante ``0.0``.
.. _class_RenderingDevice_constant_BLEND_FACTOR_ONE:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_ONE** = ``1``
Factor de mezcla constante ``1.0``.
.. _class_RenderingDevice_constant_BLEND_FACTOR_SRC_COLOR:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_SRC_COLOR** = ``2``
Color blend factor is ``source color``. Alpha blend factor is ``source alpha``.
.. _class_RenderingDevice_constant_BLEND_FACTOR_ONE_MINUS_SRC_COLOR:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_ONE_MINUS_SRC_COLOR** = ``3``
Color blend factor is ``1.0 - source color``. Alpha blend factor is ``1.0 - source alpha``.
.. _class_RenderingDevice_constant_BLEND_FACTOR_DST_COLOR:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_DST_COLOR** = ``4``
Color blend factor is ``destination color``. Alpha blend factor is ``destination alpha``.
.. _class_RenderingDevice_constant_BLEND_FACTOR_ONE_MINUS_DST_COLOR:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_ONE_MINUS_DST_COLOR** = ``5``
Color blend factor is ``1.0 - destination color``. Alpha blend factor is ``1.0 - destination alpha``.
.. _class_RenderingDevice_constant_BLEND_FACTOR_SRC_ALPHA:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_SRC_ALPHA** = ``6``
Color and alpha blend factor is ``source alpha``.
.. _class_RenderingDevice_constant_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_ONE_MINUS_SRC_ALPHA** = ``7``
Color and alpha blend factor is ``1.0 - source alpha``.
.. _class_RenderingDevice_constant_BLEND_FACTOR_DST_ALPHA:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_DST_ALPHA** = ``8``
Color and alpha blend factor is ``destination alpha``.
.. _class_RenderingDevice_constant_BLEND_FACTOR_ONE_MINUS_DST_ALPHA:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_ONE_MINUS_DST_ALPHA** = ``9``
Color and alpha blend factor is ``1.0 - destination alpha``.
.. _class_RenderingDevice_constant_BLEND_FACTOR_CONSTANT_COLOR:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_CONSTANT_COLOR** = ``10``
Color blend factor is ``blend constant color``. Alpha blend factor is ``blend constant alpha`` (see :ref:`draw_list_set_blend_constants()<class_RenderingDevice_method_draw_list_set_blend_constants>`).
.. _class_RenderingDevice_constant_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR** = ``11``
Color blend factor is ``1.0 - blend constant color``. Alpha blend factor is ``1.0 - blend constant alpha`` (see :ref:`draw_list_set_blend_constants()<class_RenderingDevice_method_draw_list_set_blend_constants>`).
.. _class_RenderingDevice_constant_BLEND_FACTOR_CONSTANT_ALPHA:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_CONSTANT_ALPHA** = ``12``
Color and alpha blend factor is ``blend constant alpha`` (see :ref:`draw_list_set_blend_constants()<class_RenderingDevice_method_draw_list_set_blend_constants>`).
.. _class_RenderingDevice_constant_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA** = ``13``
Color and alpha blend factor is ``1.0 - blend constant alpha`` (see :ref:`draw_list_set_blend_constants()<class_RenderingDevice_method_draw_list_set_blend_constants>`).
.. _class_RenderingDevice_constant_BLEND_FACTOR_SRC_ALPHA_SATURATE:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_SRC_ALPHA_SATURATE** = ``14``
Color blend factor is ``min(source alpha, 1.0 - destination alpha)``. Alpha blend factor is ``1.0``.
.. _class_RenderingDevice_constant_BLEND_FACTOR_SRC1_COLOR:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_SRC1_COLOR** = ``15``
Color blend factor is ``second source color``. Alpha blend factor is ``second source alpha``. Only relevant for dual-source blending.
.. _class_RenderingDevice_constant_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_ONE_MINUS_SRC1_COLOR** = ``16``
Color blend factor is ``1.0 - second source color``. Alpha blend factor is ``1.0 - second source alpha``. Only relevant for dual-source blending.
.. _class_RenderingDevice_constant_BLEND_FACTOR_SRC1_ALPHA:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_SRC1_ALPHA** = ``17``
Color and alpha blend factor is ``second source alpha``. Only relevant for dual-source blending.
.. _class_RenderingDevice_constant_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA** = ``18``
Color and alpha blend factor is ``1.0 - second source alpha``. Only relevant for dual-source blending.
.. _class_RenderingDevice_constant_BLEND_FACTOR_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_MAX** = ``19``
Representa el tamaño del enum :ref:`BlendFactor<enum_RenderingDevice_BlendFactor>`.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_BlendOperation:
.. rst-class:: classref-enumeration
enum **BlendOperation**: :ref:`🔗<enum_RenderingDevice_BlendOperation>`
.. _class_RenderingDevice_constant_BLEND_OP_ADD:
.. rst-class:: classref-enumeration-constant
:ref:`BlendOperation<enum_RenderingDevice_BlendOperation>` **BLEND_OP_ADD** = ``0``
Additive blending operation (``source + destination``).
.. _class_RenderingDevice_constant_BLEND_OP_SUBTRACT:
.. rst-class:: classref-enumeration-constant
:ref:`BlendOperation<enum_RenderingDevice_BlendOperation>` **BLEND_OP_SUBTRACT** = ``1``
Subtractive blending operation (``source - destination``).
.. _class_RenderingDevice_constant_BLEND_OP_REVERSE_SUBTRACT:
.. rst-class:: classref-enumeration-constant
:ref:`BlendOperation<enum_RenderingDevice_BlendOperation>` **BLEND_OP_REVERSE_SUBTRACT** = ``2``
Reverse subtractive blending operation (``destination - source``).
.. _class_RenderingDevice_constant_BLEND_OP_MINIMUM:
.. rst-class:: classref-enumeration-constant
:ref:`BlendOperation<enum_RenderingDevice_BlendOperation>` **BLEND_OP_MINIMUM** = ``3``
Minimum blending operation (keep the lowest value of the two).
.. _class_RenderingDevice_constant_BLEND_OP_MAXIMUM:
.. rst-class:: classref-enumeration-constant
:ref:`BlendOperation<enum_RenderingDevice_BlendOperation>` **BLEND_OP_MAXIMUM** = ``4``
Maximum blending operation (keep the highest value of the two).
.. _class_RenderingDevice_constant_BLEND_OP_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`BlendOperation<enum_RenderingDevice_BlendOperation>` **BLEND_OP_MAX** = ``5``
Representa el tamaño del enum :ref:`BlendOperation<enum_RenderingDevice_BlendOperation>`.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_PipelineDynamicStateFlags:
.. rst-class:: classref-enumeration
flags **PipelineDynamicStateFlags**: :ref:`🔗<enum_RenderingDevice_PipelineDynamicStateFlags>`
.. _class_RenderingDevice_constant_DYNAMIC_STATE_LINE_WIDTH:
.. rst-class:: classref-enumeration-constant
:ref:`PipelineDynamicStateFlags<enum_RenderingDevice_PipelineDynamicStateFlags>` **DYNAMIC_STATE_LINE_WIDTH** = ``1``
Allows dynamically changing the width of rendering lines.
.. _class_RenderingDevice_constant_DYNAMIC_STATE_DEPTH_BIAS:
.. rst-class:: classref-enumeration-constant
:ref:`PipelineDynamicStateFlags<enum_RenderingDevice_PipelineDynamicStateFlags>` **DYNAMIC_STATE_DEPTH_BIAS** = ``2``
Allows dynamically changing the depth bias.
.. _class_RenderingDevice_constant_DYNAMIC_STATE_BLEND_CONSTANTS:
.. rst-class:: classref-enumeration-constant
:ref:`PipelineDynamicStateFlags<enum_RenderingDevice_PipelineDynamicStateFlags>` **DYNAMIC_STATE_BLEND_CONSTANTS** = ``4``
.. container:: contribute
There is currently no description for this enum. Please help us by `contributing one <https://contributing.godotengine.org/en/latest/documentation/class_reference.html>`__!
.. _class_RenderingDevice_constant_DYNAMIC_STATE_DEPTH_BOUNDS:
.. rst-class:: classref-enumeration-constant
:ref:`PipelineDynamicStateFlags<enum_RenderingDevice_PipelineDynamicStateFlags>` **DYNAMIC_STATE_DEPTH_BOUNDS** = ``8``
.. container:: contribute
There is currently no description for this enum. Please help us by `contributing one <https://contributing.godotengine.org/en/latest/documentation/class_reference.html>`__!
.. _class_RenderingDevice_constant_DYNAMIC_STATE_STENCIL_COMPARE_MASK:
.. rst-class:: classref-enumeration-constant
:ref:`PipelineDynamicStateFlags<enum_RenderingDevice_PipelineDynamicStateFlags>` **DYNAMIC_STATE_STENCIL_COMPARE_MASK** = ``16``
.. container:: contribute
There is currently no description for this enum. Please help us by `contributing one <https://contributing.godotengine.org/en/latest/documentation/class_reference.html>`__!
.. _class_RenderingDevice_constant_DYNAMIC_STATE_STENCIL_WRITE_MASK:
.. rst-class:: classref-enumeration-constant
:ref:`PipelineDynamicStateFlags<enum_RenderingDevice_PipelineDynamicStateFlags>` **DYNAMIC_STATE_STENCIL_WRITE_MASK** = ``32``
.. container:: contribute
There is currently no description for this enum. Please help us by `contributing one <https://contributing.godotengine.org/en/latest/documentation/class_reference.html>`__!
.. _class_RenderingDevice_constant_DYNAMIC_STATE_STENCIL_REFERENCE:
.. rst-class:: classref-enumeration-constant
:ref:`PipelineDynamicStateFlags<enum_RenderingDevice_PipelineDynamicStateFlags>` **DYNAMIC_STATE_STENCIL_REFERENCE** = ``64``
.. container:: contribute
There is currently no description for this enum. Please help us by `contributing one <https://contributing.godotengine.org/en/latest/documentation/class_reference.html>`__!
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_InitialAction:
.. rst-class:: classref-enumeration
enum **InitialAction**: :ref:`🔗<enum_RenderingDevice_InitialAction>`
.. _class_RenderingDevice_constant_INITIAL_ACTION_LOAD:
.. rst-class:: classref-enumeration-constant
:ref:`InitialAction<enum_RenderingDevice_InitialAction>` **INITIAL_ACTION_LOAD** = ``0``
**Obsoleto:** Initial actions are solved automatically by RenderingDevice.
Load the previous contents of the framebuffer.
.. _class_RenderingDevice_constant_INITIAL_ACTION_CLEAR:
.. rst-class:: classref-enumeration-constant
:ref:`InitialAction<enum_RenderingDevice_InitialAction>` **INITIAL_ACTION_CLEAR** = ``1``
**Obsoleto:** Initial actions are solved automatically by RenderingDevice.
Clear the whole framebuffer or its specified region.
.. _class_RenderingDevice_constant_INITIAL_ACTION_DISCARD:
.. rst-class:: classref-enumeration-constant
:ref:`InitialAction<enum_RenderingDevice_InitialAction>` **INITIAL_ACTION_DISCARD** = ``2``
**Obsoleto:** Initial actions are solved automatically by RenderingDevice.
Ignore the previous contents of the framebuffer. This is the fastest option if you'll overwrite all of the pixels and don't need to read any of them.
.. _class_RenderingDevice_constant_INITIAL_ACTION_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`InitialAction<enum_RenderingDevice_InitialAction>` **INITIAL_ACTION_MAX** = ``3``
**Obsoleto:** Initial actions are solved automatically by RenderingDevice.
Representa el tamaño del enum :ref:`InitialAction<enum_RenderingDevice_InitialAction>`.
.. _class_RenderingDevice_constant_INITIAL_ACTION_CLEAR_REGION:
.. rst-class:: classref-enumeration-constant
:ref:`InitialAction<enum_RenderingDevice_InitialAction>` **INITIAL_ACTION_CLEAR_REGION** = ``1``
**Obsoleto:** Initial actions are solved automatically by RenderingDevice.
.. _class_RenderingDevice_constant_INITIAL_ACTION_CLEAR_REGION_CONTINUE:
.. rst-class:: classref-enumeration-constant
:ref:`InitialAction<enum_RenderingDevice_InitialAction>` **INITIAL_ACTION_CLEAR_REGION_CONTINUE** = ``1``
**Obsoleto:** Initial actions are solved automatically by RenderingDevice.
.. _class_RenderingDevice_constant_INITIAL_ACTION_KEEP:
.. rst-class:: classref-enumeration-constant
:ref:`InitialAction<enum_RenderingDevice_InitialAction>` **INITIAL_ACTION_KEEP** = ``0``
**Obsoleto:** Initial actions are solved automatically by RenderingDevice.
.. _class_RenderingDevice_constant_INITIAL_ACTION_DROP:
.. rst-class:: classref-enumeration-constant
:ref:`InitialAction<enum_RenderingDevice_InitialAction>` **INITIAL_ACTION_DROP** = ``2``
**Obsoleto:** Initial actions are solved automatically by RenderingDevice.
.. _class_RenderingDevice_constant_INITIAL_ACTION_CONTINUE:
.. rst-class:: classref-enumeration-constant
:ref:`InitialAction<enum_RenderingDevice_InitialAction>` **INITIAL_ACTION_CONTINUE** = ``0``
**Obsoleto:** Initial actions are solved automatically by RenderingDevice.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_FinalAction:
.. rst-class:: classref-enumeration
enum **FinalAction**: :ref:`🔗<enum_RenderingDevice_FinalAction>`
.. _class_RenderingDevice_constant_FINAL_ACTION_STORE:
.. rst-class:: classref-enumeration-constant
:ref:`FinalAction<enum_RenderingDevice_FinalAction>` **FINAL_ACTION_STORE** = ``0``
**Obsoleto:** Final actions are solved automatically by RenderingDevice.
Store the result of the draw list in the framebuffer. This is generally what you want to do.
.. _class_RenderingDevice_constant_FINAL_ACTION_DISCARD:
.. rst-class:: classref-enumeration-constant
:ref:`FinalAction<enum_RenderingDevice_FinalAction>` **FINAL_ACTION_DISCARD** = ``1``
**Obsoleto:** Final actions are solved automatically by RenderingDevice.
Discard the contents of the framebuffer. This is the fastest option if you don't need to use the results of the draw list.
.. _class_RenderingDevice_constant_FINAL_ACTION_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`FinalAction<enum_RenderingDevice_FinalAction>` **FINAL_ACTION_MAX** = ``2``
**Obsoleto:** Final actions are solved automatically by RenderingDevice.
Representa el tamaño del enum :ref:`FinalAction<enum_RenderingDevice_FinalAction>`.
.. _class_RenderingDevice_constant_FINAL_ACTION_READ:
.. rst-class:: classref-enumeration-constant
:ref:`FinalAction<enum_RenderingDevice_FinalAction>` **FINAL_ACTION_READ** = ``0``
**Obsoleto:** Final actions are solved automatically by RenderingDevice.
.. _class_RenderingDevice_constant_FINAL_ACTION_CONTINUE:
.. rst-class:: classref-enumeration-constant
:ref:`FinalAction<enum_RenderingDevice_FinalAction>` **FINAL_ACTION_CONTINUE** = ``0``
**Obsoleto:** Final actions are solved automatically by RenderingDevice.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_ShaderStage:
.. rst-class:: classref-enumeration
enum **ShaderStage**: :ref:`🔗<enum_RenderingDevice_ShaderStage>`
.. _class_RenderingDevice_constant_SHADER_STAGE_VERTEX:
.. rst-class:: classref-enumeration-constant
:ref:`ShaderStage<enum_RenderingDevice_ShaderStage>` **SHADER_STAGE_VERTEX** = ``0``
Vertex shader stage. This can be used to manipulate vertices from a shader (but not create new vertices).
.. _class_RenderingDevice_constant_SHADER_STAGE_FRAGMENT:
.. rst-class:: classref-enumeration-constant
:ref:`ShaderStage<enum_RenderingDevice_ShaderStage>` **SHADER_STAGE_FRAGMENT** = ``1``
Fragment shader stage (called "pixel shader" in Direct3D). This can be used to manipulate pixels from a shader.
.. _class_RenderingDevice_constant_SHADER_STAGE_TESSELATION_CONTROL:
.. rst-class:: classref-enumeration-constant
:ref:`ShaderStage<enum_RenderingDevice_ShaderStage>` **SHADER_STAGE_TESSELATION_CONTROL** = ``2``
Tessellation control shader stage. This can be used to create additional geometry from a shader.
.. _class_RenderingDevice_constant_SHADER_STAGE_TESSELATION_EVALUATION:
.. rst-class:: classref-enumeration-constant
:ref:`ShaderStage<enum_RenderingDevice_ShaderStage>` **SHADER_STAGE_TESSELATION_EVALUATION** = ``3``
Tessellation evaluation shader stage. This can be used to create additional geometry from a shader.
.. _class_RenderingDevice_constant_SHADER_STAGE_COMPUTE:
.. rst-class:: classref-enumeration-constant
:ref:`ShaderStage<enum_RenderingDevice_ShaderStage>` **SHADER_STAGE_COMPUTE** = ``4``
Compute shader stage. This can be used to run arbitrary computing tasks in a shader, performing them on the GPU instead of the CPU.
.. _class_RenderingDevice_constant_SHADER_STAGE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`ShaderStage<enum_RenderingDevice_ShaderStage>` **SHADER_STAGE_MAX** = ``5``
Representa el tamaño del enum :ref:`ShaderStage<enum_RenderingDevice_ShaderStage>`.
.. _class_RenderingDevice_constant_SHADER_STAGE_VERTEX_BIT:
.. rst-class:: classref-enumeration-constant
:ref:`ShaderStage<enum_RenderingDevice_ShaderStage>` **SHADER_STAGE_VERTEX_BIT** = ``1``
Vertex shader stage bit (see also :ref:`SHADER_STAGE_VERTEX<class_RenderingDevice_constant_SHADER_STAGE_VERTEX>`).
.. _class_RenderingDevice_constant_SHADER_STAGE_FRAGMENT_BIT:
.. rst-class:: classref-enumeration-constant
:ref:`ShaderStage<enum_RenderingDevice_ShaderStage>` **SHADER_STAGE_FRAGMENT_BIT** = ``2``
Fragment shader stage bit (see also :ref:`SHADER_STAGE_FRAGMENT<class_RenderingDevice_constant_SHADER_STAGE_FRAGMENT>`).
.. _class_RenderingDevice_constant_SHADER_STAGE_TESSELATION_CONTROL_BIT:
.. rst-class:: classref-enumeration-constant
:ref:`ShaderStage<enum_RenderingDevice_ShaderStage>` **SHADER_STAGE_TESSELATION_CONTROL_BIT** = ``4``
Tessellation control shader stage bit (see also :ref:`SHADER_STAGE_TESSELATION_CONTROL<class_RenderingDevice_constant_SHADER_STAGE_TESSELATION_CONTROL>`).
.. _class_RenderingDevice_constant_SHADER_STAGE_TESSELATION_EVALUATION_BIT:
.. rst-class:: classref-enumeration-constant
:ref:`ShaderStage<enum_RenderingDevice_ShaderStage>` **SHADER_STAGE_TESSELATION_EVALUATION_BIT** = ``8``
Tessellation evaluation shader stage bit (see also :ref:`SHADER_STAGE_TESSELATION_EVALUATION<class_RenderingDevice_constant_SHADER_STAGE_TESSELATION_EVALUATION>`).
.. _class_RenderingDevice_constant_SHADER_STAGE_COMPUTE_BIT:
.. rst-class:: classref-enumeration-constant
:ref:`ShaderStage<enum_RenderingDevice_ShaderStage>` **SHADER_STAGE_COMPUTE_BIT** = ``16``
Compute shader stage bit (see also :ref:`SHADER_STAGE_COMPUTE<class_RenderingDevice_constant_SHADER_STAGE_COMPUTE>`).
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_ShaderLanguage:
.. rst-class:: classref-enumeration
enum **ShaderLanguage**: :ref:`🔗<enum_RenderingDevice_ShaderLanguage>`
.. _class_RenderingDevice_constant_SHADER_LANGUAGE_GLSL:
.. rst-class:: classref-enumeration-constant
:ref:`ShaderLanguage<enum_RenderingDevice_ShaderLanguage>` **SHADER_LANGUAGE_GLSL** = ``0``
Khronos' GLSL shading language (used natively by OpenGL and Vulkan). This is the language used for core Godot shaders.
.. _class_RenderingDevice_constant_SHADER_LANGUAGE_HLSL:
.. rst-class:: classref-enumeration-constant
:ref:`ShaderLanguage<enum_RenderingDevice_ShaderLanguage>` **SHADER_LANGUAGE_HLSL** = ``1``
Microsoft's High-Level Shading Language (used natively by Direct3D, but can also be used in Vulkan).
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_PipelineSpecializationConstantType:
.. rst-class:: classref-enumeration
enum **PipelineSpecializationConstantType**: :ref:`🔗<enum_RenderingDevice_PipelineSpecializationConstantType>`
.. _class_RenderingDevice_constant_PIPELINE_SPECIALIZATION_CONSTANT_TYPE_BOOL:
.. rst-class:: classref-enumeration-constant
:ref:`PipelineSpecializationConstantType<enum_RenderingDevice_PipelineSpecializationConstantType>` **PIPELINE_SPECIALIZATION_CONSTANT_TYPE_BOOL** = ``0``
Constante de especialización de bools.
.. _class_RenderingDevice_constant_PIPELINE_SPECIALIZATION_CONSTANT_TYPE_INT:
.. rst-class:: classref-enumeration-constant
:ref:`PipelineSpecializationConstantType<enum_RenderingDevice_PipelineSpecializationConstantType>` **PIPELINE_SPECIALIZATION_CONSTANT_TYPE_INT** = ``1``
Constante de especialización de ints.
.. _class_RenderingDevice_constant_PIPELINE_SPECIALIZATION_CONSTANT_TYPE_FLOAT:
.. rst-class:: classref-enumeration-constant
:ref:`PipelineSpecializationConstantType<enum_RenderingDevice_PipelineSpecializationConstantType>` **PIPELINE_SPECIALIZATION_CONSTANT_TYPE_FLOAT** = ``2``
Constante de especialización de punto flotante.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_Features:
.. rst-class:: classref-enumeration
enum **Features**: :ref:`🔗<enum_RenderingDevice_Features>`
.. _class_RenderingDevice_constant_SUPPORTS_METALFX_SPATIAL:
.. rst-class:: classref-enumeration-constant
:ref:`Features<enum_RenderingDevice_Features>` **SUPPORTS_METALFX_SPATIAL** = ``3``
Soporte para el escalado espacial de MetalFX.
.. _class_RenderingDevice_constant_SUPPORTS_METALFX_TEMPORAL:
.. rst-class:: classref-enumeration-constant
:ref:`Features<enum_RenderingDevice_Features>` **SUPPORTS_METALFX_TEMPORAL** = ``4``
Soporte para el escalado temporal de MetalFX.
.. _class_RenderingDevice_constant_SUPPORTS_BUFFER_DEVICE_ADDRESS:
.. rst-class:: classref-enumeration-constant
:ref:`Features<enum_RenderingDevice_Features>` **SUPPORTS_BUFFER_DEVICE_ADDRESS** = ``6``
Funciones de soporte para la extensión de la dirección del dispositivo de búfer.
.. _class_RenderingDevice_constant_SUPPORTS_IMAGE_ATOMIC_32_BIT:
.. rst-class:: classref-enumeration-constant
:ref:`Features<enum_RenderingDevice_Features>` **SUPPORTS_IMAGE_ATOMIC_32_BIT** = ``7``
Soporte para operaciones atómicas de imágenes de 32 bits.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_Limit:
.. rst-class:: classref-enumeration
enum **Limit**: :ref:`🔗<enum_RenderingDevice_Limit>`
.. _class_RenderingDevice_constant_LIMIT_MAX_BOUND_UNIFORM_SETS:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_BOUND_UNIFORM_SETS** = ``0``
Maximum number of uniform sets that can be bound at a given time.
.. _class_RenderingDevice_constant_LIMIT_MAX_FRAMEBUFFER_COLOR_ATTACHMENTS:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_FRAMEBUFFER_COLOR_ATTACHMENTS** = ``1``
Maximum number of color framebuffer attachments that can be used at a given time.
.. _class_RenderingDevice_constant_LIMIT_MAX_TEXTURES_PER_UNIFORM_SET:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_TEXTURES_PER_UNIFORM_SET** = ``2``
Maximum number of textures that can be used per uniform set.
.. _class_RenderingDevice_constant_LIMIT_MAX_SAMPLERS_PER_UNIFORM_SET:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_SAMPLERS_PER_UNIFORM_SET** = ``3``
Maximum number of samplers that can be used per uniform set.
.. _class_RenderingDevice_constant_LIMIT_MAX_STORAGE_BUFFERS_PER_UNIFORM_SET:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_STORAGE_BUFFERS_PER_UNIFORM_SET** = ``4``
Maximum number of `storage buffers <https://vkguide.dev/docs/chapter-4/storage_buffers/>`__ per uniform set.
.. _class_RenderingDevice_constant_LIMIT_MAX_STORAGE_IMAGES_PER_UNIFORM_SET:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_STORAGE_IMAGES_PER_UNIFORM_SET** = ``5``
Número máximo de imágenes de almacenamiento por conjunto de uniformes.
.. _class_RenderingDevice_constant_LIMIT_MAX_UNIFORM_BUFFERS_PER_UNIFORM_SET:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_UNIFORM_BUFFERS_PER_UNIFORM_SET** = ``6``
Número máximo de búferes de uniformes por conjunto de uniformes.
.. _class_RenderingDevice_constant_LIMIT_MAX_DRAW_INDEXED_INDEX:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_DRAW_INDEXED_INDEX** = ``7``
Índice máximo para un comando de dibujado indexado.
.. _class_RenderingDevice_constant_LIMIT_MAX_FRAMEBUFFER_HEIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_FRAMEBUFFER_HEIGHT** = ``8``
Altura máxima de un framebuffer (en píxeles).
.. _class_RenderingDevice_constant_LIMIT_MAX_FRAMEBUFFER_WIDTH:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_FRAMEBUFFER_WIDTH** = ``9``
Ancho máximo de un framebuffer (en píxeles).
.. _class_RenderingDevice_constant_LIMIT_MAX_TEXTURE_ARRAY_LAYERS:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_TEXTURE_ARRAY_LAYERS** = ``10``
Número máximo de capas de array de texturas.
.. _class_RenderingDevice_constant_LIMIT_MAX_TEXTURE_SIZE_1D:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_TEXTURE_SIZE_1D** = ``11``
Tamaño máximo de textura unidimensional soportado (en píxeles en un solo eje).
.. _class_RenderingDevice_constant_LIMIT_MAX_TEXTURE_SIZE_2D:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_TEXTURE_SIZE_2D** = ``12``
Tamaño máximo de textura bidimensional soportado (en píxeles en un solo eje).
.. _class_RenderingDevice_constant_LIMIT_MAX_TEXTURE_SIZE_3D:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_TEXTURE_SIZE_3D** = ``13``
Tamaño máximo de textura tridimensional soportado (en píxeles en un solo eje).
.. _class_RenderingDevice_constant_LIMIT_MAX_TEXTURE_SIZE_CUBE:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_TEXTURE_SIZE_CUBE** = ``14``
Tamaño máximo de textura cubemap soportado (en píxeles en un solo eje de una sola cara).
.. _class_RenderingDevice_constant_LIMIT_MAX_TEXTURES_PER_SHADER_STAGE:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_TEXTURES_PER_SHADER_STAGE** = ``15``
Número máximo de texturas por etapa de shader.
.. _class_RenderingDevice_constant_LIMIT_MAX_SAMPLERS_PER_SHADER_STAGE:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_SAMPLERS_PER_SHADER_STAGE** = ``16``
Número máximo de samplers por etapa de shader.
.. _class_RenderingDevice_constant_LIMIT_MAX_STORAGE_BUFFERS_PER_SHADER_STAGE:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_STORAGE_BUFFERS_PER_SHADER_STAGE** = ``17``
Número máximo de `búferes de almacenamiento <https://vkguide.dev/docs/chapter-4/storage_buffers/>`__ por etapa de shader.
.. _class_RenderingDevice_constant_LIMIT_MAX_STORAGE_IMAGES_PER_SHADER_STAGE:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_STORAGE_IMAGES_PER_SHADER_STAGE** = ``18``
Número máximo de imágenes de almacenamiento por etapa de shader.
.. _class_RenderingDevice_constant_LIMIT_MAX_UNIFORM_BUFFERS_PER_SHADER_STAGE:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_UNIFORM_BUFFERS_PER_SHADER_STAGE** = ``19``
Número máximo de búferes de uniformes por conjunto de uniformes.
.. _class_RenderingDevice_constant_LIMIT_MAX_PUSH_CONSTANT_SIZE:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_PUSH_CONSTANT_SIZE** = ``20``
Tamaño máximo de una push constante. Muchos dispositivos están limitados a 128 bytes, así que intenta no exceder los 128 bytes en las constantes push para asegurar la compatibilidad incluso si tu GPU reporta un valor más alto.
.. _class_RenderingDevice_constant_LIMIT_MAX_UNIFORM_BUFFER_SIZE:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_UNIFORM_BUFFER_SIZE** = ``21``
Tamaño máximo de un búfer de uniformes.
.. _class_RenderingDevice_constant_LIMIT_MAX_VERTEX_INPUT_ATTRIBUTE_OFFSET:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_VERTEX_INPUT_ATTRIBUTE_OFFSET** = ``22``
Desplazamiento máximo del atributo de entrada de vértice.
.. _class_RenderingDevice_constant_LIMIT_MAX_VERTEX_INPUT_ATTRIBUTES:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_VERTEX_INPUT_ATTRIBUTES** = ``23``
Maximum number of vertex input attributes.
.. _class_RenderingDevice_constant_LIMIT_MAX_VERTEX_INPUT_BINDINGS:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_VERTEX_INPUT_BINDINGS** = ``24``
Maximum number of vertex input bindings.
.. _class_RenderingDevice_constant_LIMIT_MAX_VERTEX_INPUT_BINDING_STRIDE:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_VERTEX_INPUT_BINDING_STRIDE** = ``25``
Paso máximo del enlace de entrada de vértice.
.. _class_RenderingDevice_constant_LIMIT_MIN_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MIN_UNIFORM_BUFFER_OFFSET_ALIGNMENT** = ``26``
Alineación mínima del desplazamiento del búfer uniforme.
.. _class_RenderingDevice_constant_LIMIT_MAX_COMPUTE_SHARED_MEMORY_SIZE:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_COMPUTE_SHARED_MEMORY_SIZE** = ``27``
Tamaño máximo de la memoria compartida para los shaders de cómputo.
.. _class_RenderingDevice_constant_LIMIT_MAX_COMPUTE_WORKGROUP_COUNT_X:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_COMPUTE_WORKGROUP_COUNT_X** = ``28``
Número máximo de grupos de trabajo para los shaders de cómputo en el eje X.
.. _class_RenderingDevice_constant_LIMIT_MAX_COMPUTE_WORKGROUP_COUNT_Y:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_COMPUTE_WORKGROUP_COUNT_Y** = ``29``
Número máximo de grupos de trabajo para los shaders de cómputo en el eje Y.
.. _class_RenderingDevice_constant_LIMIT_MAX_COMPUTE_WORKGROUP_COUNT_Z:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_COMPUTE_WORKGROUP_COUNT_Z** = ``30``
Número máximo de grupos de trabajo para los shaders de cómputo en el eje Z.
.. _class_RenderingDevice_constant_LIMIT_MAX_COMPUTE_WORKGROUP_INVOCATIONS:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_COMPUTE_WORKGROUP_INVOCATIONS** = ``31``
Maximum number of workgroup invocations for compute shaders.
.. _class_RenderingDevice_constant_LIMIT_MAX_COMPUTE_WORKGROUP_SIZE_X:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_COMPUTE_WORKGROUP_SIZE_X** = ``32``
Maximum workgroup size for compute shaders on the X axis.
.. _class_RenderingDevice_constant_LIMIT_MAX_COMPUTE_WORKGROUP_SIZE_Y:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_COMPUTE_WORKGROUP_SIZE_Y** = ``33``
Maximum workgroup size for compute shaders on the Y axis.
.. _class_RenderingDevice_constant_LIMIT_MAX_COMPUTE_WORKGROUP_SIZE_Z:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_COMPUTE_WORKGROUP_SIZE_Z** = ``34``
Maximum workgroup size for compute shaders on the Z axis.
.. _class_RenderingDevice_constant_LIMIT_MAX_VIEWPORT_DIMENSIONS_X:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_VIEWPORT_DIMENSIONS_X** = ``35``
Ancho máximo del viewport (en píxeles).
.. _class_RenderingDevice_constant_LIMIT_MAX_VIEWPORT_DIMENSIONS_Y:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_VIEWPORT_DIMENSIONS_Y** = ``36``
Maximum viewport height (in pixels).
.. _class_RenderingDevice_constant_LIMIT_METALFX_TEMPORAL_SCALER_MIN_SCALE:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_METALFX_TEMPORAL_SCALER_MIN_SCALE** = ``46``
Returns the smallest value for :ref:`ProjectSettings.rendering/scaling_3d/scale<class_ProjectSettings_property_rendering/scaling_3d/scale>` when using the MetalFX temporal upscaler.
\ **Note:** The returned value is multiplied by a factor of ``1000000`` to preserve 6 digits of precision. It must be divided by ``1000000.0`` to convert the value to a floating point number.
.. _class_RenderingDevice_constant_LIMIT_METALFX_TEMPORAL_SCALER_MAX_SCALE:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_METALFX_TEMPORAL_SCALER_MAX_SCALE** = ``47``
Returns the largest value for :ref:`ProjectSettings.rendering/scaling_3d/scale<class_ProjectSettings_property_rendering/scaling_3d/scale>` when using the MetalFX temporal upscaler.
\ **Note:** The returned value is multiplied by a factor of ``1000000`` to preserve 6 digits of precision. It must be divided by ``1000000.0`` to convert the value to a floating point number.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_MemoryType:
.. rst-class:: classref-enumeration
enum **MemoryType**: :ref:`🔗<enum_RenderingDevice_MemoryType>`
.. _class_RenderingDevice_constant_MEMORY_TEXTURES:
.. rst-class:: classref-enumeration-constant
:ref:`MemoryType<enum_RenderingDevice_MemoryType>` **MEMORY_TEXTURES** = ``0``
La memoria utilizada por las texturas.
.. _class_RenderingDevice_constant_MEMORY_BUFFERS:
.. rst-class:: classref-enumeration-constant
:ref:`MemoryType<enum_RenderingDevice_MemoryType>` **MEMORY_BUFFERS** = ``1``
Memory taken by buffers.
.. _class_RenderingDevice_constant_MEMORY_TOTAL:
.. rst-class:: classref-enumeration-constant
:ref:`MemoryType<enum_RenderingDevice_MemoryType>` **MEMORY_TOTAL** = ``2``
Total memory taken. This is greater than the sum of :ref:`MEMORY_TEXTURES<class_RenderingDevice_constant_MEMORY_TEXTURES>` and :ref:`MEMORY_BUFFERS<class_RenderingDevice_constant_MEMORY_BUFFERS>`, as it also includes miscellaneous memory usage.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_BreadcrumbMarker:
.. rst-class:: classref-enumeration
enum **BreadcrumbMarker**: :ref:`🔗<enum_RenderingDevice_BreadcrumbMarker>`
.. _class_RenderingDevice_constant_NONE:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **NONE** = ``0``
No breadcrumb marker will be added.
.. _class_RenderingDevice_constant_REFLECTION_PROBES:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **REFLECTION_PROBES** = ``65536``
During a GPU crash in dev or debug mode, Godot's error message will include ``"REFLECTION_PROBES"`` for added context as to when the crash occurred.
.. _class_RenderingDevice_constant_SKY_PASS:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **SKY_PASS** = ``131072``
During a GPU crash in dev or debug mode, Godot's error message will include ``"SKY_PASS"`` for added context as to when the crash occurred.
.. _class_RenderingDevice_constant_LIGHTMAPPER_PASS:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **LIGHTMAPPER_PASS** = ``196608``
During a GPU crash in dev or debug mode, Godot's error message will include ``"LIGHTMAPPER_PASS"`` for added context as to when the crash occurred.
.. _class_RenderingDevice_constant_SHADOW_PASS_DIRECTIONAL:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **SHADOW_PASS_DIRECTIONAL** = ``262144``
During a GPU crash in dev or debug mode, Godot's error message will include ``"SHADOW_PASS_DIRECTIONAL"`` for added context as to when the crash occurred.
.. _class_RenderingDevice_constant_SHADOW_PASS_CUBE:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **SHADOW_PASS_CUBE** = ``327680``
During a GPU crash in dev or debug mode, Godot's error message will include ``"SHADOW_PASS_CUBE"`` for added context as to when the crash occurred.
.. _class_RenderingDevice_constant_OPAQUE_PASS:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **OPAQUE_PASS** = ``393216``
During a GPU crash in dev or debug mode, Godot's error message will include ``"OPAQUE_PASS"`` for added context as to when the crash occurred.
.. _class_RenderingDevice_constant_ALPHA_PASS:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **ALPHA_PASS** = ``458752``
Durante un fallo de la GPU en modo de desarrollo o depuración, el mensaje de error de Godot incluirá ``"ALPHA_PASS"`` para añadir contexto de cuándo ocurrió el fallo.
.. _class_RenderingDevice_constant_TRANSPARENT_PASS:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **TRANSPARENT_PASS** = ``524288``
Durante un fallo de la GPU en modo de desarrollo o depuración, el mensaje de error de Godot incluirá ``"TRANSPARENT_PASS"`` para añadir contexto de cuándo ocurrió el fallo.
.. _class_RenderingDevice_constant_POST_PROCESSING_PASS:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **POST_PROCESSING_PASS** = ``589824``
Durante un fallo de la GPU en modo de desarrollo o depuración, el mensaje de error de Godot incluirá ``"POST_PROCESSING_PASS"`` para añadir contexto de cuándo ocurrió el fallo.
.. _class_RenderingDevice_constant_BLIT_PASS:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **BLIT_PASS** = ``655360``
Durante un fallo de la GPU en modo de desarrollo o depuración, el mensaje de error de Godot incluirá ``"BLIT_PASS"`` para añadir contexto de cuándo ocurrió el fallo.
.. _class_RenderingDevice_constant_UI_PASS:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **UI_PASS** = ``720896``
Durante un fallo de la GPU en modo de desarrollo o depuración, el mensaje de error de Godot incluirá ``"UI_PASS"`` para añadir contexto de cuándo ocurrió el fallo.
.. _class_RenderingDevice_constant_DEBUG_PASS:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **DEBUG_PASS** = ``786432``
Durante un fallo de la GPU en modo de desarrollo o depuración, el mensaje de error de Godot incluirá ``"DEBUG_PASS"`` para añadir contexto de cuándo ocurrió el fallo.
.. rst-class:: classref-item-separator
----
.. _enum_RenderingDevice_DrawFlags:
.. rst-class:: classref-enumeration
flags **DrawFlags**: :ref:`🔗<enum_RenderingDevice_DrawFlags>`
.. _class_RenderingDevice_constant_DRAW_DEFAULT_ALL:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_DEFAULT_ALL** = ``0``
No limpiar ni ignorar ningún adjunto.
.. _class_RenderingDevice_constant_DRAW_CLEAR_COLOR_0:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_COLOR_0** = ``1``
Limpia el primer adjunto de color.
.. _class_RenderingDevice_constant_DRAW_CLEAR_COLOR_1:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_COLOR_1** = ``2``
Limpia el segundo adjunto de color.
.. _class_RenderingDevice_constant_DRAW_CLEAR_COLOR_2:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_COLOR_2** = ``4``
Limpia el tercer adjunto de color.
.. _class_RenderingDevice_constant_DRAW_CLEAR_COLOR_3:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_COLOR_3** = ``8``
Limpia el cuarto adjunto de color.
.. _class_RenderingDevice_constant_DRAW_CLEAR_COLOR_4:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_COLOR_4** = ``16``
Limpia el quinto adjunto de color.
.. _class_RenderingDevice_constant_DRAW_CLEAR_COLOR_5:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_COLOR_5** = ``32``
Limpia el sexto adjunto de color.
.. _class_RenderingDevice_constant_DRAW_CLEAR_COLOR_6:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_COLOR_6** = ``64``
Limpia el séptimo adjunto de color.
.. _class_RenderingDevice_constant_DRAW_CLEAR_COLOR_7:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_COLOR_7** = ``128``
Limpia el octavo adjunto de color.
.. _class_RenderingDevice_constant_DRAW_CLEAR_COLOR_MASK:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_COLOR_MASK** = ``255``
Máscara para limpiar todos los adjuntos de color.
.. _class_RenderingDevice_constant_DRAW_CLEAR_COLOR_ALL:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_COLOR_ALL** = ``255``
Limpia todos los adjuntos de color.
.. _class_RenderingDevice_constant_DRAW_IGNORE_COLOR_0:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_COLOR_0** = ``256``
Ignora el contenido anterior del primer adjunto de color.
.. _class_RenderingDevice_constant_DRAW_IGNORE_COLOR_1:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_COLOR_1** = ``512``
Ignora el contenido anterior del segundo adjunto de color.
.. _class_RenderingDevice_constant_DRAW_IGNORE_COLOR_2:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_COLOR_2** = ``1024``
Ignora el contenido anterior del tercer adjunto de color.
.. _class_RenderingDevice_constant_DRAW_IGNORE_COLOR_3:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_COLOR_3** = ``2048``
Ignora el contenido anterior del cuarto adjunto de color.
.. _class_RenderingDevice_constant_DRAW_IGNORE_COLOR_4:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_COLOR_4** = ``4096``
Ignora el contenido anterior del quinto adjunto de color.
.. _class_RenderingDevice_constant_DRAW_IGNORE_COLOR_5:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_COLOR_5** = ``8192``
Ignora el contenido anterior del sexto adjunto de color.
.. _class_RenderingDevice_constant_DRAW_IGNORE_COLOR_6:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_COLOR_6** = ``16384``
Ignora el contenido anterior del séptimo adjunto de color.
.. _class_RenderingDevice_constant_DRAW_IGNORE_COLOR_7:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_COLOR_7** = ``32768``
Ignora el contenido anterior del octavo adjunto de color.
.. _class_RenderingDevice_constant_DRAW_IGNORE_COLOR_MASK:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_COLOR_MASK** = ``65280``
Máscara para ignorar todo el contenido anterior de los adjuntos de color.
.. _class_RenderingDevice_constant_DRAW_IGNORE_COLOR_ALL:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_COLOR_ALL** = ``65280``
Ignora el contenido anterior de todos los adjuntos de color.
.. _class_RenderingDevice_constant_DRAW_CLEAR_DEPTH:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_DEPTH** = ``65536``
Limpia el adjunto de profundidad.
.. _class_RenderingDevice_constant_DRAW_IGNORE_DEPTH:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_DEPTH** = ``131072``
Ignora el contenido anterior del adjunto de profundidad.
.. _class_RenderingDevice_constant_DRAW_CLEAR_STENCIL:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_STENCIL** = ``262144``
Limpia el adjunto de esténcil.
.. _class_RenderingDevice_constant_DRAW_IGNORE_STENCIL:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_STENCIL** = ``524288``
Ignora el contenido anterior del adjunto de esténcil.
.. _class_RenderingDevice_constant_DRAW_CLEAR_ALL:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_ALL** = ``327935``
Limpia todos los adjuntos.
.. _class_RenderingDevice_constant_DRAW_IGNORE_ALL:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_ALL** = ``720640``
Ignora el contenido anterior de todos los adjuntos.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Constantes
--------------------
.. _class_RenderingDevice_constant_INVALID_ID:
.. rst-class:: classref-constant
**INVALID_ID** = ``-1`` :ref:`🔗<class_RenderingDevice_constant_INVALID_ID>`
Returned by functions that return an ID if a value is invalid.
.. _class_RenderingDevice_constant_INVALID_FORMAT_ID:
.. rst-class:: classref-constant
**INVALID_FORMAT_ID** = ``-1`` :ref:`🔗<class_RenderingDevice_constant_INVALID_FORMAT_ID>`
Returned by functions that return a format ID if a value is invalid.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Métodos
------------------------------------------------
.. _class_RenderingDevice_method_barrier:
.. rst-class:: classref-method
|void| **barrier**\ (\ from\: |bitfield|\[:ref:`BarrierMask<enum_RenderingDevice_BarrierMask>`\] = 32767, to\: |bitfield|\[:ref:`BarrierMask<enum_RenderingDevice_BarrierMask>`\] = 32767\ ) :ref:`🔗<class_RenderingDevice_method_barrier>`
**Obsoleto:** Barriers are automatically inserted by RenderingDevice.
Este método no hace nada.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_buffer_clear:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **buffer_clear**\ (\ buffer\: :ref:`RID<class_RID>`, offset\: :ref:`int<class_int>`, size_bytes\: :ref:`int<class_int>`\ ) :ref:`🔗<class_RenderingDevice_method_buffer_clear>`
Borra el contenido del ``buffer``, borrando ``size_bytes`` bytes, empezando en ``offset``.
Imprime un error si:
- el tamaño no es múltiplo de cuatro
- la región especificada por ``offset`` + ``size_bytes`` excede el búfer
- una lista de dibujado está actualmente activa (creada por :ref:`draw_list_begin()<class_RenderingDevice_method_draw_list_begin>`)
- una lista de cálculo está actualmente activa (creada por :ref:`compute_list_begin()<class_RenderingDevice_method_compute_list_begin>`)
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_buffer_copy:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **buffer_copy**\ (\ src_buffer\: :ref:`RID<class_RID>`, dst_buffer\: :ref:`RID<class_RID>`, src_offset\: :ref:`int<class_int>`, dst_offset\: :ref:`int<class_int>`, size\: :ref:`int<class_int>`\ ) :ref:`🔗<class_RenderingDevice_method_buffer_copy>`
Copia ``size`` bytes desde el ``src_buffer`` en ``src_offset`` a ``dst_buffer`` en ``dst_offset``.
Imprime un error si:
- ``size`` excede el tamaño de ``src_buffer`` o ``dst_buffer`` en sus correspondientes desplazamientos.
- una lista de dibujado está actualmente activa (creada por :ref:`draw_list_begin()<class_RenderingDevice_method_draw_list_begin>`)
- una lista de cálculo está actualmente activa (creada por :ref:`compute_list_begin()<class_RenderingDevice_method_compute_list_begin>`)
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_buffer_get_data:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **buffer_get_data**\ (\ buffer\: :ref:`RID<class_RID>`, offset_bytes\: :ref:`int<class_int>` = 0, size_bytes\: :ref:`int<class_int>` = 0\ ) :ref:`🔗<class_RenderingDevice_method_buffer_get_data>`
Devuelve una copia de los datos del ``buffer`` especificado, opcionalmente se puede establecer ``offset_bytes`` y ``size_bytes`` para copiar solo una parte del búfer.
\ **Nota:** Este método bloqueará el trabajo de la GPU hasta que se recuperen los datos. Véase :ref:`buffer_get_data_async()<class_RenderingDevice_method_buffer_get_data_async>` para obtener una alternativa que devuelve los datos de forma más eficiente.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_buffer_get_data_async:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **buffer_get_data_async**\ (\ buffer\: :ref:`RID<class_RID>`, callback\: :ref:`Callable<class_Callable>`, offset_bytes\: :ref:`int<class_int>` = 0, size_bytes\: :ref:`int<class_int>` = 0\ ) :ref:`🔗<class_RenderingDevice_method_buffer_get_data_async>`
Versión asíncrona de :ref:`buffer_get_data()<class_RenderingDevice_method_buffer_get_data>`. RenderingDevice llamará a ``callback`` en una cierta cantidad de fotogramas con los datos que tenía el búfer en el momento de la solicitud.
\ **Nota:** Por el momento, el retardo corresponde a la cantidad de fotogramas especificada por :ref:`ProjectSettings.rendering/rendering_device/vsync/frame_queue_size<class_ProjectSettings_property_rendering/rendering_device/vsync/frame_queue_size>`.
\ **Nota:** La descarga de búferes grandes puede tener un coste prohibitivo para el tiempo real, incluso cuando se utiliza el método asíncrono debido a las limitaciones del ancho de banda del hardware. Cuando se trata de recursos grandes, puedes ajustar ajustes como :ref:`ProjectSettings.rendering/rendering_device/staging_buffer/block_size_kb<class_ProjectSettings_property_rendering/rendering_device/staging_buffer/block_size_kb>` para mejorar la velocidad de transferencia a costa de memoria adicional.
::
func _buffer_get_data_callback(array):
value = array.decode_u32(0)
...
rd.buffer_get_data_async(buffer, _buffer_get_data_callback)
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_buffer_get_device_address:
.. rst-class:: classref-method
:ref:`int<class_int>` **buffer_get_device_address**\ (\ buffer\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_RenderingDevice_method_buffer_get_device_address>`
Devuelve la dirección del ``buffer`` dado que puede ser pasado a los shaders de cualquier manera para acceder a los datos subyacentes. El búfer debe haber sido creado con esta característica habilitada.
\ **Nota:** Debes comprobar que la GPU soporta esta funcionalidad llamando a :ref:`has_feature()<class_RenderingDevice_method_has_feature>` con :ref:`SUPPORTS_BUFFER_DEVICE_ADDRESS<class_RenderingDevice_constant_SUPPORTS_BUFFER_DEVICE_ADDRESS>` como parámetro.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_buffer_update:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **buffer_update**\ (\ buffer\: :ref:`RID<class_RID>`, offset\: :ref:`int<class_int>`, size_bytes\: :ref:`int<class_int>`, data\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) :ref:`🔗<class_RenderingDevice_method_buffer_update>`
Actualiza una región de ``size_bytes`` bytes, comenzando en ``offset``, en el búfer, con los ``data`` especificados.
Imprime un error si:
- la región especificada por ``offset`` + ``size_bytes`` excede el búfer
- una lista de dibujado está actualmente activa (creada por :ref:`draw_list_begin()<class_RenderingDevice_method_draw_list_begin>`)
- una lista de cálculo está actualmente activa (creada por :ref:`compute_list_begin()<class_RenderingDevice_method_compute_list_begin>`)
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_capture_timestamp:
.. rst-class:: classref-method
|void| **capture_timestamp**\ (\ name\: :ref:`String<class_String>`\ ) :ref:`🔗<class_RenderingDevice_method_capture_timestamp>`
Crea un marcador de tiempo con el ``name`` especificado. Esto se utiliza para informar del rendimiento con los métodos :ref:`get_captured_timestamp_cpu_time()<class_RenderingDevice_method_get_captured_timestamp_cpu_time>`, :ref:`get_captured_timestamp_gpu_time()<class_RenderingDevice_method_get_captured_timestamp_gpu_time>` y :ref:`get_captured_timestamp_name()<class_RenderingDevice_method_get_captured_timestamp_name>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_compute_list_add_barrier:
.. rst-class:: classref-method
|void| **compute_list_add_barrier**\ (\ compute_list\: :ref:`int<class_int>`\ ) :ref:`🔗<class_RenderingDevice_method_compute_list_add_barrier>`
Eleva una barrera de cálculo Vulkan en la ``compute_list`` especificada.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_compute_list_begin:
.. rst-class:: classref-method
:ref:`int<class_int>` **compute_list_begin**\ (\ ) :ref:`🔗<class_RenderingDevice_method_compute_list_begin>`
Inicia una lista de comandos de cálculo creados con los métodos ``compute_*``. El valor devuelto debe pasarse a otras funciones ``compute_list_*``.
No se pueden crear varias listas de cálculo al mismo tiempo; primero debes terminar la lista de cálculo anterior usando :ref:`compute_list_end()<class_RenderingDevice_method_compute_list_end>`.
Una operación de cálculo simple podría ser así (el código no es un ejemplo completo):
::
var rd = RenderingDevice.new()
var compute_list = rd.compute_list_begin()
rd.compute_list_bind_compute_pipeline(compute_list, compute_shader_dilate_pipeline)
rd.compute_list_bind_uniform_set(compute_list, compute_base_uniform_set, 0)
rd.compute_list_bind_uniform_set(compute_list, dilate_uniform_set, 1)
for i in atlas_slices:
rd.compute_list_set_push_constant(compute_list, push_constant, push_constant.size())
rd.compute_list_dispatch(compute_list, group_size.x, group_size.y, group_size.z)
# Sin barrera, dejarlos correr a todos juntos.
rd.compute_list_end()
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_compute_list_bind_compute_pipeline:
.. rst-class:: classref-method
|void| **compute_list_bind_compute_pipeline**\ (\ compute_list\: :ref:`int<class_int>`, compute_pipeline\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_RenderingDevice_method_compute_list_bind_compute_pipeline>`
Le dice a la GPU qué pipeline de cálculo usar al procesar la lista de cálculo. Si el shader ha cambiado desde la última vez que se llamó a esta función, Godot desvinculará todos los conjuntos de descriptores y los volverá a vincular dentro de :ref:`compute_list_dispatch()<class_RenderingDevice_method_compute_list_dispatch>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_compute_list_bind_uniform_set:
.. rst-class:: classref-method
|void| **compute_list_bind_uniform_set**\ (\ compute_list\: :ref:`int<class_int>`, uniform_set\: :ref:`RID<class_RID>`, set_index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_RenderingDevice_method_compute_list_bind_uniform_set>`
Vincula el ``uniform_set`` a esta ``compute_list``. Godot se asegura de que todas las texturas en el conjunto uniforme tengan las máscaras de acceso Vulkan correctas. Si Godot tuvo que cambiar las máscaras de acceso de las texturas, elevará una barrera de memoria de imagen Vulkan.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_compute_list_dispatch:
.. rst-class:: classref-method
|void| **compute_list_dispatch**\ (\ compute_list\: :ref:`int<class_int>`, x_groups\: :ref:`int<class_int>`, y_groups\: :ref:`int<class_int>`, z_groups\: :ref:`int<class_int>`\ ) :ref:`🔗<class_RenderingDevice_method_compute_list_dispatch>`
Envía la lista de cálculo para su procesamiento en la GPU. Este es el equivalente de cálculo a :ref:`draw_list_draw()<class_RenderingDevice_method_draw_list_draw>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_compute_list_dispatch_indirect:
.. rst-class:: classref-method
|void| **compute_list_dispatch_indirect**\ (\ compute_list\: :ref:`int<class_int>`, buffer\: :ref:`RID<class_RID>`, offset\: :ref:`int<class_int>`\ ) :ref:`🔗<class_RenderingDevice_method_compute_list_dispatch_indirect>`
Envía la lista de cálculo para su procesamiento en la GPU con los conteos de grupos dados almacenados en el ``buffer`` en ``offset``. El búfer debe haber sido creado con el flag :ref:`STORAGE_BUFFER_USAGE_DISPATCH_INDIRECT<class_RenderingDevice_constant_STORAGE_BUFFER_USAGE_DISPATCH_INDIRECT>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_compute_list_end:
.. rst-class:: classref-method
|void| **compute_list_end**\ (\ ) :ref:`🔗<class_RenderingDevice_method_compute_list_end>`
Finaliza una lista de comandos de cálculo creados con los métodos ``compute_*``.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_compute_list_set_push_constant:
.. rst-class:: classref-method
|void| **compute_list_set_push_constant**\ (\ compute_list\: :ref:`int<class_int>`, buffer\: :ref:`PackedByteArray<class_PackedByteArray>`, size_bytes\: :ref:`int<class_int>`\ ) :ref:`🔗<class_RenderingDevice_method_compute_list_set_push_constant>`
Establece los datos constantes de inserción en ``buffer`` para la ``compute_list`` especificada. El shader determina cómo se utilizan estos datos binarios. El tamaño del búfer en bytes también debe especificarse en ``size_bytes`` (esto se puede obtener llamando al método :ref:`PackedByteArray.size()<class_PackedByteArray_method_size>` en el ``buffer`` pasado).
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_compute_pipeline_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **compute_pipeline_create**\ (\ shader\: :ref:`RID<class_RID>`, specialization_constants\: :ref:`Array<class_Array>`\[:ref:`RDPipelineSpecializationConstant<class_RDPipelineSpecializationConstant>`\] = []\ ) :ref:`🔗<class_RenderingDevice_method_compute_pipeline_create>`
Crea un nuevo pipeline de cómputo. Se puede acceder a él con el RID que se devuelve.
Una vez que hayas terminado con tu RID, querrás liberarlo usando el método :ref:`free_rid()<class_RenderingDevice_method_free_rid>` de RenderingDevice.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_compute_pipeline_is_valid:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **compute_pipeline_is_valid**\ (\ compute_pipeline\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_RenderingDevice_method_compute_pipeline_is_valid>`
Devuelve ``true`` si el pipeline de cómputo especificado por el RID ``compute_pipeline`` es válido, ``false`` en caso contrario.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_create_local_device:
.. rst-class:: classref-method
:ref:`RenderingDevice<class_RenderingDevice>` **create_local_device**\ (\ ) :ref:`🔗<class_RenderingDevice_method_create_local_device>`
Crea un nuevo **RenderingDevice** local. Esto es más útil para realizar operaciones de cómputo en la GPU independientemente del resto del motor.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_draw_command_begin_label:
.. rst-class:: classref-method
|void| **draw_command_begin_label**\ (\ name\: :ref:`String<class_String>`, color\: :ref:`Color<class_Color>`\ ) :ref:`🔗<class_RenderingDevice_method_draw_command_begin_label>`
Crea una región de etiqueta de depuración del búfer de comandos que se puede mostrar en herramientas de terceros como `RenderDoc <https://renderdoc.org/>`__. Todas las regiones deben terminar con una llamada a :ref:`draw_command_end_label()<class_RenderingDevice_method_draw_command_end_label>`. Cuando se ve desde la serie lineal de envíos a una sola cola, las llamadas a :ref:`draw_command_begin_label()<class_RenderingDevice_method_draw_command_begin_label>` y :ref:`draw_command_end_label()<class_RenderingDevice_method_draw_command_end_label>` deben coincidir y estar balanceadas.
La extensión Vulkan ``VK_EXT_DEBUG_UTILS_EXTENSION_NAME`` debe estar disponible y habilitada para que funcione la región de etiqueta de depuración del búfer de comandos. Véase también :ref:`draw_command_end_label()<class_RenderingDevice_method_draw_command_end_label>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_draw_command_end_label:
.. rst-class:: classref-method
|void| **draw_command_end_label**\ (\ ) :ref:`🔗<class_RenderingDevice_method_draw_command_end_label>`
Finaliza la región de etiqueta de depuración del búfer de comandos iniciada por una llamada a :ref:`draw_command_begin_label()<class_RenderingDevice_method_draw_command_begin_label>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_draw_command_insert_label:
.. rst-class:: classref-method
|void| **draw_command_insert_label**\ (\ name\: :ref:`String<class_String>`, color\: :ref:`Color<class_Color>`\ ) :ref:`🔗<class_RenderingDevice_method_draw_command_insert_label>`
**Obsoleto:** Inserting labels no longer applies due to command reordering.
Este método no hace nada.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_draw_list_begin:
.. rst-class:: classref-method
:ref:`int<class_int>` **draw_list_begin**\ (\ framebuffer\: :ref:`RID<class_RID>`, draw_flags\: |bitfield|\[:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>`\] = 0, clear_color_values\: :ref:`PackedColorArray<class_PackedColorArray>` = PackedColorArray(), clear_depth_value\: :ref:`float<class_float>` = 1.0, clear_stencil_value\: :ref:`int<class_int>` = 0, region\: :ref:`Rect2<class_Rect2>` = Rect2(0, 0, 0, 0), breadcrumb\: :ref:`int<class_int>` = 0\ ) :ref:`🔗<class_RenderingDevice_method_draw_list_begin>`
Starts a list of raster drawing commands created with the ``draw_*`` methods. The returned value should be passed to other ``draw_list_*`` functions.
Multiple draw lists cannot be created at the same time; you must finish the previous draw list first using :ref:`draw_list_end()<class_RenderingDevice_method_draw_list_end>`.
A simple drawing operation might look like this (code is not a complete example):
::
var rd = RenderingDevice.new()
var clear_colors = PackedColorArray([Color(0, 0, 0, 0), Color(0, 0, 0, 0), Color(0, 0, 0, 0)])
var draw_list = rd.draw_list_begin(framebuffers[i], RenderingDevice.CLEAR_COLOR_ALL, clear_colors, true, 1.0f, true, 0, Rect2(), RenderingDevice.OPAQUE_PASS)
# Draw opaque.
rd.draw_list_bind_render_pipeline(draw_list, raster_pipeline)
rd.draw_list_bind_uniform_set(draw_list, raster_base_uniform, 0)
rd.draw_list_set_push_constant(draw_list, raster_push_constant, raster_push_constant.size())
rd.draw_list_draw(draw_list, false, 1, slice_triangle_count[i] * 3)
# Draw wire.
rd.draw_list_bind_render_pipeline(draw_list, raster_pipeline_wire)
rd.draw_list_bind_uniform_set(draw_list, raster_base_uniform, 0)
rd.draw_list_set_push_constant(draw_list, raster_push_constant, raster_push_constant.size())
rd.draw_list_draw(draw_list, false, 1, slice_triangle_count[i] * 3)
rd.draw_list_end()
The ``draw_flags`` indicates if the texture attachments of the framebuffer should be cleared or ignored. Only one of the two flags can be used for each individual attachment. Ignoring an attachment means that any contents that existed before the draw list will be completely discarded, reducing the memory bandwidth used by the render pass but producing garbage results if the pixels aren't replaced. The default behavior allows the engine to figure out the right operation to use if the texture is discardable, which can result in increased performance. See :ref:`RDTextureFormat<class_RDTextureFormat>` or :ref:`texture_set_discardable()<class_RenderingDevice_method_texture_set_discardable>`.
The ``breadcrumb`` parameter can be an arbitrary 32-bit integer that is useful to diagnose GPU crashes. If Godot is built in dev or debug mode; when the GPU crashes Godot will dump all shaders that were being executed at the time of the crash and the breadcrumb is useful to diagnose what passes did those shaders belong to.
It does not affect rendering behavior and can be set to 0. It is recommended to use :ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` enumerations for consistency but it's not required. It is also possible to use bitwise operations to add extra data. e.g.
::
rd.draw_list_begin(fb[i], RenderingDevice.CLEAR_COLOR_ALL, clear_colors, true, 1.0f, true, 0, Rect2(), RenderingDevice.OPAQUE_PASS | 5)
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_draw_list_begin_for_screen:
.. rst-class:: classref-method
:ref:`int<class_int>` **draw_list_begin_for_screen**\ (\ screen\: :ref:`int<class_int>` = 0, clear_color\: :ref:`Color<class_Color>` = Color(0, 0, 0, 1)\ ) :ref:`🔗<class_RenderingDevice_method_draw_list_begin_for_screen>`
Variante de alto nivel de :ref:`draw_list_begin()<class_RenderingDevice_method_draw_list_begin>`, con los parámetros que se ajustan automáticamente para dibujar en la ventana especificada por el ID ``screen``.
\ **Nota:** No se puede utilizar con RenderingDevices locales, ya que estos no tienen una pantalla. Si se llama en un RenderingDevice local, :ref:`draw_list_begin_for_screen()<class_RenderingDevice_method_draw_list_begin_for_screen>` devuelve :ref:`INVALID_ID<class_RenderingDevice_constant_INVALID_ID>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_draw_list_begin_split:
.. rst-class:: classref-method
:ref:`PackedInt64Array<class_PackedInt64Array>` **draw_list_begin_split**\ (\ framebuffer\: :ref:`RID<class_RID>`, splits\: :ref:`int<class_int>`, initial_color_action\: :ref:`InitialAction<enum_RenderingDevice_InitialAction>`, final_color_action\: :ref:`FinalAction<enum_RenderingDevice_FinalAction>`, initial_depth_action\: :ref:`InitialAction<enum_RenderingDevice_InitialAction>`, final_depth_action\: :ref:`FinalAction<enum_RenderingDevice_FinalAction>`, clear_color_values\: :ref:`PackedColorArray<class_PackedColorArray>` = PackedColorArray(), clear_depth\: :ref:`float<class_float>` = 1.0, clear_stencil\: :ref:`int<class_int>` = 0, region\: :ref:`Rect2<class_Rect2>` = Rect2(0, 0, 0, 0), storage_textures\: :ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\] = []\ ) :ref:`🔗<class_RenderingDevice_method_draw_list_begin_split>`
**Obsoleto:** Split draw lists are used automatically by RenderingDevice.
Este método no hace nada y siempre devuelve un :ref:`PackedInt64Array<class_PackedInt64Array>` vacío.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_draw_list_bind_index_array:
.. rst-class:: classref-method
|void| **draw_list_bind_index_array**\ (\ draw_list\: :ref:`int<class_int>`, index_array\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_RenderingDevice_method_draw_list_bind_index_array>`
Vincula ``index_array`` a la ``draw_list`` especificada.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_draw_list_bind_render_pipeline:
.. rst-class:: classref-method
|void| **draw_list_bind_render_pipeline**\ (\ draw_list\: :ref:`int<class_int>`, render_pipeline\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_RenderingDevice_method_draw_list_bind_render_pipeline>`
Vincula ``render_pipeline`` a la ``draw_list`` especificada.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_draw_list_bind_uniform_set:
.. rst-class:: classref-method
|void| **draw_list_bind_uniform_set**\ (\ draw_list\: :ref:`int<class_int>`, uniform_set\: :ref:`RID<class_RID>`, set_index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_RenderingDevice_method_draw_list_bind_uniform_set>`
Vincula ``uniform_set`` a la ``draw_list`` especificada. También se debe especificar un ``set_index``, que es un identificador que comienza en ``0`` y que debe coincidir con el esperado por la lista de dibujado.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_draw_list_bind_vertex_array:
.. rst-class:: classref-method
|void| **draw_list_bind_vertex_array**\ (\ draw_list\: :ref:`int<class_int>`, vertex_array\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_RenderingDevice_method_draw_list_bind_vertex_array>`
Vincula ``vertex_array`` a la ``draw_list`` especificada.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_draw_list_disable_scissor:
.. rst-class:: classref-method
|void| **draw_list_disable_scissor**\ (\ draw_list\: :ref:`int<class_int>`\ ) :ref:`🔗<class_RenderingDevice_method_draw_list_disable_scissor>`
Elimina e inhabilita el rectángulo de tijera para la ``draw_list`` especificada. Véase también :ref:`draw_list_enable_scissor()<class_RenderingDevice_method_draw_list_enable_scissor>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_draw_list_draw:
.. rst-class:: classref-method
|void| **draw_list_draw**\ (\ draw_list\: :ref:`int<class_int>`, use_indices\: :ref:`bool<class_bool>`, instances\: :ref:`int<class_int>`, procedural_vertex_count\: :ref:`int<class_int>` = 0\ ) :ref:`🔗<class_RenderingDevice_method_draw_list_draw>`
Envía ``draw_list`` para renderizar en la GPU. Este es el equivalente raster a :ref:`compute_list_dispatch()<class_RenderingDevice_method_compute_list_dispatch>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_draw_list_draw_indirect:
.. rst-class:: classref-method
|void| **draw_list_draw_indirect**\ (\ draw_list\: :ref:`int<class_int>`, use_indices\: :ref:`bool<class_bool>`, buffer\: :ref:`RID<class_RID>`, offset\: :ref:`int<class_int>` = 0, draw_count\: :ref:`int<class_int>` = 1, stride\: :ref:`int<class_int>` = 0\ ) :ref:`🔗<class_RenderingDevice_method_draw_list_draw_indirect>`
Envía ``draw_list`` para renderizar en la GPU con los parámetros dados almacenados en el ``buffer`` en ``offset``. Los parámetros son enteros: conteo de vértices, conteo de instancias, primer vértice, primera instancia. Y cuando se usan índices: conteo de índices, conteo de instancias, primer índice, desplazamiento de vértice, primera instancia. El búfer debe haber sido creado con el flag :ref:`STORAGE_BUFFER_USAGE_DISPATCH_INDIRECT<class_RenderingDevice_constant_STORAGE_BUFFER_USAGE_DISPATCH_INDIRECT>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_draw_list_enable_scissor:
.. rst-class:: classref-method
|void| **draw_list_enable_scissor**\ (\ draw_list\: :ref:`int<class_int>`, rect\: :ref:`Rect2<class_Rect2>` = Rect2(0, 0, 0, 0)\ ) :ref:`🔗<class_RenderingDevice_method_draw_list_enable_scissor>`
Crea un rectángulo de tijera y lo habilita para la ``draw_list`` especificada. Los rectángulos de tijera se utilizan para el recorte descartando los fragmentos que caen fuera de una porción rectangular especificada de la pantalla. Véase también :ref:`draw_list_disable_scissor()<class_RenderingDevice_method_draw_list_disable_scissor>`.
\ **Nota:** El ``rect`` especificado se cruza automáticamente con las dimensiones de la pantalla, lo que significa que no puede exceder las dimensiones de la pantalla.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_draw_list_end:
.. rst-class:: classref-method
|void| **draw_list_end**\ (\ ) :ref:`🔗<class_RenderingDevice_method_draw_list_end>`
Finishes a list of raster drawing commands created with the ``draw_*`` methods.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_draw_list_set_blend_constants:
.. rst-class:: classref-method
|void| **draw_list_set_blend_constants**\ (\ draw_list\: :ref:`int<class_int>`, color\: :ref:`Color<class_Color>`\ ) :ref:`🔗<class_RenderingDevice_method_draw_list_set_blend_constants>`
Establece las constantes de mezcla para la ``draw_list`` especificada a ``color``. Las constantes de mezcla solo se utilizan si el pipeline gráfico se crea con el flag :ref:`DYNAMIC_STATE_BLEND_CONSTANTS<class_RenderingDevice_constant_DYNAMIC_STATE_BLEND_CONSTANTS>` establecido.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_draw_list_set_push_constant:
.. rst-class:: classref-method
|void| **draw_list_set_push_constant**\ (\ draw_list\: :ref:`int<class_int>`, buffer\: :ref:`PackedByteArray<class_PackedByteArray>`, size_bytes\: :ref:`int<class_int>`\ ) :ref:`🔗<class_RenderingDevice_method_draw_list_set_push_constant>`
Establece los datos constantes de inserción en ``buffer`` para la ``draw_list`` especificada. El shader determina cómo se utilizan estos datos binarios. El tamaño del búfer en bytes también debe especificarse en ``size_bytes`` (esto se puede obtener llamando al método :ref:`PackedByteArray.size()<class_PackedByteArray_method_size>` en el ``buffer`` pasado).
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_draw_list_switch_to_next_pass:
.. rst-class:: classref-method
:ref:`int<class_int>` **draw_list_switch_to_next_pass**\ (\ ) :ref:`🔗<class_RenderingDevice_method_draw_list_switch_to_next_pass>`
Cambia al siguiente pase de dibujado.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_draw_list_switch_to_next_pass_split:
.. rst-class:: classref-method
:ref:`PackedInt64Array<class_PackedInt64Array>` **draw_list_switch_to_next_pass_split**\ (\ splits\: :ref:`int<class_int>`\ ) :ref:`🔗<class_RenderingDevice_method_draw_list_switch_to_next_pass_split>`
**Obsoleto:** Split draw lists are used automatically by RenderingDevice.
Este método no hace nada y siempre devuelve un :ref:`PackedInt64Array<class_PackedInt64Array>` vacío.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_framebuffer_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **framebuffer_create**\ (\ textures\: :ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\], validate_with_format\: :ref:`int<class_int>` = -1, view_count\: :ref:`int<class_int>` = 1\ ) :ref:`🔗<class_RenderingDevice_method_framebuffer_create>`
Creates a new framebuffer. It can be accessed with the RID that is returned.
Once finished with your RID, you will want to free the RID using the RenderingDevice's :ref:`free_rid()<class_RenderingDevice_method_free_rid>` method.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_framebuffer_create_empty:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **framebuffer_create_empty**\ (\ size\: :ref:`Vector2i<class_Vector2i>`, samples\: :ref:`TextureSamples<enum_RenderingDevice_TextureSamples>` = 0, validate_with_format\: :ref:`int<class_int>` = -1\ ) :ref:`🔗<class_RenderingDevice_method_framebuffer_create_empty>`
Creates a new empty framebuffer. It can be accessed with the RID that is returned.
Once finished with your RID, you will want to free the RID using the RenderingDevice's :ref:`free_rid()<class_RenderingDevice_method_free_rid>` method.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_framebuffer_create_multipass:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **framebuffer_create_multipass**\ (\ textures\: :ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\], passes\: :ref:`Array<class_Array>`\[:ref:`RDFramebufferPass<class_RDFramebufferPass>`\], validate_with_format\: :ref:`int<class_int>` = -1, view_count\: :ref:`int<class_int>` = 1\ ) :ref:`🔗<class_RenderingDevice_method_framebuffer_create_multipass>`
Creates a new multipass framebuffer. It can be accessed with the RID that is returned.
Once finished with your RID, you will want to free the RID using the RenderingDevice's :ref:`free_rid()<class_RenderingDevice_method_free_rid>` method.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_framebuffer_format_create:
.. rst-class:: classref-method
:ref:`int<class_int>` **framebuffer_format_create**\ (\ attachments\: :ref:`Array<class_Array>`\[:ref:`RDAttachmentFormat<class_RDAttachmentFormat>`\], view_count\: :ref:`int<class_int>` = 1\ ) :ref:`🔗<class_RenderingDevice_method_framebuffer_format_create>`
Creates a new framebuffer format with the specified ``attachments`` and ``view_count``. Returns the new framebuffer's unique framebuffer format ID.
If ``view_count`` is greater than or equal to ``2``, enables multiview which is used for VR rendering. This requires support for the Vulkan multiview extension.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_framebuffer_format_create_empty:
.. rst-class:: classref-method
:ref:`int<class_int>` **framebuffer_format_create_empty**\ (\ samples\: :ref:`TextureSamples<enum_RenderingDevice_TextureSamples>` = 0\ ) :ref:`🔗<class_RenderingDevice_method_framebuffer_format_create_empty>`
Creates a new empty framebuffer format with the specified number of ``samples`` and returns its ID.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_framebuffer_format_create_multipass:
.. rst-class:: classref-method
:ref:`int<class_int>` **framebuffer_format_create_multipass**\ (\ attachments\: :ref:`Array<class_Array>`\[:ref:`RDAttachmentFormat<class_RDAttachmentFormat>`\], passes\: :ref:`Array<class_Array>`\[:ref:`RDFramebufferPass<class_RDFramebufferPass>`\], view_count\: :ref:`int<class_int>` = 1\ ) :ref:`🔗<class_RenderingDevice_method_framebuffer_format_create_multipass>`
Creates a multipass framebuffer format with the specified ``attachments``, ``passes`` and ``view_count`` and returns its ID. If ``view_count`` is greater than or equal to ``2``, enables multiview which is used for VR rendering. This requires support for the Vulkan multiview extension.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_framebuffer_format_get_texture_samples:
.. rst-class:: classref-method
:ref:`TextureSamples<enum_RenderingDevice_TextureSamples>` **framebuffer_format_get_texture_samples**\ (\ format\: :ref:`int<class_int>`, render_pass\: :ref:`int<class_int>` = 0\ ) :ref:`🔗<class_RenderingDevice_method_framebuffer_format_get_texture_samples>`
Devuelve el número de muestras de textura utilizadas para el ID de ``format`` del framebuffer dado (devuelto por :ref:`framebuffer_get_format()<class_RenderingDevice_method_framebuffer_get_format>`).
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_framebuffer_get_format:
.. rst-class:: classref-method
:ref:`int<class_int>` **framebuffer_get_format**\ (\ framebuffer\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_RenderingDevice_method_framebuffer_get_format>`
Devuelve el ID de formato del framebuffer especificado por el RID ``framebuffer``. Se garantiza que este ID es único para los mismos formatos y no es necesario liberarlo.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_framebuffer_is_valid:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **framebuffer_is_valid**\ (\ framebuffer\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_RenderingDevice_method_framebuffer_is_valid>`
Devuelve ``true`` si el framebuffer especificado por el RID ``framebuffer`` es válido, ``false`` en caso contrario.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_free_rid:
.. rst-class:: classref-method
|void| **free_rid**\ (\ rid\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_RenderingDevice_method_free_rid>`
Intenta liberar un objeto en el RenderingDevice. Para evitar fugas de memoria, se debe llamar a esto después de usar un objeto ya que la gestión de la memoria no se produce automáticamente cuando se utiliza RenderingDevice directamente.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_full_barrier:
.. rst-class:: classref-method
|void| **full_barrier**\ (\ ) :ref:`🔗<class_RenderingDevice_method_full_barrier>`
**Obsoleto:** Barriers are automatically inserted by RenderingDevice.
Este método no hace nada.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_get_captured_timestamp_cpu_time:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_captured_timestamp_cpu_time**\ (\ index\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_RenderingDevice_method_get_captured_timestamp_cpu_time>`
Devuelve la marca de tiempo en tiempo de CPU para el paso de renderizado especificado por ``index`` (en microsegundos desde que se inició el motor). Véase también :ref:`get_captured_timestamp_gpu_time()<class_RenderingDevice_method_get_captured_timestamp_gpu_time>` y :ref:`capture_timestamp()<class_RenderingDevice_method_capture_timestamp>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_get_captured_timestamp_gpu_time:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_captured_timestamp_gpu_time**\ (\ index\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_RenderingDevice_method_get_captured_timestamp_gpu_time>`
Devuelve la marca de tiempo en tiempo de GPU para el paso de renderizado especificado por ``index`` (en microsegundos desde que se inició el motor). Véase también :ref:`get_captured_timestamp_cpu_time()<class_RenderingDevice_method_get_captured_timestamp_cpu_time>` y :ref:`capture_timestamp()<class_RenderingDevice_method_capture_timestamp>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_get_captured_timestamp_name:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_captured_timestamp_name**\ (\ index\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_RenderingDevice_method_get_captured_timestamp_name>`
Devuelve el nombre de la marca de tiempo para el paso de renderizado especificado por ``index``. Véase también :ref:`capture_timestamp()<class_RenderingDevice_method_capture_timestamp>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_get_captured_timestamps_count:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_captured_timestamps_count**\ (\ ) |const| :ref:`🔗<class_RenderingDevice_method_get_captured_timestamps_count>`
Devuelve el número total de marcas de tiempo (pasos de renderizado) disponibles para la creación de perfiles.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_get_captured_timestamps_frame:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_captured_timestamps_frame**\ (\ ) |const| :ref:`🔗<class_RenderingDevice_method_get_captured_timestamps_frame>`
Devuelve el índice del último fotograma renderizado que tiene marcas de tiempo de renderizado disponibles para la consulta.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_get_device_allocation_count:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_device_allocation_count**\ (\ ) |const| :ref:`🔗<class_RenderingDevice_method_get_device_allocation_count>`
Devuelve cuántas asignaciones ha realizado la GPU para las estructuras internas del controlador.
Esto solo lo utiliza Vulkan en las compilaciones de depuración y puede devolver 0 cuando esta información no se rastrea o se desconoce.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_get_device_allocs_by_object_type:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_device_allocs_by_object_type**\ (\ type\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_RenderingDevice_method_get_device_allocs_by_object_type>`
Igual que :ref:`get_device_allocation_count()<class_RenderingDevice_method_get_device_allocation_count>` pero filtrado para un tipo de objeto dado.
El argumento de tipo debe estar en el rango ``[0; get_tracked_object_type_count - 1]``. Si :ref:`get_tracked_object_type_count()<class_RenderingDevice_method_get_tracked_object_type_count>` es 0, entonces el argumento de tipo se ignora y siempre devuelve 0.
Esto solo lo utiliza Vulkan en las compilaciones de depuración y puede devolver 0 cuando esta información no se rastrea o se desconoce.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_get_device_memory_by_object_type:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_device_memory_by_object_type**\ (\ type\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_RenderingDevice_method_get_device_memory_by_object_type>`
Igual que :ref:`get_device_total_memory()<class_RenderingDevice_method_get_device_total_memory>` pero filtrado para un tipo de objeto dado.
El argumento de tipo debe estar en el rango ``[0; get_tracked_object_type_count - 1]``. Si :ref:`get_tracked_object_type_count()<class_RenderingDevice_method_get_tracked_object_type_count>` es 0, entonces el argumento de tipo se ignora y siempre devuelve 0.
Esto solo lo utiliza Vulkan en las compilaciones de depuración y puede devolver 0 cuando esta información no se rastrea o se desconoce.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_get_device_name:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_device_name**\ (\ ) |const| :ref:`🔗<class_RenderingDevice_method_get_device_name>`
Devuelve el nombre del adaptador de vídeo (por ejemplo, "GeForce GTX 1080/PCIe/SSE2"). Equivalente a :ref:`RenderingServer.get_video_adapter_name()<class_RenderingServer_method_get_video_adapter_name>`. Véase también :ref:`get_device_vendor_name()<class_RenderingDevice_method_get_device_vendor_name>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_get_device_pipeline_cache_uuid:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_device_pipeline_cache_uuid**\ (\ ) |const| :ref:`🔗<class_RenderingDevice_method_get_device_pipeline_cache_uuid>`
Returns the universally unique identifier for the pipeline cache. This is used to cache shader files on disk, which avoids shader recompilations on subsequent engine runs. This UUID varies depending on the graphics card model, but also the driver version. Therefore, updating graphics drivers will invalidate the shader cache.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_get_device_total_memory:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_device_total_memory**\ (\ ) |const| :ref:`🔗<class_RenderingDevice_method_get_device_total_memory>`
Devuelve cuántos bytes está usando la GPU.
Esto solo lo utiliza Vulkan en las compilaciones de depuración y puede devolver 0 cuando esta información no se rastrea o se desconoce.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_get_device_vendor_name:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_device_vendor_name**\ (\ ) |const| :ref:`🔗<class_RenderingDevice_method_get_device_vendor_name>`
Devuelve el proveedor del adaptador de vídeo (por ejemplo, "NVIDIA Corporation"). Equivalente a :ref:`RenderingServer.get_video_adapter_vendor()<class_RenderingServer_method_get_video_adapter_vendor>`. Véase también :ref:`get_device_name()<class_RenderingDevice_method_get_device_name>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_get_driver_allocation_count:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_driver_allocation_count**\ (\ ) |const| :ref:`🔗<class_RenderingDevice_method_get_driver_allocation_count>`
Devuelve cuántas asignaciones ha realizado el controlador de la GPU para las estructuras internas del controlador.
Esto solo lo utiliza Vulkan en las compilaciones de depuración y puede devolver 0 cuando esta información no se rastrea o se desconoce.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_get_driver_allocs_by_object_type:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_driver_allocs_by_object_type**\ (\ type\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_RenderingDevice_method_get_driver_allocs_by_object_type>`
Igual que :ref:`get_driver_allocation_count()<class_RenderingDevice_method_get_driver_allocation_count>` pero filtrado para un tipo de objeto dado.
El argumento de tipo debe estar en el rango ``[0; get_tracked_object_type_count - 1]``. Si :ref:`get_tracked_object_type_count()<class_RenderingDevice_method_get_tracked_object_type_count>` es 0, entonces el argumento de tipo se ignora y siempre devuelve 0.
Esto solo lo utiliza Vulkan en las compilaciones de depuración y puede devolver 0 cuando esta información no se rastrea o se desconoce.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_get_driver_and_device_memory_report:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_driver_and_device_memory_report**\ (\ ) |const| :ref:`🔗<class_RenderingDevice_method_get_driver_and_device_memory_report>`
Devuelve un informe de string en formato CSV utilizando los siguientes métodos:
- :ref:`get_tracked_object_name()<class_RenderingDevice_method_get_tracked_object_name>`\
- :ref:`get_tracked_object_type_count()<class_RenderingDevice_method_get_tracked_object_type_count>`\
- :ref:`get_driver_total_memory()<class_RenderingDevice_method_get_driver_total_memory>`\
- :ref:`get_driver_allocation_count()<class_RenderingDevice_method_get_driver_allocation_count>`\
- :ref:`get_driver_memory_by_object_type()<class_RenderingDevice_method_get_driver_memory_by_object_type>`\
- :ref:`get_driver_allocs_by_object_type()<class_RenderingDevice_method_get_driver_allocs_by_object_type>`\
- :ref:`get_device_total_memory()<class_RenderingDevice_method_get_device_total_memory>`\
- :ref:`get_device_allocation_count()<class_RenderingDevice_method_get_device_allocation_count>`\
- :ref:`get_device_memory_by_object_type()<class_RenderingDevice_method_get_device_memory_by_object_type>`\
- :ref:`get_device_allocs_by_object_type()<class_RenderingDevice_method_get_device_allocs_by_object_type>`\
Esto solo lo utiliza Vulkan en las compilaciones de depuración. Godot también debe iniciarse con el ``--extra-gpu-memory-tracking`` :doc:`argumento de la línea de comandos <../tutorials/editor/command_line_tutorial>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_get_driver_memory_by_object_type:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_driver_memory_by_object_type**\ (\ type\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_RenderingDevice_method_get_driver_memory_by_object_type>`
Igual que :ref:`get_driver_total_memory()<class_RenderingDevice_method_get_driver_total_memory>` pero filtrado para un tipo de objeto dado.
El argumento de tipo debe estar en el rango ``[0; get_tracked_object_type_count - 1]``. Si :ref:`get_tracked_object_type_count()<class_RenderingDevice_method_get_tracked_object_type_count>` es 0, entonces el argumento de tipo se ignora y siempre devuelve 0.
Esto solo lo utiliza Vulkan en las compilaciones de depuración y puede devolver 0 cuando esta información no se rastrea o se desconoce.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_get_driver_resource:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_driver_resource**\ (\ resource\: :ref:`DriverResource<enum_RenderingDevice_DriverResource>`, rid\: :ref:`RID<class_RID>`, index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_RenderingDevice_method_get_driver_resource>`
Returns the unique identifier of the driver ``resource`` for the specified ``rid``. Some driver resource types ignore the specified ``rid``. ``index`` is always ignored but must be specified anyway.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_get_driver_total_memory:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_driver_total_memory**\ (\ ) |const| :ref:`🔗<class_RenderingDevice_method_get_driver_total_memory>`
Returns how much bytes the GPU driver is using for internal driver structures.
This is only used by Vulkan in debug builds and can return 0 when this information is not tracked or unknown.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_get_frame_delay:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_frame_delay**\ (\ ) |const| :ref:`🔗<class_RenderingDevice_method_get_frame_delay>`
Returns the frame count kept by the graphics API. Higher values result in higher input lag, but with more consistent throughput. For the main **RenderingDevice**, frames are cycled (usually 3 with triple-buffered V-Sync enabled). However, local **RenderingDevice**\ s only have 1 frame.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_get_memory_usage:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_memory_usage**\ (\ type\: :ref:`MemoryType<enum_RenderingDevice_MemoryType>`\ ) |const| :ref:`🔗<class_RenderingDevice_method_get_memory_usage>`
Returns the memory usage in bytes corresponding to the given ``type``. When using Vulkan, these statistics are calculated by `Vulkan Memory Allocator <https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator>`__.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_get_perf_report:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_perf_report**\ (\ ) |const| :ref:`🔗<class_RenderingDevice_method_get_perf_report>`
Returns a string with a performance report from the past frame. Updates every frame.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_get_tracked_object_name:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_tracked_object_name**\ (\ type_index\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_RenderingDevice_method_get_tracked_object_name>`
Returns the name of the type of object for the given ``type_index``. This value must be in range ``[0; get_tracked_object_type_count - 1]``. If :ref:`get_tracked_object_type_count()<class_RenderingDevice_method_get_tracked_object_type_count>` is 0, then type argument is ignored and always returns the same string.
The return value is important because it gives meaning to the types passed to :ref:`get_driver_memory_by_object_type()<class_RenderingDevice_method_get_driver_memory_by_object_type>`, :ref:`get_driver_allocs_by_object_type()<class_RenderingDevice_method_get_driver_allocs_by_object_type>`, :ref:`get_device_memory_by_object_type()<class_RenderingDevice_method_get_device_memory_by_object_type>`, and :ref:`get_device_allocs_by_object_type()<class_RenderingDevice_method_get_device_allocs_by_object_type>`. Examples of strings it can return (not exhaustive):
- DEVICE_MEMORY
- PIPELINE_CACHE
- SWAPCHAIN_KHR
- COMMAND_POOL
Thus if e.g. ``get_tracked_object_name(5)`` returns "COMMAND_POOL", then ``get_device_memory_by_object_type(5)`` returns the bytes used by the GPU for command pools.
This is only used by Vulkan in debug builds. Godot must also be started with the ``--extra-gpu-memory-tracking`` :doc:`command line argument <../tutorials/editor/command_line_tutorial>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_get_tracked_object_type_count:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_tracked_object_type_count**\ (\ ) |const| :ref:`🔗<class_RenderingDevice_method_get_tracked_object_type_count>`
Returns how many types of trackable objects there are.
This is only used by Vulkan in debug builds. Godot must also be started with the ``--extra-gpu-memory-tracking`` :doc:`command line argument <../tutorials/editor/command_line_tutorial>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_has_feature:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has_feature**\ (\ feature\: :ref:`Features<enum_RenderingDevice_Features>`\ ) |const| :ref:`🔗<class_RenderingDevice_method_has_feature>`
Returns ``true`` if the ``feature`` is supported by the GPU.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_index_array_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **index_array_create**\ (\ index_buffer\: :ref:`RID<class_RID>`, index_offset\: :ref:`int<class_int>`, index_count\: :ref:`int<class_int>`\ ) :ref:`🔗<class_RenderingDevice_method_index_array_create>`
Creates a new index array. It can be accessed with the RID that is returned.
Once finished with your RID, you will want to free the RID using the RenderingDevice's :ref:`free_rid()<class_RenderingDevice_method_free_rid>` method.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_index_buffer_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **index_buffer_create**\ (\ size_indices\: :ref:`int<class_int>`, format\: :ref:`IndexBufferFormat<enum_RenderingDevice_IndexBufferFormat>`, data\: :ref:`PackedByteArray<class_PackedByteArray>` = PackedByteArray(), use_restart_indices\: :ref:`bool<class_bool>` = false, creation_bits\: |bitfield|\[:ref:`BufferCreationBits<enum_RenderingDevice_BufferCreationBits>`\] = 0\ ) :ref:`🔗<class_RenderingDevice_method_index_buffer_create>`
Creates a new index buffer. It can be accessed with the RID that is returned.
Once finished with your RID, you will want to free the RID using the RenderingDevice's :ref:`free_rid()<class_RenderingDevice_method_free_rid>` method.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_limit_get:
.. rst-class:: classref-method
:ref:`int<class_int>` **limit_get**\ (\ limit\: :ref:`Limit<enum_RenderingDevice_Limit>`\ ) |const| :ref:`🔗<class_RenderingDevice_method_limit_get>`
Returns the value of the specified ``limit``. This limit varies depending on the current graphics hardware (and sometimes the driver version). If the given limit is exceeded, rendering errors will occur.
Limits for various graphics hardware can be found in the `Vulkan Hardware Database <https://vulkan.gpuinfo.org/>`__.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_render_pipeline_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **render_pipeline_create**\ (\ shader\: :ref:`RID<class_RID>`, framebuffer_format\: :ref:`int<class_int>`, vertex_format\: :ref:`int<class_int>`, primitive\: :ref:`RenderPrimitive<enum_RenderingDevice_RenderPrimitive>`, rasterization_state\: :ref:`RDPipelineRasterizationState<class_RDPipelineRasterizationState>`, multisample_state\: :ref:`RDPipelineMultisampleState<class_RDPipelineMultisampleState>`, stencil_state\: :ref:`RDPipelineDepthStencilState<class_RDPipelineDepthStencilState>`, color_blend_state\: :ref:`RDPipelineColorBlendState<class_RDPipelineColorBlendState>`, dynamic_state_flags\: |bitfield|\[:ref:`PipelineDynamicStateFlags<enum_RenderingDevice_PipelineDynamicStateFlags>`\] = 0, for_render_pass\: :ref:`int<class_int>` = 0, specialization_constants\: :ref:`Array<class_Array>`\[:ref:`RDPipelineSpecializationConstant<class_RDPipelineSpecializationConstant>`\] = []\ ) :ref:`🔗<class_RenderingDevice_method_render_pipeline_create>`
Creates a new render pipeline. It can be accessed with the RID that is returned.
Once finished with your RID, you will want to free the RID using the RenderingDevice's :ref:`free_rid()<class_RenderingDevice_method_free_rid>` method.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_render_pipeline_is_valid:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **render_pipeline_is_valid**\ (\ render_pipeline\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_RenderingDevice_method_render_pipeline_is_valid>`
Returns ``true`` if the render pipeline specified by the ``render_pipeline`` RID is valid, ``false`` otherwise.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_sampler_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **sampler_create**\ (\ state\: :ref:`RDSamplerState<class_RDSamplerState>`\ ) :ref:`🔗<class_RenderingDevice_method_sampler_create>`
Creates a new sampler. It can be accessed with the RID that is returned.
Once finished with your RID, you will want to free the RID using the RenderingDevice's :ref:`free_rid()<class_RenderingDevice_method_free_rid>` method.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_sampler_is_format_supported_for_filter:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **sampler_is_format_supported_for_filter**\ (\ format\: :ref:`DataFormat<enum_RenderingDevice_DataFormat>`, sampler_filter\: :ref:`SamplerFilter<enum_RenderingDevice_SamplerFilter>`\ ) |const| :ref:`🔗<class_RenderingDevice_method_sampler_is_format_supported_for_filter>`
Returns ``true`` if implementation supports using a texture of ``format`` with the given ``sampler_filter``.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_screen_get_framebuffer_format:
.. rst-class:: classref-method
:ref:`int<class_int>` **screen_get_framebuffer_format**\ (\ screen\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_RenderingDevice_method_screen_get_framebuffer_format>`
Returns the framebuffer format of the given screen.
\ **Note:** Only the main **RenderingDevice** returned by :ref:`RenderingServer.get_rendering_device()<class_RenderingServer_method_get_rendering_device>` has a format. If called on a local **RenderingDevice**, this method prints an error and returns :ref:`INVALID_ID<class_RenderingDevice_constant_INVALID_ID>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_screen_get_height:
.. rst-class:: classref-method
:ref:`int<class_int>` **screen_get_height**\ (\ screen\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_RenderingDevice_method_screen_get_height>`
Returns the window height matching the graphics API context for the given window ID (in pixels). Despite the parameter being named ``screen``, this returns the *window* size. See also :ref:`screen_get_width()<class_RenderingDevice_method_screen_get_width>`.
\ **Note:** Only the main **RenderingDevice** returned by :ref:`RenderingServer.get_rendering_device()<class_RenderingServer_method_get_rendering_device>` has a height. If called on a local **RenderingDevice**, this method prints an error and returns :ref:`INVALID_ID<class_RenderingDevice_constant_INVALID_ID>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_screen_get_width:
.. rst-class:: classref-method
:ref:`int<class_int>` **screen_get_width**\ (\ screen\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_RenderingDevice_method_screen_get_width>`
Returns the window width matching the graphics API context for the given window ID (in pixels). Despite the parameter being named ``screen``, this returns the *window* size. See also :ref:`screen_get_height()<class_RenderingDevice_method_screen_get_height>`.
\ **Note:** Only the main **RenderingDevice** returned by :ref:`RenderingServer.get_rendering_device()<class_RenderingServer_method_get_rendering_device>` has a width. If called on a local **RenderingDevice**, this method prints an error and returns :ref:`INVALID_ID<class_RenderingDevice_constant_INVALID_ID>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_set_resource_name:
.. rst-class:: classref-method
|void| **set_resource_name**\ (\ id\: :ref:`RID<class_RID>`, name\: :ref:`String<class_String>`\ ) :ref:`🔗<class_RenderingDevice_method_set_resource_name>`
Sets the resource name for ``id`` to ``name``. This is used for debugging with third-party tools such as `RenderDoc <https://renderdoc.org/>`__.
The following types of resources can be named: texture, sampler, vertex buffer, index buffer, uniform buffer, texture buffer, storage buffer, uniform set buffer, shader, render pipeline and compute pipeline. Framebuffers cannot be named. Attempting to name an incompatible resource type will print an error.
\ **Note:** Resource names are only set when the engine runs in verbose mode (:ref:`OS.is_stdout_verbose()<class_OS_method_is_stdout_verbose>` = ``true``), or when using an engine build compiled with the ``dev_mode=yes`` SCons option. The graphics driver must also support the ``VK_EXT_DEBUG_UTILS_EXTENSION_NAME`` Vulkan extension for named resources to work.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_shader_compile_binary_from_spirv:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **shader_compile_binary_from_spirv**\ (\ spirv_data\: :ref:`RDShaderSPIRV<class_RDShaderSPIRV>`, name\: :ref:`String<class_String>` = ""\ ) :ref:`🔗<class_RenderingDevice_method_shader_compile_binary_from_spirv>`
Compiles a binary shader from ``spirv_data`` and returns the compiled binary data as a :ref:`PackedByteArray<class_PackedByteArray>`. This compiled shader is specific to the GPU model and driver version used; it will not work on different GPU models or even different driver versions. See also :ref:`shader_compile_spirv_from_source()<class_RenderingDevice_method_shader_compile_spirv_from_source>`.
\ ``name`` is an optional human-readable name that can be given to the compiled shader for organizational purposes.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_shader_compile_spirv_from_source:
.. rst-class:: classref-method
:ref:`RDShaderSPIRV<class_RDShaderSPIRV>` **shader_compile_spirv_from_source**\ (\ shader_source\: :ref:`RDShaderSource<class_RDShaderSource>`, allow_cache\: :ref:`bool<class_bool>` = true\ ) :ref:`🔗<class_RenderingDevice_method_shader_compile_spirv_from_source>`
Compiles a SPIR-V from the shader source code in ``shader_source`` and returns the SPIR-V as an :ref:`RDShaderSPIRV<class_RDShaderSPIRV>`. This intermediate language shader is portable across different GPU models and driver versions, but cannot be run directly by GPUs until compiled into a binary shader using :ref:`shader_compile_binary_from_spirv()<class_RenderingDevice_method_shader_compile_binary_from_spirv>`.
If ``allow_cache`` is ``true``, make use of the shader cache generated by Godot. This avoids a potentially lengthy shader compilation step if the shader is already in cache. If ``allow_cache`` is ``false``, Godot's shader cache is ignored and the shader will always be recompiled.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_shader_create_from_bytecode:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **shader_create_from_bytecode**\ (\ binary_data\: :ref:`PackedByteArray<class_PackedByteArray>`, placeholder_rid\: :ref:`RID<class_RID>` = RID()\ ) :ref:`🔗<class_RenderingDevice_method_shader_create_from_bytecode>`
Creates a new shader instance from a binary compiled shader. It can be accessed with the RID that is returned.
Once finished with your RID, you will want to free the RID using the RenderingDevice's :ref:`free_rid()<class_RenderingDevice_method_free_rid>` method. See also :ref:`shader_compile_binary_from_spirv()<class_RenderingDevice_method_shader_compile_binary_from_spirv>` and :ref:`shader_create_from_spirv()<class_RenderingDevice_method_shader_create_from_spirv>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_shader_create_from_spirv:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **shader_create_from_spirv**\ (\ spirv_data\: :ref:`RDShaderSPIRV<class_RDShaderSPIRV>`, name\: :ref:`String<class_String>` = ""\ ) :ref:`🔗<class_RenderingDevice_method_shader_create_from_spirv>`
Creates a new shader instance from SPIR-V intermediate code. It can be accessed with the RID that is returned.
Once finished with your RID, you will want to free the RID using the RenderingDevice's :ref:`free_rid()<class_RenderingDevice_method_free_rid>` method. See also :ref:`shader_compile_spirv_from_source()<class_RenderingDevice_method_shader_compile_spirv_from_source>` and :ref:`shader_create_from_bytecode()<class_RenderingDevice_method_shader_create_from_bytecode>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_shader_create_placeholder:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **shader_create_placeholder**\ (\ ) :ref:`🔗<class_RenderingDevice_method_shader_create_placeholder>`
Create a placeholder RID by allocating an RID without initializing it for use in :ref:`shader_create_from_bytecode()<class_RenderingDevice_method_shader_create_from_bytecode>`. This allows you to create an RID for a shader and pass it around, but defer compiling the shader to a later time.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_shader_get_vertex_input_attribute_mask:
.. rst-class:: classref-method
:ref:`int<class_int>` **shader_get_vertex_input_attribute_mask**\ (\ shader\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_RenderingDevice_method_shader_get_vertex_input_attribute_mask>`
Returns the internal vertex input mask. Internally, the vertex input mask is an unsigned integer consisting of the locations (specified in GLSL via. ``layout(location = ...)``) of the input variables (specified in GLSL by the ``in`` keyword).
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_storage_buffer_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **storage_buffer_create**\ (\ size_bytes\: :ref:`int<class_int>`, data\: :ref:`PackedByteArray<class_PackedByteArray>` = PackedByteArray(), usage\: |bitfield|\[:ref:`StorageBufferUsage<enum_RenderingDevice_StorageBufferUsage>`\] = 0, creation_bits\: |bitfield|\[:ref:`BufferCreationBits<enum_RenderingDevice_BufferCreationBits>`\] = 0\ ) :ref:`🔗<class_RenderingDevice_method_storage_buffer_create>`
Creates a `storage buffer <https://vkguide.dev/docs/chapter-4/storage_buffers/>`__ with the specified ``data`` and ``usage``. It can be accessed with the RID that is returned.
Once finished with your RID, you will want to free the RID using the RenderingDevice's :ref:`free_rid()<class_RenderingDevice_method_free_rid>` method.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_submit:
.. rst-class:: classref-method
|void| **submit**\ (\ ) :ref:`🔗<class_RenderingDevice_method_submit>`
Pushes the frame setup and draw command buffers then marks the local device as currently processing (which allows calling :ref:`sync()<class_RenderingDevice_method_sync>`).
\ **Note:** Only available in local RenderingDevices.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_sync:
.. rst-class:: classref-method
|void| **sync**\ (\ ) :ref:`🔗<class_RenderingDevice_method_sync>`
Forces a synchronization between the CPU and GPU, which may be required in certain cases. Only call this when needed, as CPU-GPU synchronization has a performance cost.
\ **Note:** Only available in local RenderingDevices.
\ **Note:** :ref:`sync()<class_RenderingDevice_method_sync>` can only be called after a :ref:`submit()<class_RenderingDevice_method_submit>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_texture_buffer_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **texture_buffer_create**\ (\ size_bytes\: :ref:`int<class_int>`, format\: :ref:`DataFormat<enum_RenderingDevice_DataFormat>`, data\: :ref:`PackedByteArray<class_PackedByteArray>` = PackedByteArray()\ ) :ref:`🔗<class_RenderingDevice_method_texture_buffer_create>`
Creates a new texture buffer. It can be accessed with the RID that is returned.
Once finished with your RID, you will want to free the RID using the RenderingDevice's :ref:`free_rid()<class_RenderingDevice_method_free_rid>` method.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_texture_clear:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **texture_clear**\ (\ texture\: :ref:`RID<class_RID>`, color\: :ref:`Color<class_Color>`, base_mipmap\: :ref:`int<class_int>`, mipmap_count\: :ref:`int<class_int>`, base_layer\: :ref:`int<class_int>`, layer_count\: :ref:`int<class_int>`\ ) :ref:`🔗<class_RenderingDevice_method_texture_clear>`
Clears the specified ``texture`` by replacing all of its pixels with the specified ``color``. ``base_mipmap`` and ``mipmap_count`` determine which mipmaps of the texture are affected by this clear operation, while ``base_layer`` and ``layer_count`` determine which layers of a 3D texture (or texture array) are affected by this clear operation. For 2D textures (which only have one layer by design), ``base_layer`` must be ``0`` and ``layer_count`` must be ``1``.
\ **Note:** ``texture`` can't be cleared while a draw list that uses it as part of a framebuffer is being created. Ensure the draw list is finalized (and that the color/depth texture using it is not set to :ref:`FINAL_ACTION_CONTINUE<class_RenderingDevice_constant_FINAL_ACTION_CONTINUE>`) to clear this texture.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_texture_copy:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **texture_copy**\ (\ from_texture\: :ref:`RID<class_RID>`, to_texture\: :ref:`RID<class_RID>`, from_pos\: :ref:`Vector3<class_Vector3>`, to_pos\: :ref:`Vector3<class_Vector3>`, size\: :ref:`Vector3<class_Vector3>`, src_mipmap\: :ref:`int<class_int>`, dst_mipmap\: :ref:`int<class_int>`, src_layer\: :ref:`int<class_int>`, dst_layer\: :ref:`int<class_int>`\ ) :ref:`🔗<class_RenderingDevice_method_texture_copy>`
Copies the ``from_texture`` to ``to_texture`` with the specified ``from_pos``, ``to_pos`` and ``size`` coordinates. The Z axis of the ``from_pos``, ``to_pos`` and ``size`` must be ``0`` for 2-dimensional textures. Source and destination mipmaps/layers must also be specified, with these parameters being ``0`` for textures without mipmaps or single-layer textures. Returns :ref:`@GlobalScope.OK<class_@GlobalScope_constant_OK>` if the texture copy was successful or :ref:`@GlobalScope.ERR_INVALID_PARAMETER<class_@GlobalScope_constant_ERR_INVALID_PARAMETER>` otherwise.
\ **Note:** ``from_texture`` texture can't be copied while a draw list that uses it as part of a framebuffer is being created. Ensure the draw list is finalized (and that the color/depth texture using it is not set to :ref:`FINAL_ACTION_CONTINUE<class_RenderingDevice_constant_FINAL_ACTION_CONTINUE>`) to copy this texture.
\ **Note:** ``from_texture`` texture requires the :ref:`TEXTURE_USAGE_CAN_COPY_FROM_BIT<class_RenderingDevice_constant_TEXTURE_USAGE_CAN_COPY_FROM_BIT>` to be retrieved.
\ **Note:** ``to_texture`` can't be copied while a draw list that uses it as part of a framebuffer is being created. Ensure the draw list is finalized (and that the color/depth texture using it is not set to :ref:`FINAL_ACTION_CONTINUE<class_RenderingDevice_constant_FINAL_ACTION_CONTINUE>`) to copy this texture.
\ **Note:** ``to_texture`` requires the :ref:`TEXTURE_USAGE_CAN_COPY_TO_BIT<class_RenderingDevice_constant_TEXTURE_USAGE_CAN_COPY_TO_BIT>` to be retrieved.
\ **Note:** ``from_texture`` and ``to_texture`` must be of the same type (color or depth).
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_texture_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **texture_create**\ (\ format\: :ref:`RDTextureFormat<class_RDTextureFormat>`, view\: :ref:`RDTextureView<class_RDTextureView>`, data\: :ref:`Array<class_Array>`\[:ref:`PackedByteArray<class_PackedByteArray>`\] = []\ ) :ref:`🔗<class_RenderingDevice_method_texture_create>`
Creates a new texture. It can be accessed with the RID that is returned.
Once finished with your RID, you will want to free the RID using the RenderingDevice's :ref:`free_rid()<class_RenderingDevice_method_free_rid>` method.
\ **Note:** ``data`` takes an :ref:`Array<class_Array>` of :ref:`PackedByteArray<class_PackedByteArray>`\ s. For :ref:`TEXTURE_TYPE_1D<class_RenderingDevice_constant_TEXTURE_TYPE_1D>`, :ref:`TEXTURE_TYPE_2D<class_RenderingDevice_constant_TEXTURE_TYPE_2D>`, and :ref:`TEXTURE_TYPE_3D<class_RenderingDevice_constant_TEXTURE_TYPE_3D>` types, this array should only have one element, a :ref:`PackedByteArray<class_PackedByteArray>` containing all the data for the texture. For ``_ARRAY`` and ``_CUBE`` types, the length should be the same as the number of :ref:`RDTextureFormat.array_layers<class_RDTextureFormat_property_array_layers>` in ``format``.
\ **Note:** Not to be confused with :ref:`RenderingServer.texture_2d_create()<class_RenderingServer_method_texture_2d_create>`, which creates the Godot-specific :ref:`Texture2D<class_Texture2D>` resource as opposed to the graphics API's own texture type.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_texture_create_from_extension:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **texture_create_from_extension**\ (\ type\: :ref:`TextureType<enum_RenderingDevice_TextureType>`, format\: :ref:`DataFormat<enum_RenderingDevice_DataFormat>`, samples\: :ref:`TextureSamples<enum_RenderingDevice_TextureSamples>`, usage_flags\: |bitfield|\[:ref:`TextureUsageBits<enum_RenderingDevice_TextureUsageBits>`\], image\: :ref:`int<class_int>`, width\: :ref:`int<class_int>`, height\: :ref:`int<class_int>`, depth\: :ref:`int<class_int>`, layers\: :ref:`int<class_int>`, mipmaps\: :ref:`int<class_int>` = 1\ ) :ref:`🔗<class_RenderingDevice_method_texture_create_from_extension>`
Returns an RID for an existing ``image`` (``VkImage``) with the given ``type``, ``format``, ``samples``, ``usage_flags``, ``width``, ``height``, ``depth``, ``layers``, and ``mipmaps``. This can be used to allow Godot to render onto foreign images.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_texture_create_shared:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **texture_create_shared**\ (\ view\: :ref:`RDTextureView<class_RDTextureView>`, with_texture\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_RenderingDevice_method_texture_create_shared>`
Creates a shared texture using the specified ``view`` and the texture information from ``with_texture``.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_texture_create_shared_from_slice:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **texture_create_shared_from_slice**\ (\ view\: :ref:`RDTextureView<class_RDTextureView>`, with_texture\: :ref:`RID<class_RID>`, layer\: :ref:`int<class_int>`, mipmap\: :ref:`int<class_int>`, mipmaps\: :ref:`int<class_int>` = 1, slice_type\: :ref:`TextureSliceType<enum_RenderingDevice_TextureSliceType>` = 0\ ) :ref:`🔗<class_RenderingDevice_method_texture_create_shared_from_slice>`
Creates a shared texture using the specified ``view`` and the texture information from ``with_texture``'s ``layer`` and ``mipmap``. The number of included mipmaps from the original texture can be controlled using the ``mipmaps`` parameter. Only relevant for textures with multiple layers, such as 3D textures, texture arrays and cubemaps. For single-layer textures, use :ref:`texture_create_shared()<class_RenderingDevice_method_texture_create_shared>`.
For 2D textures (which only have one layer), ``layer`` must be ``0``.
\ **Note:** Layer slicing is only supported for 2D texture arrays, not 3D textures or cubemaps.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_texture_get_data:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **texture_get_data**\ (\ texture\: :ref:`RID<class_RID>`, layer\: :ref:`int<class_int>`\ ) :ref:`🔗<class_RenderingDevice_method_texture_get_data>`
Returns the ``texture`` data for the specified ``layer`` as raw binary data. For 2D textures (which only have one layer), ``layer`` must be ``0``.
\ **Note:** ``texture`` can't be retrieved while a draw list that uses it as part of a framebuffer is being created. Ensure the draw list is finalized (and that the color/depth texture using it is not set to :ref:`FINAL_ACTION_CONTINUE<class_RenderingDevice_constant_FINAL_ACTION_CONTINUE>`) to retrieve this texture. Otherwise, an error is printed and an empty :ref:`PackedByteArray<class_PackedByteArray>` is returned.
\ **Note:** ``texture`` requires the :ref:`TEXTURE_USAGE_CAN_COPY_FROM_BIT<class_RenderingDevice_constant_TEXTURE_USAGE_CAN_COPY_FROM_BIT>` to be retrieved. Otherwise, an error is printed and an empty :ref:`PackedByteArray<class_PackedByteArray>` is returned.
\ **Note:** This method will block the GPU from working until the data is retrieved. Refer to :ref:`texture_get_data_async()<class_RenderingDevice_method_texture_get_data_async>` for an alternative that returns the data in more performant way.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_texture_get_data_async:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **texture_get_data_async**\ (\ texture\: :ref:`RID<class_RID>`, layer\: :ref:`int<class_int>`, callback\: :ref:`Callable<class_Callable>`\ ) :ref:`🔗<class_RenderingDevice_method_texture_get_data_async>`
Asynchronous version of :ref:`texture_get_data()<class_RenderingDevice_method_texture_get_data>`. RenderingDevice will call ``callback`` in a certain amount of frames with the data the texture had at the time of the request.
\ **Note:** At the moment, the delay corresponds to the amount of frames specified by :ref:`ProjectSettings.rendering/rendering_device/vsync/frame_queue_size<class_ProjectSettings_property_rendering/rendering_device/vsync/frame_queue_size>`.
\ **Note:** Downloading large textures can have a prohibitive cost for real-time even when using the asynchronous method due to hardware bandwidth limitations. When dealing with large resources, you can adjust settings such as :ref:`ProjectSettings.rendering/rendering_device/staging_buffer/texture_download_region_size_px<class_ProjectSettings_property_rendering/rendering_device/staging_buffer/texture_download_region_size_px>` and :ref:`ProjectSettings.rendering/rendering_device/staging_buffer/block_size_kb<class_ProjectSettings_property_rendering/rendering_device/staging_buffer/block_size_kb>` to improve the transfer speed at the cost of extra memory.
::
func _texture_get_data_callback(array):
value = array.decode_u32(0)
...
rd.texture_get_data_async(texture, 0, _texture_get_data_callback)
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_texture_get_format:
.. rst-class:: classref-method
:ref:`RDTextureFormat<class_RDTextureFormat>` **texture_get_format**\ (\ texture\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_RenderingDevice_method_texture_get_format>`
Devuelve el formato de datos utilizado para crear esta textura.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_texture_get_native_handle:
.. rst-class:: classref-method
:ref:`int<class_int>` **texture_get_native_handle**\ (\ texture\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_RenderingDevice_method_texture_get_native_handle>`
**Obsoleto:** Use :ref:`get_driver_resource()<class_RenderingDevice_method_get_driver_resource>` with :ref:`DRIVER_RESOURCE_TEXTURE<class_RenderingDevice_constant_DRIVER_RESOURCE_TEXTURE>` instead.
Returns the internal graphics handle for this texture object. For use when communicating with third-party APIs mostly with GDExtension.
\ **Note:** This function returns a ``uint64_t`` which internally maps to a ``GLuint`` (OpenGL) or ``VkImage`` (Vulkan).
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_texture_is_discardable:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **texture_is_discardable**\ (\ texture\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_RenderingDevice_method_texture_is_discardable>`
Devuelve ``true`` si la ``texture`` es descartable, ``false`` en caso contrario. Véase :ref:`RDTextureFormat<class_RDTextureFormat>` o :ref:`texture_set_discardable()<class_RenderingDevice_method_texture_set_discardable>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_texture_is_format_supported_for_usage:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **texture_is_format_supported_for_usage**\ (\ format\: :ref:`DataFormat<enum_RenderingDevice_DataFormat>`, usage_flags\: |bitfield|\[:ref:`TextureUsageBits<enum_RenderingDevice_TextureUsageBits>`\]\ ) |const| :ref:`🔗<class_RenderingDevice_method_texture_is_format_supported_for_usage>`
Devuelve ``true`` si el ``format`` especificado es compatible con los ``usage_flags`` proporcionados, ``false`` en caso contrario.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_texture_is_shared:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **texture_is_shared**\ (\ texture\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_RenderingDevice_method_texture_is_shared>`
Devuelve ``true`` si la ``texture`` es compartida, ``false`` en caso contrario. Véase :ref:`RDTextureView<class_RDTextureView>`.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_texture_is_valid:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **texture_is_valid**\ (\ texture\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_RenderingDevice_method_texture_is_valid>`
Devuelve ``true`` si la ``texture`` es válida, ``false`` en caso contrario.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_texture_resolve_multisample:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **texture_resolve_multisample**\ (\ from_texture\: :ref:`RID<class_RID>`, to_texture\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_RenderingDevice_method_texture_resolve_multisample>`
Resolves the ``from_texture`` texture onto ``to_texture`` with multisample antialiasing enabled. This must be used when rendering a framebuffer for MSAA to work. Returns :ref:`@GlobalScope.OK<class_@GlobalScope_constant_OK>` if successful, :ref:`@GlobalScope.ERR_INVALID_PARAMETER<class_@GlobalScope_constant_ERR_INVALID_PARAMETER>` otherwise.
\ **Note:** ``from_texture`` and ``to_texture`` textures must have the same dimension, format and type (color or depth).
\ **Note:** ``from_texture`` can't be copied while a draw list that uses it as part of a framebuffer is being created. Ensure the draw list is finalized (and that the color/depth texture using it is not set to :ref:`FINAL_ACTION_CONTINUE<class_RenderingDevice_constant_FINAL_ACTION_CONTINUE>`) to resolve this texture.
\ **Note:** ``from_texture`` requires the :ref:`TEXTURE_USAGE_CAN_COPY_FROM_BIT<class_RenderingDevice_constant_TEXTURE_USAGE_CAN_COPY_FROM_BIT>` to be retrieved.
\ **Note:** ``from_texture`` must be multisampled and must also be 2D (or a slice of a 3D/cubemap texture).
\ **Note:** ``to_texture`` can't be copied while a draw list that uses it as part of a framebuffer is being created. Ensure the draw list is finalized (and that the color/depth texture using it is not set to :ref:`FINAL_ACTION_CONTINUE<class_RenderingDevice_constant_FINAL_ACTION_CONTINUE>`) to resolve this texture.
\ **Note:** ``to_texture`` texture requires the :ref:`TEXTURE_USAGE_CAN_COPY_TO_BIT<class_RenderingDevice_constant_TEXTURE_USAGE_CAN_COPY_TO_BIT>` to be retrieved.
\ **Note:** ``to_texture`` texture must **not** be multisampled and must also be 2D (or a slice of a 3D/cubemap texture).
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_texture_set_discardable:
.. rst-class:: classref-method
|void| **texture_set_discardable**\ (\ texture\: :ref:`RID<class_RID>`, discardable\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_RenderingDevice_method_texture_set_discardable>`
Updates the discardable property of ``texture``.
If a texture is discardable, its contents do not need to be preserved between frames. This flag is only relevant when the texture is used as target in a draw list.
This information is used by **RenderingDevice** to figure out if a texture's contents can be discarded, eliminating unnecessary writes to memory and boosting performance.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_texture_update:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **texture_update**\ (\ texture\: :ref:`RID<class_RID>`, layer\: :ref:`int<class_int>`, data\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) :ref:`🔗<class_RenderingDevice_method_texture_update>`
Updates texture data with new data, replacing the previous data in place. The updated texture data must have the same dimensions and format. For 2D textures (which only have one layer), ``layer`` must be ``0``. Returns :ref:`@GlobalScope.OK<class_@GlobalScope_constant_OK>` if the update was successful, :ref:`@GlobalScope.ERR_INVALID_PARAMETER<class_@GlobalScope_constant_ERR_INVALID_PARAMETER>` otherwise.
\ **Note:** Updating textures is forbidden during creation of a draw or compute list.
\ **Note:** The existing ``texture`` can't be updated while a draw list that uses it as part of a framebuffer is being created. Ensure the draw list is finalized (and that the color/depth texture using it is not set to :ref:`FINAL_ACTION_CONTINUE<class_RenderingDevice_constant_FINAL_ACTION_CONTINUE>`) to update this texture.
\ **Note:** The existing ``texture`` requires the :ref:`TEXTURE_USAGE_CAN_UPDATE_BIT<class_RenderingDevice_constant_TEXTURE_USAGE_CAN_UPDATE_BIT>` to be updatable.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_uniform_buffer_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **uniform_buffer_create**\ (\ size_bytes\: :ref:`int<class_int>`, data\: :ref:`PackedByteArray<class_PackedByteArray>` = PackedByteArray(), creation_bits\: |bitfield|\[:ref:`BufferCreationBits<enum_RenderingDevice_BufferCreationBits>`\] = 0\ ) :ref:`🔗<class_RenderingDevice_method_uniform_buffer_create>`
Creates a new uniform buffer. It can be accessed with the RID that is returned.
Once finished with your RID, you will want to free the RID using the RenderingDevice's :ref:`free_rid()<class_RenderingDevice_method_free_rid>` method.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_uniform_set_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **uniform_set_create**\ (\ uniforms\: :ref:`Array<class_Array>`\[:ref:`RDUniform<class_RDUniform>`\], shader\: :ref:`RID<class_RID>`, shader_set\: :ref:`int<class_int>`\ ) :ref:`🔗<class_RenderingDevice_method_uniform_set_create>`
Creates a new uniform set. It can be accessed with the RID that is returned.
Once finished with your RID, you will want to free the RID using the RenderingDevice's :ref:`free_rid()<class_RenderingDevice_method_free_rid>` method.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_uniform_set_is_valid:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **uniform_set_is_valid**\ (\ uniform_set\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_RenderingDevice_method_uniform_set_is_valid>`
Checks if the ``uniform_set`` is valid, i.e. is owned.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_vertex_array_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **vertex_array_create**\ (\ vertex_count\: :ref:`int<class_int>`, vertex_format\: :ref:`int<class_int>`, src_buffers\: :ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\], offsets\: :ref:`PackedInt64Array<class_PackedInt64Array>` = PackedInt64Array()\ ) :ref:`🔗<class_RenderingDevice_method_vertex_array_create>`
Crea un array de vértices basado en los búferes especificados. Opcionalmente, se pueden definir ``offsets`` (en bytes) para cada búfer.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_vertex_buffer_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **vertex_buffer_create**\ (\ size_bytes\: :ref:`int<class_int>`, data\: :ref:`PackedByteArray<class_PackedByteArray>` = PackedByteArray(), creation_bits\: |bitfield|\[:ref:`BufferCreationBits<enum_RenderingDevice_BufferCreationBits>`\] = 0\ ) :ref:`🔗<class_RenderingDevice_method_vertex_buffer_create>`
Crea un nuevo búfer de vértices. Se puede acceder a él con el RID que se devuelve.
Una vez que hayas terminado con tu RID, querrás liberarlo usando el método :ref:`free_rid()<class_RenderingDevice_method_free_rid>` de RenderingDevice.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_vertex_format_create:
.. rst-class:: classref-method
:ref:`int<class_int>` **vertex_format_create**\ (\ vertex_descriptions\: :ref:`Array<class_Array>`\[:ref:`RDVertexAttribute<class_RDVertexAttribute>`\]\ ) :ref:`🔗<class_RenderingDevice_method_vertex_format_create>`
Crea un nuevo formato de vértice con los ``vertex_descriptions`` especificados. Devuelve un ID de formato de vértice único correspondiente al formato de vértice recién creado.
.. |virtual| replace:: :abbr:`virtual (Normalmente, este método debería ser sobreescrito por el usuario para que tenga algún efecto.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Este método no tiene efectos secundarios. No modifica ninguna de las variables miembro de la instancia.)`
.. |vararg| replace:: :abbr:`vararg (Este método permite agregar cualquier número de argumentos después de los descritos aquí.)`
.. |constructor| replace:: :abbr:`constructor (Este método se utiliza para construir un tipo.)`
.. |static| replace:: :abbr:`static (Este método no necesita una instancia para ser llamado, por lo que puede llamarse directamente utilizando el nombre de la clase.)`
.. |operator| replace:: :abbr:`operator (Este método describe un operador válido para usar con este tipo como operando izquierdo.)`
.. |bitfield| replace:: :abbr:`BitField (Este valor es un entero compuesto como una máscara de bits de las siguientes banderas.)`
.. |void| replace:: :abbr:`void (Sin valor de retorno.)`
Reference in New Issue View Git Blame Copy Permalink