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
57781dc0bc3ff665ce77f07d04c053cbb254ac37
godot-docs-l10n/classes/it/class_renderingdevice.rst
Rémi Verschelde 369fd84a4f Sync classref with 4.5 branch
2025-12-19 14:34:07 +01:00

6924 lines
528 KiB
ReStructuredText
Raw 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
===============
**Eredita:** :ref:`Object<class_Object>`
Astrazione per lavorare con API grafiche moderne di basso livello.
.. rst-class:: classref-introduction-group
Descrizione
----------------------
**RenderingDevice** è un'astrazione per lavorare con API grafiche moderne di basso livello come Vulkan. Rispetto a :ref:`RenderingServer<class_RenderingServer>` (che funziona con i sottosistemi di rendering di Godot), **RenderingDevice** è di livello molto più basso e consente di lavorare in modo più diretto con le API grafiche sottostanti. **RenderingDevice** viene utilizzato in Godot per fornire supporto a diverse API grafiche moderne di basso livello, riducendo allo stesso tempo la duplicazione necessaria del codice. È possibile utilizzare **RenderingDevice** anche nei propri progetti per eseguire operazioni che non sono esposte da :ref:`RenderingServer<class_RenderingServer>` o dai nodi di alto livello, come l'uso di shader di calcolo.
All'avvio, Godot crea un **RenderingDevice** globale che è possibile recuperare tramite :ref:`RenderingServer.get_rendering_device()<class_RenderingServer_method_get_rendering_device>`. Questo **RenderingDevice** globale esegue l'operazione di disegno sullo schermo.
\ **Dispositivi di rendering locali:** Tramite :ref:`RenderingServer.create_local_rendering_device()<class_RenderingServer_method_create_local_rendering_device>`, è possibile creare dispositivi di rendering "secondari" per eseguire operazioni di disegno e di elaborazione sulla GPU su thread separati.
\ **Nota:** **RenderingDevice** presuppone una conoscenza intermedia delle moderne API grafiche come Vulkan, Direct3D 12, Metal o WebGPU. Queste API grafiche sono di livello inferiore rispetto a OpenGL o Direct3D 11 e richiedono di eseguire certe operazioni che in precedenza erano eseguite dal driver grafico stesso. Se hai difficoltà a comprendere i concetti utilizzati in questa classe, segui il `Tutorial di Vulkan <https://vulkan-tutorial.com/>`__ o la `Guida di Vulkan <https://vkguide.dev/>`__. Si consiglia di avere una conoscenza pre-esistente di OpenGL o Direct3D 11 prima di provare a imparare un'API grafica di basso livello.
\ **Nota:** **RenderingDevice** non è disponibile quando si esegue in modalità headless o quando si utilizza il metodo di rendering Compatibilità.
.. rst-class:: classref-introduction-group
Tutorial
----------------
- :doc:`Utilizzo degli shader di calcolo <../tutorials/shaders/compute_shaders>`
.. rst-class:: classref-reftable-group
Metodi
------------
.. 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
Enumerazioni
------------------------
.. _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``
Il tipo del dispositivo di rendering non corrisponde a nessuno degli altri valori nell'enumerazione oppure è sconosciuto.
.. _class_RenderingDevice_constant_DEVICE_TYPE_INTEGRATED_GPU:
.. rst-class:: classref-enumeration-constant
:ref:`DeviceType<enum_RenderingDevice_DeviceType>` **DEVICE_TYPE_INTEGRATED_GPU** = ``1``
Il dispositivo di rendering è una GPU integrata, che è solitamente *(ma non sempre)* più lenta delle GPU dedicate (:ref:`DEVICE_TYPE_DISCRETE_GPU<class_RenderingDevice_constant_DEVICE_TYPE_DISCRETE_GPU>`). Su Android e iOS, il tipo del dispositivo di rendering è sempre considerato :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``
Il dispositivo di rendering è una GPU dedicata, che è solitamente *(ma non sempre)* più veloce delle GPU integrate (: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``
Il dispositivo di rendering è una GPU emulata in un ambiente virtuale. Solitamente è molto più lento della GPU host, il che significa che il livello di prestazioni previsto su una GPU dedicata sarà più o meno equivalente a :ref:`DEVICE_TYPE_INTEGRATED_GPU<class_RenderingDevice_constant_DEVICE_TYPE_INTEGRATED_GPU>`. Il passthrough della GPU in una macchina virtuale (come VFIO) non segnalerà il tipo di dispositivo come :ref:`DEVICE_TYPE_VIRTUAL_GPU<class_RenderingDevice_constant_DEVICE_TYPE_VIRTUAL_GPU>`. Invece, il tipo di dispositivo della GPU host verrà segnalato come se la GPU non fosse stata emulata.
.. _class_RenderingDevice_constant_DEVICE_TYPE_CPU:
.. rst-class:: classref-enumeration-constant
:ref:`DeviceType<enum_RenderingDevice_DeviceType>` **DEVICE_TYPE_CPU** = ``4``
Il dispositivo di rendering è fornito dall'emulazione in software (come Lavapipe o `SwiftShader <https://github.com/google/swiftshader>`__). Questo è il tipo di dispositivo di rendering più lento disponibile; è solitamente molto più lento di :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``
Rappresenta la dimensione dell'enumerazione :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``
Oggetto dispositivo specifico basato su un dispositivo fisico (il parametro ``rid`` è ignorato).
- Vulkan: Risorsa driver dispositivo Vulkan (``VkDevice``).
- D3D12: Risorsa driver dispositivo D3D12 (``ID3D12Device``).
- Metal: Risorsa driver 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 fisico su cui si basa il dispositivo logico specifico (il parametro ``rid`` è ignorato).
- 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``
Oggetto di ingresso di livello superiore nell'API grafica (il parametro ``rid`` è ignorato).
- 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 coda principale dei comandi di elaborazione grafica (il parametro ``rid`` è ignorato).
- 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 famiglia specifica a cui appartiene la coda principale (il parametro ``rid`` è ignorato).
- Vulkan: l'indice della famiglia di code, 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 di una texture posseduta o condivisa.
- Vulkan: ``VkImageView``.
- D3D12: ``VkImageView``.
.. _class_RenderingDevice_constant_DRIVER_RESOURCE_TEXTURE_DATA_FORMAT:
.. rst-class:: classref-enumeration-constant
:ref:`DriverResource<enum_RenderingDevice_DriverResource>` **DRIVER_RESOURCE_TEXTURE_DATA_FORMAT** = ``7``
L'ID nativo del formato dati della texture.
- 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``
Buffer di qualsiasi tipo (memorizzazione, vertici, ecc.).
- 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``
**Deprecato:** 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``
**Deprecato:** 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``
**Deprecato:** 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``
**Deprecato:** 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``
**Deprecato:** 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``
**Deprecato:** 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``
**Deprecato:** 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``
**Deprecato:** 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``
**Deprecato:** 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``
**Deprecato:** 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``
**Deprecato:** 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``
**Deprecato:** 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``
**Deprecato:** 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``
Formato dati di canali rosso/verde a 4 bit per canale, racchiusi in 8 bit. I valori sono nell'intervallo ``[0.0, 1.0]``.
\ **Nota:** Ulteriori informazioni su tutti i formati dati sono disponibili nella sezione `Identificazione dei formati <https://registry.khronos.org/vulkan/specs/1.1/html/vkspec.html#_identification_of_formats>`__ della specifica Vulkan, nonché nell'enumerazione `VkFormat <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkFormat.html>`__.
.. _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 dati di canali rosso/verde/blu/alfa a 4 bit per canale, racchiusi in 16 bit. I valori sono nell'intervallo ``[0.0, 1.0]``.
.. _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 dati di canali blu/verde/rosso/alfa a 4 bit per canale, racchiusi in 16 bit. I valori sono nell'intervallo ``[0.0, 1.0]``.
.. _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 dati di canali rosso/verde/blu con 5 bit di rosso, 6 bit di verde e 5 bit di blu, racchiusi in 16 bit. I valori sono nell'intervallo ``[0.0, 1.0]``.
.. _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 dati di canali blu/verde/rosso con 5 bit di blu, 6 bit di verde e 5 bit di rosso, racchiusi in 16 bit. I valori sono nell'intervallo ``[0.0, 1.0]``.
.. _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 dati di canali rosso/verde/blu/alfa con 5 bit di rosso, 6 bit di verde, 5 bit di blu e 1 bit di alfa, racchiusi in 16 bit. I valori sono nell'intervallo ``[0.0, 1.0]``.
.. _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 dati di canali blu/verde/rosso/alfa con 5 bit di blu, 6 bit di verde, 5 bit di rosso e 1 bit di alfa, racchiusi in 16 bit. I valori sono nell'intervallo ``[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 dati di canali alfa/rosso/verde/blu con 1 bit di alfa, 5 bit di rosso, 6 bit di verde e 5 bit di blu, racchiusi in 16 bit. I valori sono nell'intervallo ``[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 dati di canale rosso in virgola mobile senza segno a 8 bit con valore normalizzato. I valori sono compresi nell'intervallo ``[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 dati di canale rosso in virgola mobile con segno a 8 bit con valore normalizzato. I valori sono compresi nell'intervallo ``[-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 dati di canale rosso in virgola mobile senza segno a 8 bit con valore scalato (il valore è convertito da intero a float). I valori sono compresi nell'intervallo ``[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 dati di canale rosso in virgola mobile con segno a 8 bit con valore scalato (il valore è convertito da intero a float). I valori sono compresi nell'intervallo ``[-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 dati di canale rosso intero senza segno a 8 bit. I valori sono compresi nell'intervallo ``[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 dati di canale rosso intero con segno a 8 bit. I valori sono compresi nell'intervallo ``[-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 dati di canale rosso in virgola mobile senza segno a 8 bit con valore normalizzato e codifica in sRGB non lineare. I valori sono compresi nell'intervallo ``[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 dati di canale rosso in virgola mobile senza segno a 8 bit con valore normalizzato. I valori sono compresi nell'intervallo ``[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 dati di canale rosso in virgola mobile con segno a 8 bit con valore normalizzato. I valori sono compresi nell'intervallo ``[-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 dati di canali rosso/verde a virgola mobile senza segno a 8 bit per canale con valore scalato (il valore è convertito da intero a float). I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde a virgola mobile con segno a 8 bit per canale con valore scalato (il valore è convertito da intero a float). I valori sono compresi nell'intervallo ``[0.0, 255.0]``.
.. _class_RenderingDevice_constant_DATA_FORMAT_R8G8_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R8G8_UINT** = ``19``
Formato dati di canali rosso/verde interi senza segno a 8 bit per canale. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde interi con segno a 8 bit per canale. I valori sono compresi nell'intervallo ``[-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 dati di canali rosso/verde in virgola mobile senza segno a 8 bit per canale con valore normalizzato e codifica in sRGB non lineare. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde/blu in virgola mobile senza segno a 8 bit per canale con valore normalizzato. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde/blu in virgola mobile con segno a 8 bit per canale con valore normalizzato. I valori sono compresi nell'intervallo ``[-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 dati di canali rosso/verde/blu a virgola mobile senza segno a 8 bit per canale con valore scalato (il valore è convertito da intero a float). I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde/blu a virgola mobile con segno a 8 bit per canale con valore scalato (il valore è convertito da intero a float). I valori sono compresi nell'intervallo ``[-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 dati di canali rosso/verde/blu intero senza segno a 8 bit per canale. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde/blu intero con segno a 8 bit per canale. I valori sono compresi nell'intervallo ``[-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 dati di canali rosso/verde/blu in virgola mobile senza segno a 8 bit per canale con valore normalizzato e codifica in sRGB non lineare. I valori sono compresi nell'intervallo ``[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 dati di canali blu/verde/rosso in virgola mobile senza segno a 8 bit per canale con valore normalizzato. I valori sono compresi nell'intervallo ``[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 dati di canali blu/verde/rosso in virgola mobile con segno a 8 bit per canale con valore normalizzato. I valori sono compresi nell'intervallo ``[-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 dati di canali blu/verde/rosso in virgola mobile senza segno a 8 bit per canale con valore scalato (il valore è convertito da intero a float). I valori sono compresi nell'intervallo ``[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 dati di canali blu/verde/rosso in virgola mobile con segno a 8 bit per canale con valore scalato (il valore è convertito da intero a float). I valori sono compresi nell'intervallo ``[-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 dati di canali blu/verde/rosso interi senza segno a 8 bit per canale. I valori sono compresi nell'intervallo ``[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 dati di canali blu/verde/rosso interi con segno a 8 bit per canale. I valori sono compresi nell'intervallo ``[-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 dati di canali blu/verde/rosso in virgola mobile senza segno a 8 bit per canale con valore normalizzato e codifica in sRGB non lineare. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde/blu/alfa in virgola mobile senza segno a 8 bit per canale con valore normalizzato. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde/blu/alfa in virgola mobile con segno a 8 bit per canale con valore normalizzato. I valori sono compresi nell'intervallo ``[-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 dati di canali rosso/verde/blu/alfa in virgola mobile senza segno a 8 bit per canale con valore scalato (il valore è convertito da intero a float). I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde/blu/alfa in virgola mobile con segno a 8 bit per canale con valore scalato (il valore è convertito da intero a float). I valori sono compresi nell'intervallo ``[-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 dati di canali rosso/verde/blu/alfa interi senza segno a 8 bit per canale. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde/blu/alfa interi con segno a 8 bit per canale. I valori sono compresi nell'intervallo ``[-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 dati di canali rosso/verde/blu/alfa in virgola mobile senza segno a 8 bit per canale con valore normalizzato e codifica in sRGB non lineare. I valori sono compresi nell'intervallo ``[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 dati di canali blu/verde/rosso/alfa in virgola mobile senza segno a 8 bit per canale con valore normalizzato. I valori sono compresi nell'intervallo ``[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 dati di canali blu/verde/rosso/alfa in virgola mobile con segno a 8 bit per canale con valore normalizzato. I valori sono compresi nell'intervallo ``[-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 dati di canali blu/verde/rosso/alfa in virgola mobile senza segno a 8 bit per canale con valore scalato (il valore è convertito da intero a float). I valori sono compresi nell'intervallo ``[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 dati di canali blu/verde/rosso/alfa in virgola mobile con segno a 8 bit per canale con valore scalato (il valore è convertito da intero a float). I valori sono compresi nell'intervallo ``[-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 dati di canali blu/verde/rosso/alfa interi senza segno a 8 bit per canale. I valori sono compresi nell'intervallo ``[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 dati di canali blu/verde/rosso/alfa interi con segno a 8 bit per canale. I valori sono compresi nell'intervallo ``[-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 dati di canali blu/verde/rosso/alfa in virgola mobile senza segno a 8 bit per canale con valore normalizzato e codifica in sRGB non lineare. I valori sono compresi nell'intervallo ``[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 dati di canali alfa/rosso/verde/blu in virgola mobile senza segno a 8 bit per canale con valore normalizzato, racchiuso in 32 bit. I valori sono compresi nell'intervallo ``[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 dati di canali alfa /rosso/verde/blu in virgola mobile con segno a 8 bit per canale con valore normalizzato, racchiuso in 32 bit. I valori sono compresi nell'intervallo ``[-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 dati di canali alfa /rosso/verde/blu in virgola mobile senza segno a 8 bit per canale con valore scalato (il valore è convertito da intero a float), racchiuso in 32 bit. I valori sono compresi nell'intervallo ``[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 dati di canali alfa /rosso/verde/blu in virgola mobile con segno a 8 bit per canale con valore scalato (il valore è convertito da intero a float), racchiuso in 32 bit. I valori sono compresi nell'intervallo ``[-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 dati di canali alfa/rosso/verde/blu interi senza segno a 8 bit per canale, racchiuso in 32 bit. I valori sono compresi nell'intervallo ``[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 dati di canali alfa/rosso/verde/blu interi con segno a 8 bit per canale, racchiuso in 32 bit. I valori sono compresi nell'intervallo ``[-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 dati di canali alfa/rosso/verde/blu in virgola mobile senza segno a 8 bit per canale con valore normalizzato e codifica in sRGB non lineare, racchiuso in 32 bit. I valori sono compresi nell'intervallo ``[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 dati di canali alfa/rosso/verde/blu in virgola mobile senza segno con valore normalizzato, racchiuso in 32 bit. Il formato contiene 2 bit di alfa, 10 bit di rosso, 10 bit di verde e 10 bit di blu. I valori sono compresi nell'intervallo ``[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 dati di canali alfa/rosso/verde/blu in virgola mobile con segno con valore normalizzato, racchiuso in 32 bit. Il formato contiene 2 bit di alfa, 10 bit di rosso, 10 bit di verde e 10 bit di blu. I valori sono compresi nell'intervallo ``[-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 dati di canali alfa/rosso/verde/blu in virgola mobile senza segno con valore normalizzato, racchiuso in 32 bit. Il formato contiene 2 bit di alfa, 10 bit di rosso, 10 bit di verde e 10 bit di blu. I valori sono compresi nell'intervallo ``[0.0, 1023.0]`` per il rosso/verde/blu e ``[0.0, 3.0]`` per l'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 dati di canali alfa/rosso/verde/blu in virgola mobile con segno con valore normalizzato, racchiuso in 32 bit. Il formato contiene 2 bit di alfa, 10 bit di rosso, 10 bit di verde e 10 bit di blu. I valori sono compresi nell'intervallo ``[-511.0, 511.0]`` per il rosso/verde/blu e ``[-1.0, 1.0]`` per l'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 dati di canali alfa/rosso/verde/blu interi senza segno con valore normalizzato, racchiuso in 32 bit. Il formato contiene 2 bit di alfa, 10 bit di rosso, 10 bit di verde e 10 bit di blu. I valori sono compresi nell'intervallo ``[0, 1023]`` per il rosso/verde/blu e ``[0, 3]`` per l'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 dati di canali alfa/rosso/verde/blu interi con segno con valore normalizzato, racchiuso in 32 bit. Il formato contiene 2 bit di alfa, 10 bit di rosso, 10 bit di verde e 10 bit di blu. I valori sono compresi nell'intervallo ``[-511, 511]`` per il rosso/verde/blu e ``[-1, 1]`` per l'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 dati di canali alfa/blu/verde/rosso in virgola mobile senza segno con valore normalizzato, racchiuso in 32 bit. Il formato contiene 2 bit di alfa, 10 bit di blu, 10 bit di verde e 10 bit di rosso. I valori sono compresi nell'intervallo ``[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 dati di canali alfa/blu/verde/rosso in virgola mobile con segno con valore normalizzato, racchiuso in 32 bit. Il formato contiene 2 bit di alfa, 10 bit di blu, 10 bit di verde e 10 bit di rosso. I valori sono compresi nell'intervallo ``[-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 dati di canali alfa/blu/verde/rosso in virgola mobile senza segno con valore normalizzato, racchiuso in 32 bit. Il formato contiene 2 bit di alfa, 10 bit di blu, 10 bit di verde e 10 bit di rosso. I valori sono compresi nell'intervallo ``[0.0, 1023.0]`` per il blu/verde/rosso e ``[0.0, 3.0]`` per l'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 dati di canali alfa/blu/verde/rosso in virgola mobile con segno con valore normalizzato, racchiuso in 32 bit. Il formato contiene 2 bit di alfa, 10 bit di blu, 10 bit di verde e 10 bit di rosso. I valori sono compresi nell'intervallo ``[-511.0, 511.0]`` per il blu/verde/rosso e ``[-1.0, 1.0]`` per l'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 dati di canali alfa/blu/verde/rosso interi senza segno con valore normalizzato, racchiuso in 32 bit. Il formato contiene 2 bit di alfa, 10 bit di blu, 10 bit di verde e 10 bit di rosso. I valori sono compresi nell'intervallo ``[0, 1023]`` per il blu/verde/rosso e ``[0, 3]`` per l'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 dati di canali alfa/blu/verde/rosso interi con segno con valore normalizzato, racchiuso in 32 bit. Il formato contiene 2 bit di alfa, 10 bit di blu, 10 bit di verde e 10 bit di rosso. I valori sono compresi nell'intervallo ``[-511, 511]`` per il blu/verde/rosso e ``[-1, 1]`` per l'alfa.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16_UNORM** = ``69``
Formato dati di canale rosso in virgola mobile senza segno a 16 bit con valore normalizzato. I valori sono compresi nell'intervallo ``[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 dati di canale rosso in virgola mobile con segno a 16 bit con valore normalizzato. I valori sono compresi nell'intervallo ``[-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 dati di canale rosso in virgola mobile senza segno a 16 bit con valore scalato (il valore è convertito da intero a float). I valori sono compresi nell'intervallo ``[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 dati di canale rosso in virgola mobile con segno a 16 bit con valore scalato (il valore è convertito da intero a float). I valori sono compresi nell'intervallo ``[-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 dati di canale rosso intero senza segno a 16 bit. I valori sono compresi nell'intervallo ``[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 dati di canale rosso intero con segno a 16 bit. I valori sono compresi nell'intervallo ``[-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 dati di canale rosso in virgola mobile con segno a 16 bit per canale, con il valore memorizzato così com'è.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16_UNORM** = ``76``
Formato dati di canali rosso/verde in virgola mobile senza segno a 16 bit per canale con valore normalizzato. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde in virgola mobile con segno a 16 bit per canale con valore normalizzato. I valori sono compresi nell'intervallo ``[-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 dati di canali rosso/verde in virgola mobile senza segno a 16 bit per canale con valore scalato (il valore è convertito da intero a float). I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde in virgola mobile con segno a 16 bit per canale con valore scalato (il valore è convertito da intero a float). I valori sono compresi nell'intervallo ``[-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 dati di canali rosso/verde intero senza segno a 16 bit. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde intero con segno a 16 bit. I valori sono compresi nell'intervallo ``[-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 dati di canali rosso/verde in virgola mobile con segno a 16 bit per canale, con il valore memorizzato così com'è.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16B16_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16B16_UNORM** = ``83``
Formato dati di canali rosso/verde/blu in virgola mobile senza segno a 16 bit per canale con valore normalizzato. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde/blu in virgola mobile con segno a 16 bit per canale con valore normalizzato. I valori sono compresi nell'intervallo ``[-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 dati di canali rosso/verde/blu in virgola mobile senza segno a 16 bit per canale con valore scalato (il valore è convertito da intero a float). I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde/blu in virgola mobile con segno a 16 bit per canale con valore scalato (il valore è convertito da intero a float). I valori sono compresi nell'intervallo ``[-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 dati di canali rosso/verde/blu intero senza segno a 16 bit per canale. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde/blu intero con segno a 16 bit per canale. I valori sono compresi nell'intervallo ``[-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 dati di canali rosso/verde/blu in virgola mobile con segno a 16 bit per canale, con il valore memorizzato così com'è.
.. _class_RenderingDevice_constant_DATA_FORMAT_R16G16B16A16_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R16G16B16A16_UNORM** = ``90``
Formato dati di canali rosso/verde/blu/alfa in virgola mobile con segno a 16 bit per canale con valore normalizzato. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde/blu/alfa in virgola mobile senza segno a 16 bit per canale con valore normalizzato. I valori sono compresi nell'intervallo ``[-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 dati di canali rosso/verde/blu/alfa in virgola mobile senza segno a 16 bit per canale con valore scalato (il valore è convertito da intero a float). I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde/blu/alfa in virgola mobile con segno a 16 bit per canale con valore scalato (il valore è convertito da intero a float). I valori sono compresi nell'intervallo ``[-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 dati di canali rosso/verde/blu/alfa interi senza segno a 16 bit per canale. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde/blu/alfa interi con segno a 16 bit per canale. I valori sono compresi nell'intervallo ``[-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 dati di canali rosso/verde/blu/alfa in virgola mobile con segno a 16 bit per canale, con il valore memorizzato così com'è.
.. _class_RenderingDevice_constant_DATA_FORMAT_R32_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R32_UINT** = ``97``
Formato dati di canale rosso intero senza segno a 32 bit. I valori sono compresi nell'intervallo ``[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 dati di canale rosso intero con segno a 32 bit. I valori sono compresi nell'intervallo ``[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 dati di canali rosso in virgola mobile con segno a 32 bit per canale, con il valore memorizzato così com'è.
.. _class_RenderingDevice_constant_DATA_FORMAT_R32G32_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R32G32_UINT** = ``100``
Formato dati di canali rosso/verde interi senza segno a 32 bit. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde interi con segno a 32 bit. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde in virgola mobile con segno a 32 bit per canale, con il valore memorizzato così com'è.
.. _class_RenderingDevice_constant_DATA_FORMAT_R32G32B32_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R32G32B32_UINT** = ``103``
Formato dati di canali rosso/verde/blu interi senza segno a 32 bit. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde/blu interi con segno a 32 bit. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde/blu in virgola mobile con segno a 32 bit per canale, con il valore memorizzato così com'è.
.. _class_RenderingDevice_constant_DATA_FORMAT_R32G32B32A32_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R32G32B32A32_UINT** = ``106``
Formato dati di canali rosso/verde/blu/alfa interi senza segno a 32 bit. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde/blu/alfa interi con segno a 32 bit. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde/blu/alfa in virgola mobile con segno a 32 bit per canale, con il valore memorizzato così com'è.
.. _class_RenderingDevice_constant_DATA_FORMAT_R64_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R64_UINT** = ``109``
Formato dati di canale rosso intero senza segno a 64 bit. I valori sono compresi nell'intervallo ``[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 dati di canale rosso intero con segno a 64 bit. I valori sono compresi nell'intervallo ``[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 dati di canale rosso in virgola mobile con segno a 64 bit, con il valore memorizzato così com'è.
.. _class_RenderingDevice_constant_DATA_FORMAT_R64G64_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R64G64_UINT** = ``112``
Formato dati di canali rosso/verde interi senza segno a 64 bit. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde interi con segno a 64 bit. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde in virgola mobile con segno a 64 bit, con il valore memorizzato così com'è.
.. _class_RenderingDevice_constant_DATA_FORMAT_R64G64B64_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R64G64B64_UINT** = ``115``
Formato dati di canali rosso/verde/blu interi senza segno a 64 bit. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde/blu interi con segno a 64 bit. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde/blu in virgola mobile con segno a 64 bit, con il valore memorizzato così com'è.
.. _class_RenderingDevice_constant_DATA_FORMAT_R64G64B64A64_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_R64G64B64A64_UINT** = ``118``
Formato dati di canali rosso/verde/blu/alfa interi senza segno a 64 bit. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde/blu/alfa interi con segno a 64 bit. I valori sono compresi nell'intervallo ``[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 dati di canali rosso/verde/blu/alfa in virgola mobile con segno a 64 bit, con il valore memorizzato così com'è.
.. _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 dati di canali blu/verde/rosso in virgola mobile senza segno, con il valore memorizzato così com'è, racchiuso in 32 bit. La precisione del formato è 10 bit per il canale blu, 11 bit per il canale verde e 11 bit per il canale rosso.
.. _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 dati di canali esposizione/blu/verde/rosso in virgola mobile senza segno, con il valore memorizzato così com'è, racchiuso in 32 bit. La precisione del formato è 5 bit per l'esposizione, 9 bit per il canale blu, 9 bit per il canale verde e 9 bit per il canale rosso.
.. _class_RenderingDevice_constant_DATA_FORMAT_D16_UNORM:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_D16_UNORM** = ``123``
Formato dati di profondità in virgola mobile senza segno a 16 bit con valore normalizzato. I valori sono compresi nell'intervallo ``[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 dati di profondità in virgola mobile senza segno a 24 bit con valore normalizzato, più 8 bit inutilizzati, racchiusi in 32 bit. I valori sono compresi nell'intervallo ``[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 dati di profondità in virgola mobile con segno a 32 bit, con il valore memorizzato così com'è.
.. _class_RenderingDevice_constant_DATA_FORMAT_S8_UINT:
.. rst-class:: classref-enumeration-constant
:ref:`DataFormat<enum_RenderingDevice_DataFormat>` **DATA_FORMAT_S8_UINT** = ``126``
Formato dati di stencil intero senza segno a 8 bit.
.. _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 dati di profondità in virgola mobile senza segno a 16 bit con valore normalizzato, più 8 bit di stencil in formato intero senza segno. I valori per la profondità sono compresi nell'intervallo ``[0.0, 1.0]``. I valori per lo stencil sono compresi nell'intervallo ``[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 dati di profondità in virgola mobile senza segno a 24 bit con valore normalizzato, più 8 bit di stencil in formato intero senza segno. I valori per la profondità sono compresi nell'intervallo ``[0.0, 1.0]``. I valori per lo stencil sono compresi nell'intervallo ``[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 dati di profondità in virgola mobile senza segno a 32 bit, con il valore memorizzato così com'è, più 8 bit di stencil in formato intero senza segno. I valori per lo stencil sono compresi nell'intervallo ``[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 dati di canali rosso/verde/blu senza segno compresso in VRAM con valore normalizzato. I valori sono nell'intervallo ``[0.0, 1.0]``. La precisione del formato è di 5 bit per il canale rosso, 6 bit per il canale verde e 5 bit per il canale blu. Utilizza la compressione texture BC1 (nota anche come 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 dati di canali rosso/verde/blu senza segno compresso in VRAM con valore normalizzato e codifica in sRGB non lineare. I valori sono nell'intervallo ``[0.0, 1.0]``. La precisione del formato è di 5 bit per il canale rosso, 6 bit per il canale verde e 5 bit per il canale blu. Utilizza la compressione texture BC1 (nota anche come 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 dati di canali rosso/verde/blu/alfa senza segno compresso in VRAM con valore normalizzato. I valori sono nell'intervallo ``[0.0, 1.0]``. La precisione del formato è di 5 bit per il canale rosso, 6 bit per il canale verde, 5 bit per il canale blu e 1 bit per il canale alfa. Utilizza la compressione texture BC1 (nota anche come 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 dati di canali rosso/verde/blu/alfa senza segno compresso in VRAM con valore normalizzato e codifica in sRGB non lineare. I valori sono nell'intervallo ``[0.0, 1.0]``. La precisione del formato è di 5 bit per il canale rosso, 6 bit per il canale verde, 5 bit per il canale blu e 1 bit per il canale alfa. Utilizza la compressione texture BC1 (nota anche come 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 dati di canali rosso/verde/blu/alfa compresso per VRAM senza segno con valore normalizzato. I valori sono nell'intervallo ``[0.0, 1.0]``. La precisione del formato è di 5 bit per il canale rosso, 6 bit per il canale verde, 5 bit per il canale blu e 4 bit per il canale alfa. Utilizza la compressione texture BC2 (nota anche come 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 dati di canali rosso/verde/blu/alfa compresso per VRAM senza segno con valore normalizzato e codifica in sRGB non lineare. I valori sono nell'intervallo ``[0.0, 1.0]``. La precisione del formato è di 5 bit per il canale rosso, 6 bit per il canale verde, 5 bit per il canale blu e 4 bit per il canale alfa. Utilizza la compressione texture BC2 (nota anche come 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 dati di canali rosso/verde/blu/alfa compresso per VRAM senza segno con valore normalizzato. I valori sono nell'intervallo ``[0.0, 1.0]``. La precisione del formato è di 5 bit per il canale rosso, 6 bit per il canale verde, 5 bit per il canale blu e 8 bit per il canale alfa. Utilizza la compressione texture BC3 (nota anche come 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 dati di canali rosso/verde/blu/alfa compresso per VRAM senza segno con valore normalizzato e codifica in sRGB non lineare. I valori sono nell'intervallo ``[0.0, 1.0]``. La precisione del formato è di 5 bit per il canale rosso, 6 bit per il canale verde, 5 bit per il canale blu e 8 bit per il canale alfa. Utilizza la compressione texture BC3 (nota anche come 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 dati di canale rosso compresso per VRAM senza segno con valore normalizzato. I valori sono nell'intervallo ``[0.0, 1.0]``. La precisione del formato è di 8 bit per il canale rosso. Utilizza la compressione texture 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 dati di canale rosso compresso per VRAM con segno con valore normalizzato. I valori sono nell'intervallo ``[-1.0, 1.0]``. La precisione del formato è di 8 bit per il canale rosso. Utilizza la compressione texture 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 dati di canali rosso/verde compresso per VRAM senza segno con valore normalizzato. I valori sono nell'intervallo ``[0.0, 1.0]``. La precisione del formato è di 8 bit per il canale rosso e 8 bit per il canale verde. Utilizza la compressione texture BC5 (nota anche come 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 dati di canali rosso/verde compresso per VRAM con segno con valore normalizzato. I valori sono nell'intervallo ``[-1.0, 1.0]``. La precisione del formato è di 8 bit per il canale rosso e 8 bit per il canale verde. Utilizza la compressione texture BC5 (nota anche come 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 dati di canali rosso/verde/blu compresso per VRAM senza segno con il valore in virgola mobile memorizzato così com'è. La precisione del formato è tra 10 e 13 bit per il canali rosso/verde/blu. Utilizza la compressione texture BC6H (nota anche come 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 dati di canali rosso/verde/blu compresso per VRAM con segno con il valore in virgola mobile memorizzato così com'è. La precisione del formato è tra 10 e 13 bit per il canali rosso/verde/blu. Utilizza la compressione texture BC6H (nota anche come 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 dati di canali rosso/verde/blu compresso per VRAM senza segno con valore normalizzato. I valori sono nell'intervallo ``[0.0, 1.0]``. La precisione del formato è tra 4 e 7 bit per il canali rosso/verde/blu e tra 0 e 8 bit per il canale alfa. Noto anche come 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 dati di canali rosso/verde/blu compresso per VRAM senza segno con valore normalizzato e codifica in sRGB non lineare. I valori sono nell'intervallo ``[0.0, 1.0]``. La precisione del formato è tra 4 e 7 bit per il canali rosso/verde/blu e tra 0 e 8 bit per il canale alfa. Noto anche come 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 dati di canali rosso/verde/blu senza segno compresso VRAM con valore normalizzato. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione texture 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 dati di canali rosso/verde/blu senza segno compresso VRAM con valore normalizzato e codifica in sRGB non lineare. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione texture 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 dati di canali rosso/verde/blu/alfa senza segno compresso VRAM con valore normalizzato. I valori sono nell'intervallo ``[0.0, 1.0]``. Rosso/verde/blu usano 8 bit di precisione ciascuno, con l'alfa che usa 1 bit di precisione. Utilizza la compressione texture 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 dati di canali rosso/verde/blu/alfa senza segno compresso VRAM con valore normalizzato e codifica in sRGB non lineare. I valori sono nell'intervallo ``[0.0, 1.0]``. Rosso/verde/blu usano 8 bit di precisione ciascuno, con l'alfa che usa 1 bit di precisione. Utilizza la compressione texture 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 dati di canali rosso/verde/blu/alfa senza segno compresso VRAM con valore normalizzato. I valori sono nell'intervallo ``[0.0, 1.0]``. Rosso/verde/blu usano 8 bit di precisione ciascuno, con l'alfa che usa 8 bit di precisione. Utilizza la compressione texture 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 dati di canali rosso/verde/blu/alfa senza segno compresso VRAM con valore normalizzato e codifica in sRGB non lineare. I valori sono nell'intervallo ``[0.0, 1.0]``. Rosso/verde/blu usano 8 bit di precisione ciascuno, con l'alfa che usa 8 bit di precisione. Utilizza la compressione texture 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 dati di canale rosso senza segno compresso in VRAM a 11 bit con valore normalizzato. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione texture 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 dati di canale rosso con segno compresso in VRAM a 11 bit con valore normalizzato. I valori sono nell'intervallo ``[-1.0, 1.0]``. Utilizza la compressione texture 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 dati di canali rosso/verde senza segno compresso in VRAM a 11 bit con valore normalizzato. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione texture 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 dati di canali rosso/verde senza segno compresso in VRAM a 11 bit con valore normalizzato. I valori sono nell'intervallo ``[-1.0, 1.0]``. Utilizza la compressione texture 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato, compresso in blocchi 4×4 (massima qualità). I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato e codifica in sRGB non lineare, compresso in blocchi 4×4 (massima qualità). I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato, compresso in blocchi 5×4. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato e codifica in sRGB non lineare, compresso in blocchi 5×4. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato, compresso in blocchi 5×5. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato e codifica in sRGB non lineare, compresso in blocchi 5×5. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato, compresso in blocchi 6×5. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato e codifica in sRGB non lineare, compresso in blocchi 6×5. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato, compresso in blocchi 6×6. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato e codifica in sRGB non lineare, compresso in blocchi 6×6. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato, compresso in blocchi 8×5. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato e codifica in sRGB non lineare, compresso in blocchi 8×5. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato, compresso in blocchi 8×6. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato e codifica in sRGB non lineare, compresso in blocchi 8×6. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato, compresso in blocchi 8×8. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato e codifica in sRGB non lineare, compresso in blocchi 8×8. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato, compresso in blocchi 10×5. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato e codifica in sRGB non lineare, compresso in blocchi 10×5. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato, compresso in blocchi 10×6. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato e codifica in sRGB non lineare, compresso in blocchi 10×6. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato, compresso in blocchi 10×8. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato e codifica in sRGB non lineare, compresso in blocchi 10×8. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato, compresso in blocchi 10×10. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato e codifica in sRGB non lineare, compresso in blocchi 10×10. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato, compresso in blocchi 12×10. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato e codifica in sRGB non lineare, compresso in blocchi 12×10. I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato, compresso in 12 blocchi (minore qualità). I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati in virgola mobile senza segno compresso in VRAM con valore normalizzato e codifica in sRGB non lineare, compresso in 12 blocchi (minore qualità). I valori sono nell'intervallo ``[0.0, 1.0]``. Utilizza la compressione 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 dati dei canali verde/blu/rosso in virgola mobile senza segno a 8 bit per canale con valore normalizzato. I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati a una risoluzione orizzontale dimezzata (ovvero, 2 pixel orizzontalmente adiacenti condivideranno lo stesso valore per il canale blu/rosso).
.. _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 dati dei canali blu/verde/rosso in virgola mobile senza segno a 8 bit per canale con valore normalizzato. I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati a una risoluzione orizzontale dimezzata (ovvero, 2 pixel orizzontalmente adiacenti condivideranno lo stesso valore per il canale blu/rosso).
.. _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``
Formato dati dei canali verde/blu/rosso in virgola mobile senza segno a 8 bit per canale con valore normalizzato, memorizzati su 3 piani separati (verde + blu + rosso). I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati con una risoluzione orizzontale e verticale dimezzata (ovvero, 2×2 pixel adiacenti condivideranno lo stesso valore per il canale blu/rosso).
.. _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``
Formato dati dei canali verde/blu/rosso in virgola mobile senza segno a 8 bit per canale con valore normalizzato, memorizzati su 2 piani separati (verde + blu/rosso). I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati con una risoluzione orizzontale e verticale dimezzata (ovvero, 2×2 pixel adiacenti condivideranno lo stesso valore per il canale blu/rosso).
.. _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``
Formato dati dei canali verde/blu/rosso in virgola mobile senza segno a 8 bit per canale con valore normalizzato, memorizzati su 2 piani separati (verde + blu + rosso). I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati con una risoluzione orizzontale dimezzata (ovvero, 2×2 pixel adiacenti condivideranno lo stesso valore per il canale blu/rosso).
.. _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``
Formato dati dei canali verde/blu/rosso in virgola mobile senza segno a 8 bit per canale con valore normalizzato, memorizzati su 2 piani separati (verde + blu/rosso). I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati con una risoluzione orizzontale dimezzata (ovvero, 2 pixel adiacenti condivideranno lo stesso valore per il canale blu/rosso).
.. _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``
Formato dati dei canali verde/blu/rosso in virgola mobile senza segno a 8 bit per canale con valore normalizzato, memorizzati su 3 piani separati. I valori sono compresi nell'intervallo ``[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``
Formato dati del canale rosso in virgola mobile senza segno a 10 bit con valore normalizzato, più 6 bit non utilizzati, compressi in 16 bit. I valori sono compresi nell'intervallo ``[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``
Formato dati dei canali rosso/verde in virgola mobile senza segno a 10 bit per canale con valore normalizzato, più 6 bit non utilizzati, compressi in 2×16 bit. I valori sono compresi nell'intervallo ``[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``
Formato dati dei canali rosso/verde/blu/alfa in virgola mobile senza segno a 10 bit per canale con valore normalizzato, più 6 bit non utilizzati, compressi in 4×16 bit. I valori sono compresi nell'intervallo ``[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``
Formato dati dei canali verde/blu/verde/rosso in virgola mobile senza segno a 10 bit per canale con valore normalizzato, più 6 bit non utilizzati, compressi in 4×16 bit. I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati a una risoluzione orizzontale dimezzata (ovvero, 2 pixel adiacenti orizzontalmente condivideranno lo stesso valore per il canale blu/rosso). Il canale verde è elencato due volte, ma contiene valori diversi per consentirne la rappresentazione a piena risoluzione.
.. _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``
Formato dati dei canali blu/verde/rosso/verdein virgola mobile senza segno a 10 bit per canale con valore normalizzato, più 6 bit non utilizzati, compressi in 4×16 bit. I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati a una risoluzione orizzontale dimezzata (ovvero, 2 pixel adiacenti orizzontalmente condivideranno lo stesso valore per il canale blu/rosso). Il canale verde è elencato due volte, ma contiene valori diversi per consentirne la rappresentazione a piena risoluzione.
.. _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``
Formato dati dei canali verde/blu/rosso in virgola mobile senza segno a 10 bit per canale con valore normalizzato, più 6 bit non utilizzati dopo ciascun canale. Compressi in 3×16 bit e memorizzati su 2 piani separati (verde + blu + rosso). I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati con una risoluzione orizzontale e verticale dimezzata (ovvero, 2×2 pixel adiacenti condivideranno lo stesso valore per il canale blu/rosso).
.. _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``
Formato dati dei canali verde/blu/rosso in virgola mobile senza segno a 10 bit per canale con valore normalizzato, più 6 bit non utilizzati dopo ciascun canale. Compressi in 3×16 bit e memorizzati su 2 piani separati (verde + blu/rosso). I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati con una risoluzione orizzontale e verticale dimezzata (ovvero, 2×2 pixel adiacenti condivideranno lo stesso valore per il canale blu/rosso).
.. _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``
Formato dati dei canali verde/blu/rosso in virgola mobile senza segno a 10 bit per canale con valore normalizzato, più 6 bit non utilizzati dopo ciascun canale. Compressi in 3×16 bit e memorizzati su 3 piani separati (verde + blu + rosso). I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati con una risoluzione orizzontale e verticale dimezzata (ovvero, 2×2 pixel adiacenti condivideranno lo stesso valore per il canale blu/rosso).
.. _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``
Formato dati dei canali verde/blu/rosso in virgola mobile senza segno a 10 bit per canale con valore normalizzato, più 6 bit non utilizzati dopo ciascun canale. Compressi in 3×16 bit e memorizzati su 3 piani separati (verde + blu/rosso). I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati con una risoluzione orizzontale dimezzata (ovvero, 2 pixel adiacenti orizzontalmente condivideranno lo stesso valore per il canale blu/rosso).
.. _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``
Formato dati dei canali verde/blu/rosso in virgola mobile senza segno a 10 bit per canale con valore normalizzato, più 6 bit non utilizzati dopo ciascun canale. Compressi in 3×16 bit e memorizzati su 3 piani separati (verde + blu + rosso). I valori sono compresi nell'intervallo ``[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``
Formato dati del canale rosso in virgola mobile senza segno a 12 bit con valore normalizzato, più 6 bit non utilizzati, compressi in 16 bit. I valori sono compresi nell'intervallo ``[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``
Formato dati dei canali rosso/verde in virgola mobile senza segno a 12 bit con valore normalizzato, più 6 bit non utilizzati, compressi in 2×16 bit. I valori sono compresi nell'intervallo ``[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``
Formato dati dei canali rosso/verde/blu/alfa in virgola mobile senza segno a 12 bit con valore normalizzato, più 6 bit non utilizzati, compressi in 4×16 bit. I valori sono compresi nell'intervallo ``[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``
Formato dati dei canali verde/blu/verde/rosso in virgola mobile senza segno a 12 bit per canale con valore normalizzato, più 6 bit non utilizzati, compressi in 4×16 bit. I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati a una risoluzione orizzontale dimezzata (ovvero, 2 pixel adiacenti orizzontalmente condivideranno lo stesso valore per il canale blu/rosso). Il canale verde è elencato due volte, ma contiene valori diversi per consentirne la rappresentazione a piena risoluzione.
.. _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``
Formato dati dei canali blue/verde/rosso/verde in virgola mobile senza segno a 12 bit per canale con valore normalizzato, più 6 bit non utilizzati, compressi in 4×16 bit. I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati a una risoluzione orizzontale dimezzata (ovvero, 2 pixel adiacenti orizzontalmente condivideranno lo stesso valore per il canale blu/rosso). Il canale verde è elencato due volte, ma contiene valori diversi per consentirne la rappresentazione a piena risoluzione.
.. _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``
Formato dati dei canali verde/blu/rosso in virgola mobile senza segno a 12 bit per canale con valore normalizzato, più 6 bit non utilizzati dopo ciascun canale. Compressi in 3×16 bit e memorizzati su 2 piani separati (verde + blu + rosso). I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati con una risoluzione orizzontale e verdicale dimezzata (ovvero, 2×2 pixel adiacenti condivideranno lo stesso valore per il canale blu/rosso).
.. _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``
Formato dati dei canali verde/blu/rosso in virgola mobile senza segno a 12 bit per canale con valore normalizzato, più 6 bit non utilizzati dopo ciascun canale. Compressi in 3×16 bit e memorizzati su 2 piani separati (verde + blu/rosso). I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati con una risoluzione orizzontale e verdicale dimezzata (ovvero, 2×2 pixel adiacenti condivideranno lo stesso valore per il canale blu/rosso).
.. _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``
Formato dati dei canali verde/blu/rosso in virgola mobile senza segno a 12 bit per canale con valore normalizzato, più 6 bit non utilizzati dopo ciascun canale. Compressi in 3×16 bit e memorizzati su 3 piani separati (verde + blu + rosso). I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati con una risoluzione orizzontale dimezzata (ovvero, 2 pixel adiacenti orizzontalmente condivideranno lo stesso valore per il canale blu/rosso).
.. _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``
Formato dati dei canali verde/blu/rosso in virgola mobile senza segno a 12 bit per canale con valore normalizzato, più 6 bit non utilizzati dopo ciascun canale. Compressi in 3×16 bit e memorizzati su 3 piani separati (verde + blu/rosso). I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati con una risoluzione orizzontale dimezzata (ovvero, 2 pixel adiacenti orizzontalmente condivideranno lo stesso valore per il canale blu/rosso).
.. _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``
Formato dati dei canali verde/blu/rosso in virgola mobile senza segno a 12 bit per canale con valore normalizzato, più 6 bit non utilizzati dopo ciascun canale. Compressi in 3×16 bit e memorizzati su 3 piani separati (verde + blu + rosso). I valori sono compresi nell'intervallo ``[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 dati dei canali verde/blu/rosso in virgola mobile senza segno a 16 bit per canale con valore normalizzato. I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati con una risoluzione orizzontale dimezzata (ovvero, 2 pixel adiacenti orizzontalmente condivideranno lo stesso valore per il canale blu/rosso).
.. _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 dati dei canali blu/verde/rosso in virgola mobile senza segno a 16 bit per canale con valore normalizzato. I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati con una risoluzione orizzontale dimezzata (ovvero, 2 pixel adiacenti orizzontalmente condivideranno lo stesso valore per il canale blu/rosso).
.. _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``
Formato dati dei canali verde/blu/rosso in virgola mobile senza segno a 16 bit per canale con valore normalizzato, più 6 bit non utilizzati dopo ciascun canale. Memorizzati su 2 piani separati (verde + blu + rosso). I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati con una risoluzione orizzontale e verticale dimezzata (ovvero, 2×2 pixel adiacenti condivideranno lo stesso valore per il canale blu/rosso).
.. _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``
Formato dati dei canali verde/blu/rosso in virgola mobile senza segno a 16 bit per canale con valore normalizzato, più 6 bit non utilizzati dopo ciascun canale. Memorizzati su 2 piani separati (verde + blu/rosso). I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati con una risoluzione orizzontale e verticale dimezzata (ovvero, 2×2 pixel adiacenti condivideranno lo stesso valore per il canale blu/rosso).
.. _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``
Formato dati dei canali verde/blu/rosso in virgola mobile senza segno a 16 bit per canale con valore normalizzato, più 6 bit non utilizzati dopo ciascun canale. Memorizzati su 3 piani separati (verde + blu + rosso). I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati con una risoluzione orizzontale dimezzata (ovvero, 2 pixel adiacenti orizzontalmente condivideranno lo stesso valore per il canale blu/rosso).
.. _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``
Formato dati dei canali verde/blu/rosso in virgola mobile senza segno a 16 bit per canale con valore normalizzato, più 6 bit non utilizzati dopo ciascun canale. Memorizzati su 3 piani separati (verde + blu/rosso). I valori sono compresi nell'intervallo ``[0.0, 1.0]``. I dati dei canali blu e rosso sono memorizzati con una risoluzione orizzontale dimezzata (ovvero, 2 pixel adiacenti orizzontalmente condivideranno lo stesso valore per il canale blu/rosso).
.. _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``
Formato dati dei canali verde/blu/rosso in virgola mobile senza segno a 16 bit per canale con valore normalizzato, più 6 bit non utilizzati dopo ciascun canale. Memorizzati su 3 piani separati (verde + blu + rosso). I valori sono compresi nell'intervallo ``[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``
Rappresenta la dimensione dell'enumerazione :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``
Maschera di barriera per tutti i tipi (vertice, frammento, calcolo, trasferimento).
.. _class_RenderingDevice_constant_BARRIER_MASK_NO_BARRIER:
.. rst-class:: classref-enumeration-constant
:ref:`BarrierMask<enum_RenderingDevice_BarrierMask>` **BARRIER_MASK_NO_BARRIER** = ``32768``
Nessuna barriera per qualsiasi tipo.
.. 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``
Texture a 1 dimensione.
.. _class_RenderingDevice_constant_TEXTURE_TYPE_2D:
.. rst-class:: classref-enumeration-constant
:ref:`TextureType<enum_RenderingDevice_TextureType>` **TEXTURE_TYPE_2D** = ``1``
Texture a 2 dimensioni.
.. _class_RenderingDevice_constant_TEXTURE_TYPE_3D:
.. rst-class:: classref-enumeration-constant
:ref:`TextureType<enum_RenderingDevice_TextureType>` **TEXTURE_TYPE_3D** = ``2``
Texture a 3 dimensioni.
.. _class_RenderingDevice_constant_TEXTURE_TYPE_CUBE:
.. rst-class:: classref-enumeration-constant
:ref:`TextureType<enum_RenderingDevice_TextureType>` **TEXTURE_TYPE_CUBE** = ``3``
Texture :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``
Array di texture a 1 dimensione.
.. _class_RenderingDevice_constant_TEXTURE_TYPE_2D_ARRAY:
.. rst-class:: classref-enumeration-constant
:ref:`TextureType<enum_RenderingDevice_TextureType>` **TEXTURE_TYPE_2D_ARRAY** = ``5``
Array di texture a 2 dimensioni.
.. _class_RenderingDevice_constant_TEXTURE_TYPE_CUBE_ARRAY:
.. rst-class:: classref-enumeration-constant
:ref:`TextureType<enum_RenderingDevice_TextureType>` **TEXTURE_TYPE_CUBE_ARRAY** = ``6``
Array di texture :ref:`Cubemap<class_Cubemap>`.
.. _class_RenderingDevice_constant_TEXTURE_TYPE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`TextureType<enum_RenderingDevice_TextureType>` **TEXTURE_TYPE_MAX** = ``7``
Rappresenta la dimensione dell'enumerazione :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``
Effettua 1 campione di texture (è il metodo più veloce ma di qualità inferiore per l'antialiasing).
.. _class_RenderingDevice_constant_TEXTURE_SAMPLES_2:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSamples<enum_RenderingDevice_TextureSamples>` **TEXTURE_SAMPLES_2** = ``1``
Effettua 2 campioni di texture.
.. _class_RenderingDevice_constant_TEXTURE_SAMPLES_4:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSamples<enum_RenderingDevice_TextureSamples>` **TEXTURE_SAMPLES_4** = ``2``
Effettua 4 campioni di texture.
.. _class_RenderingDevice_constant_TEXTURE_SAMPLES_8:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSamples<enum_RenderingDevice_TextureSamples>` **TEXTURE_SAMPLES_8** = ``3``
Effettua 8 campioni di texture. Non supportato su GPU mobili (incluso Apple Silicon).
.. _class_RenderingDevice_constant_TEXTURE_SAMPLES_16:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSamples<enum_RenderingDevice_TextureSamples>` **TEXTURE_SAMPLES_16** = ``4``
Effettua 16 campioni di texture. Non supportato su GPU mobili e su molte GPU desktop.
.. _class_RenderingDevice_constant_TEXTURE_SAMPLES_32:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSamples<enum_RenderingDevice_TextureSamples>` **TEXTURE_SAMPLES_32** = ``5``
Effettua 32 campioni di texture. Non supportato sulla maggior parte delle GPU.
.. _class_RenderingDevice_constant_TEXTURE_SAMPLES_64:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSamples<enum_RenderingDevice_TextureSamples>` **TEXTURE_SAMPLES_64** = ``6``
Effettua 32 campioni di texture (è il più lento ma di qualità più elevata per l'antialiasing). Non supportato sulla maggior parte delle GPU.
.. _class_RenderingDevice_constant_TEXTURE_SAMPLES_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSamples<enum_RenderingDevice_TextureSamples>` **TEXTURE_SAMPLES_MAX** = ``7``
Rappresenta la dimensione dell'enumerazione :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 texture può essere campionata.
.. _class_RenderingDevice_constant_TEXTURE_USAGE_COLOR_ATTACHMENT_BIT:
.. rst-class:: classref-enumeration-constant
:ref:`TextureUsageBits<enum_RenderingDevice_TextureUsageBits>` **TEXTURE_USAGE_COLOR_ATTACHMENT_BIT** = ``2``
La texture può essere usata come allegato di colore in un 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``
La texture può essere usata come allegato di profondità/stencil in un framebuffer.
.. _class_RenderingDevice_constant_TEXTURE_USAGE_STORAGE_BIT:
.. rst-class:: classref-enumeration-constant
:ref:`TextureUsageBits<enum_RenderingDevice_TextureUsageBits>` **TEXTURE_USAGE_STORAGE_BIT** = ``8``
La texture può essere usata come `immagine di archiviazione <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 texture può essere usata come `immagine di archiviazione <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#descriptorsets-storageimage>`__ con supporto per operazioni atomiche.
.. _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 texture può essere letta sulla CPU attraverso :ref:`texture_get_data()<class_RenderingDevice_method_texture_get_data>` più velocemente rispetto a quando non si utilizza questo bit, poiché viene sempre conservata nella 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 texture può essere aggiornata tramite :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 texture può essere una sorgente per :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 texture può essere una destinazione per :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``
La texture può essere utilizzata come `allegato di input <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#descriptorsets-inputattachment>`__ in un 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``
Restituite il valore prelevato come è.
.. _class_RenderingDevice_constant_TEXTURE_SWIZZLE_ZERO:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSwizzle<enum_RenderingDevice_TextureSwizzle>` **TEXTURE_SWIZZLE_ZERO** = ``1``
Restituisce sempre ``0.0`` al campionamento.
.. _class_RenderingDevice_constant_TEXTURE_SWIZZLE_ONE:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSwizzle<enum_RenderingDevice_TextureSwizzle>` **TEXTURE_SWIZZLE_ONE** = ``2``
Restituisce sempre ``1.0`` al campionamento.
.. _class_RenderingDevice_constant_TEXTURE_SWIZZLE_R:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSwizzle<enum_RenderingDevice_TextureSwizzle>` **TEXTURE_SWIZZLE_R** = ``3``
Campiona il canale del colore rosso.
.. _class_RenderingDevice_constant_TEXTURE_SWIZZLE_G:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSwizzle<enum_RenderingDevice_TextureSwizzle>` **TEXTURE_SWIZZLE_G** = ``4``
Campiona il canale del colore verde.
.. _class_RenderingDevice_constant_TEXTURE_SWIZZLE_B:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSwizzle<enum_RenderingDevice_TextureSwizzle>` **TEXTURE_SWIZZLE_B** = ``5``
Campiona il canale del colore blu.
.. _class_RenderingDevice_constant_TEXTURE_SWIZZLE_A:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSwizzle<enum_RenderingDevice_TextureSwizzle>` **TEXTURE_SWIZZLE_A** = ``6``
Campiona il canale dell'alfa.
.. _class_RenderingDevice_constant_TEXTURE_SWIZZLE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSwizzle<enum_RenderingDevice_TextureSwizzle>` **TEXTURE_SWIZZLE_MAX** = ``7``
Rappresenta la dimensione dell'enumerazione :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``
Sezione di texture a 2 dimensioni.
.. _class_RenderingDevice_constant_TEXTURE_SLICE_CUBEMAP:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSliceType<enum_RenderingDevice_TextureSliceType>` **TEXTURE_SLICE_CUBEMAP** = ``1``
Sezione di texture Cubemap.
.. _class_RenderingDevice_constant_TEXTURE_SLICE_3D:
.. rst-class:: classref-enumeration-constant
:ref:`TextureSliceType<enum_RenderingDevice_TextureSliceType>` **TEXTURE_SLICE_3D** = ``2``
Sezione di texture a 3 dimensioni.
.. 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``
Filtraggio del vicino più ravvicinato per il campionatore. Il campionamento a risoluzioni più elevate rispetto alla sorgente risulterà in un aspetto pixelato.
.. _class_RenderingDevice_constant_SAMPLER_FILTER_LINEAR:
.. rst-class:: classref-enumeration-constant
:ref:`SamplerFilter<enum_RenderingDevice_SamplerFilter>` **SAMPLER_FILTER_LINEAR** = ``1``
Filtraggio bilineare per il campionatore. Il campionamento a risoluzioni più elevate rispetto alla sorgente risulterà in un aspetto sfocato.
.. 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``
Campiona con la ripetizione abilitata.
.. _class_RenderingDevice_constant_SAMPLER_REPEAT_MODE_MIRRORED_REPEAT:
.. rst-class:: classref-enumeration-constant
:ref:`SamplerRepeatMode<enum_RenderingDevice_SamplerRepeatMode>` **SAMPLER_REPEAT_MODE_MIRRORED_REPEAT** = ``1``
Campiona con ripetizione specchiata abilitata. Quando si campiona al di fuori dell'intervallo ``[0.0, 1.0]``, restituisce una versione specchiata del campionatore. Questa versione specchiata viene nuovamente specchiata se si campiona più lontano, con uno schema che si ripete indefinitamente.
.. _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``
Campiona con la ripetizione disabilitata. Quando si effettua il campionamento al di fuori dell'intervallo ``[0.0, 1.0]``, restituisce il colore dell'ultimo pixel sul bordo.
.. _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``
Campiona con la ripetizione disabilitata. Quando si effettua il campionamento al di fuori dell'intervallo ``[0.0, 1.0]``, restituisce il :ref:`RDSamplerState.border_color<class_RDSamplerState_property_border_color>` specificato.
.. _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``
Campiona con ripetizione specchiata abilitata, ma solo una volta. Quando si effettua il campionamento nell'intervallo ``[-1.0, 0.0]``, restituisce una versione speculare del campionatore. Quando si effettua il campionamento al di fuori dell'intervallo ``[-1.0, 1.0]``, restituisce il colore dell'ultimo pixel sul bordo.
.. _class_RenderingDevice_constant_SAMPLER_REPEAT_MODE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`SamplerRepeatMode<enum_RenderingDevice_SamplerRepeatMode>` **SAMPLER_REPEAT_MODE_MAX** = ``5``
Rappresenta la dimensione dell'enumerazione :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``
Restituisce un colore nero trasparente a virgola mobile quando si campiona al di fuori dell'intervallo ``[0.0, 1.0]``. Efficace solo se la modalità di ripetizione del campionatore è :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``
Restituisce un colore nero trasparente intero quando si campiona al di fuori dell'intervallo ``[0.0, 1.0]``. Efficace solo se la modalità di ripetizione del campionatore è :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``
Restituisce un colore nero opaco a virgola mobile quando si campiona al di fuori dell'intervallo ``[0.0, 1.0]``. Efficace solo se la modalità di ripetizione del campionatore è :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``
Restituisce un colore nero opaco intero quando si campiona al di fuori dell'intervallo ``[0.0, 1.0]``. Efficace solo se la modalità di ripetizione del campionatore è :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``
Restituisce un colore bianco opaco a virgola mobile quando si campiona al di fuori dell'intervallo ``[0.0, 1.0]``. Efficace solo se la modalità di ripetizione del campionatore è :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``
Restituisce un colore bianco opaco intero quando si campiona al di fuori dell'intervallo ``[0.0, 1.0]``. Efficace solo se la modalità di ripetizione del campionatore è :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``
Rappresenta la dimensione dell'enumerazione :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``
L'indirizzamento degli attributi dei vertici è una funzione del vertice. Questa costante è utilizzata per specificare la frequenza con cui gli attributi dei vertici sono estratti dai buffer.
.. _class_RenderingDevice_constant_VERTEX_FREQUENCY_INSTANCE:
.. rst-class:: classref-enumeration-constant
:ref:`VertexFrequency<enum_RenderingDevice_VertexFrequency>` **VERTEX_FREQUENCY_INSTANCE** = ``1``
L'indirizzamento degli attributi dei vertici è una funzione dell'indice d'istanza. Questa costante è utilizzata per specificare la frequenza con cui gli attributi dei vertici sono estratti dai buffer.
.. 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``
Buffer di indici in formato intero senza segno a 16 bit. Questo limita l'indice massimo che può essere specificato a ``65535``.
.. _class_RenderingDevice_constant_INDEX_BUFFER_FORMAT_UINT32:
.. rst-class:: classref-enumeration-constant
:ref:`IndexBufferFormat<enum_RenderingDevice_IndexBufferFormat>` **INDEX_BUFFER_FORMAT_UINT32** = ``1``
Buffer di indici in formato intero senza segno a 32 bit. Questo limita l'indice massimo che può essere specificato a ``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``
Facoltativamente, imposta questo flag se desideri utilizzare la funzionalità :ref:`buffer_get_device_address()<class_RenderingDevice_method_buffer_get_device_address>`. È necessario prima verificare che la GPU la supporti:
.. 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``
Imposta questo flag in modo che venga creato come storage. Ciò è utile se i Compute Shader hanno bisogno di accedere (per la lettura o la scrittura) al buffer, ad esempio le animazioni degli scheletri vengono elaborate nei Compute Shader che hanno bisogno di accedere ai vertex buffer, per essere poi consumate dai vertex shader come parte della regolare pipeline di rasterizzazione.
.. 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 campionatore.
.. _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 di campionatore con una texture.
.. _class_RenderingDevice_constant_UNIFORM_TYPE_TEXTURE:
.. rst-class:: classref-enumeration-constant
:ref:`UniformType<enum_RenderingDevice_UniformType>` **UNIFORM_TYPE_TEXTURE** = ``2``
Uniforme di texture.
.. _class_RenderingDevice_constant_UNIFORM_TYPE_IMAGE:
.. rst-class:: classref-enumeration-constant
:ref:`UniformType<enum_RenderingDevice_UniformType>` **UNIFORM_TYPE_IMAGE** = ``3``
Uniforme d'immagine.
.. _class_RenderingDevice_constant_UNIFORM_TYPE_TEXTURE_BUFFER:
.. rst-class:: classref-enumeration-constant
:ref:`UniformType<enum_RenderingDevice_UniformType>` **UNIFORM_TYPE_TEXTURE_BUFFER** = ``4``
Uniforme di buffer di texture.
.. _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 di campionatore con un buffer di texture.
.. _class_RenderingDevice_constant_UNIFORM_TYPE_IMAGE_BUFFER:
.. rst-class:: classref-enumeration-constant
:ref:`UniformType<enum_RenderingDevice_UniformType>` **UNIFORM_TYPE_IMAGE_BUFFER** = ``6``
Uniforme di buffer di immagine.
.. _class_RenderingDevice_constant_UNIFORM_TYPE_UNIFORM_BUFFER:
.. rst-class:: classref-enumeration-constant
:ref:`UniformType<enum_RenderingDevice_UniformType>` **UNIFORM_TYPE_UNIFORM_BUFFER** = ``7``
Uniforme di buffer uniforme.
.. _class_RenderingDevice_constant_UNIFORM_TYPE_STORAGE_BUFFER:
.. rst-class:: classref-enumeration-constant
:ref:`UniformType<enum_RenderingDevice_UniformType>` **UNIFORM_TYPE_STORAGE_BUFFER** = ``8``
Uniforme di `storage buffer <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``
Uniforme di allegato di input.
.. _class_RenderingDevice_constant_UNIFORM_TYPE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`UniformType<enum_RenderingDevice_UniformType>` **UNIFORM_TYPE_MAX** = ``10``
Rappresenta la dimensione dell'enumerazione :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 di rendering con punti (con dimensione costante, a prescindere dalla distanza dalla telecamera).
.. _class_RenderingDevice_constant_RENDER_PRIMITIVE_LINES:
.. rst-class:: classref-enumeration-constant
:ref:`RenderPrimitive<enum_RenderingDevice_RenderPrimitive>` **RENDER_PRIMITIVE_LINES** = ``1``
Primitiva di rendering con lista di linee. Le linee vengono disegnate separate l'una dall'altra.
.. _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 di rendering con lista di linee con adiacenza. <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#drawing-line-lists-with-adjacency>`__\
\ **Nota:** L'adiacenza è utile solo con gli shader di geometria, che Godot non espone.
.. _class_RenderingDevice_constant_RENDER_PRIMITIVE_LINESTRIPS:
.. rst-class:: classref-enumeration-constant
:ref:`RenderPrimitive<enum_RenderingDevice_RenderPrimitive>` **RENDER_PRIMITIVE_LINESTRIPS** = ``3``
Primitiva di rendering con striscia di linee. Le linee disegnate sono collegate al vertice precedente.
.. _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 di rendering con strisce di linee con adiacenza. <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#drawing-line-strips-with-adjacency>`__\
\ **Nota:** L'adiacenza è utile solo con gli shader di geometria, che Godot non espone.
.. _class_RenderingDevice_constant_RENDER_PRIMITIVE_TRIANGLES:
.. rst-class:: classref-enumeration-constant
:ref:`RenderPrimitive<enum_RenderingDevice_RenderPrimitive>` **RENDER_PRIMITIVE_TRIANGLES** = ``5``
Primitiva di rendering con lista di triangoli. I triangoli vengono disegnati separati l'uno dall'altro.
.. _class_RenderingDevice_constant_RENDER_PRIMITIVE_TRIANGLES_WITH_ADJACENCY:
.. rst-class:: classref-enumeration-constant
:ref:`RenderPrimitive<enum_RenderingDevice_RenderPrimitive>` **RENDER_PRIMITIVE_TRIANGLES_WITH_ADJACENCY** = ``6``
`Primitiva di rendering con lista di triangoli con adiacenza. <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#drawing-triangle-lists-with-adjacency>`__\
\ **Nota:** L'adiacenza è utile solo con gli shader di geometra, che Godot non espone.
.. _class_RenderingDevice_constant_RENDER_PRIMITIVE_TRIANGLE_STRIPS:
.. rst-class:: classref-enumeration-constant
:ref:`RenderPrimitive<enum_RenderingDevice_RenderPrimitive>` **RENDER_PRIMITIVE_TRIANGLE_STRIPS** = ``7``
Primitiva di rendering con striscia triangolare. I triangoli disegnati sono collegati al triangolo precedente.
.. _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``
`Primitiva di rendering con strisce triangolari con adiacenza. <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#drawing-triangle-strips-with-adjacency>`__\
\ **Nota:** L'adiacenza è utile solo con gli shader di geometria, che Godot non espone.
.. _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``
Primitiva di rendering con striscia triangolare con *riavvio primitiva* abilitato. I triangoli disegnati sono collegati al triangolo precedente, ma è possibile specificare un indice di riavvio primitiva prima del disegno per creare una seconda striscia triangolare dopo l'indice specificato.
\ **Nota:** Compatibile solo con disegni indicizzati.
.. _class_RenderingDevice_constant_RENDER_PRIMITIVE_TESSELATION_PATCH:
.. rst-class:: classref-enumeration-constant
:ref:`RenderPrimitive<enum_RenderingDevice_RenderPrimitive>` **RENDER_PRIMITIVE_TESSELATION_PATCH** = ``10``
Primitiva di rendering con patch di tassellazione. Utile solo con gli shader di tassellazione, che possono essere usati per deformare queste patch.
.. _class_RenderingDevice_constant_RENDER_PRIMITIVE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`RenderPrimitive<enum_RenderingDevice_RenderPrimitive>` **RENDER_PRIMITIVE_MAX** = ``11``
Rappresenta la dimensione dell'enumerazione :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``
Non usare il culling delle facce anteriori o posteriori dei poligoni.
.. _class_RenderingDevice_constant_POLYGON_CULL_FRONT:
.. rst-class:: classref-enumeration-constant
:ref:`PolygonCullMode<enum_RenderingDevice_PolygonCullMode>` **POLYGON_CULL_FRONT** = ``1``
Utilizza il culling delle facce anteriori dei poligoni (le facce rivolte verso la telecamera vengono nascoste).
.. _class_RenderingDevice_constant_POLYGON_CULL_BACK:
.. rst-class:: classref-enumeration-constant
:ref:`PolygonCullMode<enum_RenderingDevice_PolygonCullMode>` **POLYGON_CULL_BACK** = ``2``
Utilizza il culling delle facce posteriori dei poligoni (le facce rivolte lontano dalla telecamera vengono nascoste).
.. 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``
Ordine di avvolgimento in senso orario per determinare quale faccia di un poligono è la sua faccia frontale.
.. _class_RenderingDevice_constant_POLYGON_FRONT_FACE_COUNTER_CLOCKWISE:
.. rst-class:: classref-enumeration-constant
:ref:`PolygonFrontFace<enum_RenderingDevice_PolygonFrontFace>` **POLYGON_FRONT_FACE_COUNTER_CLOCKWISE** = ``1``
Ordine di avvolgimento in senso antiorario per determinare quale faccia di un poligono è la sua faccia frontale.
.. 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``
Mantieni il valore stencil attuale.
.. _class_RenderingDevice_constant_STENCIL_OP_ZERO:
.. rst-class:: classref-enumeration-constant
:ref:`StencilOperation<enum_RenderingDevice_StencilOperation>` **STENCIL_OP_ZERO** = ``1``
Imposta il valore stencil a ``0``.
.. _class_RenderingDevice_constant_STENCIL_OP_REPLACE:
.. rst-class:: classref-enumeration-constant
:ref:`StencilOperation<enum_RenderingDevice_StencilOperation>` **STENCIL_OP_REPLACE** = ``2``
Sostituisce il valore dello stencil esistente con quello nuovo.
.. _class_RenderingDevice_constant_STENCIL_OP_INCREMENT_AND_CLAMP:
.. rst-class:: classref-enumeration-constant
:ref:`StencilOperation<enum_RenderingDevice_StencilOperation>` **STENCIL_OP_INCREMENT_AND_CLAMP** = ``3``
Incrementa il valore dello stencil esistente e lo limita al valore massimo senza segno rappresentabile, se raggiunto. I bit dello stencil sono considerati come intero senza segno.
.. _class_RenderingDevice_constant_STENCIL_OP_DECREMENT_AND_CLAMP:
.. rst-class:: classref-enumeration-constant
:ref:`StencilOperation<enum_RenderingDevice_StencilOperation>` **STENCIL_OP_DECREMENT_AND_CLAMP** = ``4``
Decrementa il valore dello stencil esistente e lo limita al valore minimo, se raggiunto. I bit dello stencil sono considerati come intero senza segno.
.. _class_RenderingDevice_constant_STENCIL_OP_INVERT:
.. rst-class:: classref-enumeration-constant
:ref:`StencilOperation<enum_RenderingDevice_StencilOperation>` **STENCIL_OP_INVERT** = ``5``
Inverte, bit a bit, il valore esistente dello stencil.
.. _class_RenderingDevice_constant_STENCIL_OP_INCREMENT_AND_WRAP:
.. rst-class:: classref-enumeration-constant
:ref:`StencilOperation<enum_RenderingDevice_StencilOperation>` **STENCIL_OP_INCREMENT_AND_WRAP** = ``6``
Incrementa il valore dello stencil e lo avvolge a ``0`` se raggiunge il massimo rappresentabile senza segno. I bit dello stencil sono considerati come un intero senza segno.
.. _class_RenderingDevice_constant_STENCIL_OP_DECREMENT_AND_WRAP:
.. rst-class:: classref-enumeration-constant
:ref:`StencilOperation<enum_RenderingDevice_StencilOperation>` **STENCIL_OP_DECREMENT_AND_WRAP** = ``7``
Decrementa il valore dello stencil e lo avvolge al massimo rappresentabile senza segno se raggiunge il minimo. I bit dello stencil sono considerati come un intero senza segno.
.. _class_RenderingDevice_constant_STENCIL_OP_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`StencilOperation<enum_RenderingDevice_StencilOperation>` **STENCIL_OP_MAX** = ``8``
Rappresenta la dimensione dell'enumerazione :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``
Confronto "mai" (opposto di :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``
Confronto "minore di".
.. _class_RenderingDevice_constant_COMPARE_OP_EQUAL:
.. rst-class:: classref-enumeration-constant
:ref:`CompareOperator<enum_RenderingDevice_CompareOperator>` **COMPARE_OP_EQUAL** = ``2``
Confronto "uguale".
.. _class_RenderingDevice_constant_COMPARE_OP_LESS_OR_EQUAL:
.. rst-class:: classref-enumeration-constant
:ref:`CompareOperator<enum_RenderingDevice_CompareOperator>` **COMPARE_OP_LESS_OR_EQUAL** = ``3``
Confronto "minore o uguale".
.. _class_RenderingDevice_constant_COMPARE_OP_GREATER:
.. rst-class:: classref-enumeration-constant
:ref:`CompareOperator<enum_RenderingDevice_CompareOperator>` **COMPARE_OP_GREATER** = ``4``
Confronto "maggiore di".
.. _class_RenderingDevice_constant_COMPARE_OP_NOT_EQUAL:
.. rst-class:: classref-enumeration-constant
:ref:`CompareOperator<enum_RenderingDevice_CompareOperator>` **COMPARE_OP_NOT_EQUAL** = ``5``
Confronto "non uguale".
.. _class_RenderingDevice_constant_COMPARE_OP_GREATER_OR_EQUAL:
.. rst-class:: classref-enumeration-constant
:ref:`CompareOperator<enum_RenderingDevice_CompareOperator>` **COMPARE_OP_GREATER_OR_EQUAL** = ``6``
Confronto "maggiore o uguale".
.. _class_RenderingDevice_constant_COMPARE_OP_ALWAYS:
.. rst-class:: classref-enumeration-constant
:ref:`CompareOperator<enum_RenderingDevice_CompareOperator>` **COMPARE_OP_ALWAYS** = ``7``
Confronto "sempre" (opposto di :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``
Rappresenta la dimensione dell'enumerazione :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``
Operazione logica di cancellazione (il risultato è sempre ``0``). Vedi anche :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``
Operazione logica AND.
.. _class_RenderingDevice_constant_LOGIC_OP_AND_REVERSE:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_AND_REVERSE** = ``2``
Operazione logica AND con l'operando *di destinazione* invertito. Vedi anche :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``
Operazione logica di copia (mantiene il valore *sorgente* così com'è). Vedi anche :ref:`LOGIC_OP_COPY_INVERTED<class_RenderingDevice_constant_LOGIC_OP_COPY_INVERTED>` e :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``
Operazione logica AND con l'operando *sorgente* invertito. Vedi anche :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``
Operazione logica no-op (mantiene il valore *di destinazione* così com'è). Vedi anche :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``
Operazione logica esclusiva o (XOR).
.. _class_RenderingDevice_constant_LOGIC_OP_OR:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_OR** = ``7``
Operazione logica OR.
.. _class_RenderingDevice_constant_LOGIC_OP_NOR:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_NOR** = ``8``
Operazione logica Not-OR (NOR).
.. _class_RenderingDevice_constant_LOGIC_OP_EQUIVALENT:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_EQUIVALENT** = ``9``
Operazione logica Not-XOR (XNOR).
.. _class_RenderingDevice_constant_LOGIC_OP_INVERT:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_INVERT** = ``10``
Inverti l'operazione logica.
.. _class_RenderingDevice_constant_LOGIC_OP_OR_REVERSE:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_OR_REVERSE** = ``11``
Operazione logica OR con l'operando *di destinazione* invertito. Vedi anche :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``
Operazione logica NOT (inverte il valore). Vedi anche :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``
Operazione logica OR con l'operando *sorgente* invertito. Vedi anche :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``
Operazione logica NOT-AND (NAND).
.. _class_RenderingDevice_constant_LOGIC_OP_SET:
.. rst-class:: classref-enumeration-constant
:ref:`LogicOperation<enum_RenderingDevice_LogicOperation>` **LOGIC_OP_SET** = ``15``
Operazione logica SET (il risultato è sempre ``1``). Vedi anche :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``
Rappresenta la dimensione dell'enumerazione :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``
Fattore di fusione costante ``0.0``.
.. _class_RenderingDevice_constant_BLEND_FACTOR_ONE:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_ONE** = ``1``
Fattore di fusione costante ``1.0``.
.. _class_RenderingDevice_constant_BLEND_FACTOR_SRC_COLOR:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_SRC_COLOR** = ``2``
Il fattore di fusione del colore è ``source color``. Il fattore di fusione dell'alfa è ``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``
Il fattore di fusione del colore è ``1.0 - source color``. Il fattore di fusione dell'alfa è ``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``
Il fattore di fusione del colore è ``destination color``. Il fattore di fusione dell'alfa è ``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``
Il fattore di fusione del colore è ``1.0 - destination color``. Il fattore di fusione dell'alfa è ``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``
Il fattore di fusione del colore e dell'alfa è ``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``
Il fattore di fusione del colore e dell'alfa è ``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``
Il fattore di fusione del colore e dell'alfa è ``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``
Il fattore di fusione del colore e dell'alfa è ``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``
Il fattore di fusione del colore è ``blend constant color``. Il fattore di fusione dell'alfa è ``blend constant alpha`` (vedi :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``
Il fattore di fusione del colore è ``1.0 - blend constant color``. Il fattore di fusione dell'alfa è ``1.0 - blend constant alpha`` (vedi :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``
Il fattore di fusione del colore e dell'alfa è ``blend constant alpha`` (vedi :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``
Il fattore di fusione del colore e dell'alfa è ``1.0 - blend constant alpha`` (vedi :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``
Il fattore di fusione del colore è ``min(source alpha, 1.0 - destination alpha)``. Il fattore di fusione dell'alfa è ``1.0``.
.. _class_RenderingDevice_constant_BLEND_FACTOR_SRC1_COLOR:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_SRC1_COLOR** = ``15``
Il fattore di fusione del colore è ``second source alpha``. Il fattore di fusione dell'alfa è ``second source alpha``. Rilevante solo per la fusione a doppia sorgente.
.. _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``
Il fattore di fusione del colore è ``1.0 - second source alpha``. Il fattore di fusione dell'alfa è ``1.0 - second source alpha``. Rilevante solo per la fusione a doppia sorgente.
.. _class_RenderingDevice_constant_BLEND_FACTOR_SRC1_ALPHA:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_SRC1_ALPHA** = ``17``
Il fattore di fusione del colore e dell'alfa è ``second source alpha``. Rilevante solo per la fusione a doppia sorgente.
.. _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``
Il fattore di fusione del colore e dell'alfa è ``1.0 - second source alpha``. Rilevante solo per la fusione a doppia sorgente.
.. _class_RenderingDevice_constant_BLEND_FACTOR_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`BlendFactor<enum_RenderingDevice_BlendFactor>` **BLEND_FACTOR_MAX** = ``19``
Rappresenta la dimensione dell'enumerazione :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``
Operazione di fusione additiva (``sorgente + destinazione``).
.. _class_RenderingDevice_constant_BLEND_OP_SUBTRACT:
.. rst-class:: classref-enumeration-constant
:ref:`BlendOperation<enum_RenderingDevice_BlendOperation>` **BLEND_OP_SUBTRACT** = ``1``
Operazione di fusione sottrattiva (``sorgente - destinazione``).
.. _class_RenderingDevice_constant_BLEND_OP_REVERSE_SUBTRACT:
.. rst-class:: classref-enumeration-constant
:ref:`BlendOperation<enum_RenderingDevice_BlendOperation>` **BLEND_OP_REVERSE_SUBTRACT** = ``2``
Operazione di fusione sottrattiva inversa (``destinazione - sorgente``).
.. _class_RenderingDevice_constant_BLEND_OP_MINIMUM:
.. rst-class:: classref-enumeration-constant
:ref:`BlendOperation<enum_RenderingDevice_BlendOperation>` **BLEND_OP_MINIMUM** = ``3``
Operazione di fusione minima (mantieni il valore più basso tra i due).
.. _class_RenderingDevice_constant_BLEND_OP_MAXIMUM:
.. rst-class:: classref-enumeration-constant
:ref:`BlendOperation<enum_RenderingDevice_BlendOperation>` **BLEND_OP_MAXIMUM** = ``4``
Operazione di fusione massimo (mantieni il valore più alto tra i due).
.. _class_RenderingDevice_constant_BLEND_OP_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`BlendOperation<enum_RenderingDevice_BlendOperation>` **BLEND_OP_MAX** = ``5``
Rappresenta la dimensione dell'enumerazione :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``
Consente di modificare dinamicamente lo spessore delle linee renderizzate.
.. _class_RenderingDevice_constant_DYNAMIC_STATE_DEPTH_BIAS:
.. rst-class:: classref-enumeration-constant
:ref:`PipelineDynamicStateFlags<enum_RenderingDevice_PipelineDynamicStateFlags>` **DYNAMIC_STATE_DEPTH_BIAS** = ``2``
Consente di modificare dinamicamente il bias di profondità.
.. _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``
**Deprecato:** Initial actions are solved automatically by RenderingDevice.
Carica il contenuto precedente del framebuffer.
.. _class_RenderingDevice_constant_INITIAL_ACTION_CLEAR:
.. rst-class:: classref-enumeration-constant
:ref:`InitialAction<enum_RenderingDevice_InitialAction>` **INITIAL_ACTION_CLEAR** = ``1``
**Deprecato:** Initial actions are solved automatically by RenderingDevice.
Cancella l'intero framebuffer o una sua regione specificata.
.. _class_RenderingDevice_constant_INITIAL_ACTION_DISCARD:
.. rst-class:: classref-enumeration-constant
:ref:`InitialAction<enum_RenderingDevice_InitialAction>` **INITIAL_ACTION_DISCARD** = ``2``
**Deprecato:** Initial actions are solved automatically by RenderingDevice.
Ignora il contenuto precedente del framebuffer. Questa è l'opzione più rapida se tutti i pixel saranno sovrascritti e non c'è bisogno di leggerne nessuno.
.. _class_RenderingDevice_constant_INITIAL_ACTION_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`InitialAction<enum_RenderingDevice_InitialAction>` **INITIAL_ACTION_MAX** = ``3``
**Deprecato:** Initial actions are solved automatically by RenderingDevice.
Rappresenta la dimensione dell'enumerazione :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``
**Deprecato:** 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``
**Deprecato:** 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``
**Deprecato:** 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``
**Deprecato:** 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``
**Deprecato:** 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``
**Deprecato:** Final actions are solved automatically by RenderingDevice.
Memorizza il risultato della lista di disegno nel framebuffer. Questo è in genere desiderato.
.. _class_RenderingDevice_constant_FINAL_ACTION_DISCARD:
.. rst-class:: classref-enumeration-constant
:ref:`FinalAction<enum_RenderingDevice_FinalAction>` **FINAL_ACTION_DISCARD** = ``1``
**Deprecato:** Final actions are solved automatically by RenderingDevice.
Scarta il contenuto del framebuffer. Questa è l'opzione più rapida se non c'è bisogno di usare i risultati della lista di disegno.
.. _class_RenderingDevice_constant_FINAL_ACTION_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`FinalAction<enum_RenderingDevice_FinalAction>` **FINAL_ACTION_MAX** = ``2``
**Deprecato:** Final actions are solved automatically by RenderingDevice.
Rappresenta la dimensione dell'enumerazione :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``
**Deprecato:** 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``
**Deprecato:** 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``
Fase di vertice di uno shader. Può essere utilizzata per manipolare i vertici da uno shader (ma non per creare nuovi vertici).
.. _class_RenderingDevice_constant_SHADER_STAGE_FRAGMENT:
.. rst-class:: classref-enumeration-constant
:ref:`ShaderStage<enum_RenderingDevice_ShaderStage>` **SHADER_STAGE_FRAGMENT** = ``1``
Fase di frammento di uno shader (chiamato "pixel shader" in Direct3D). Può essere utilizzata per manipolare i pixel da uno shader.
.. _class_RenderingDevice_constant_SHADER_STAGE_TESSELATION_CONTROL:
.. rst-class:: classref-enumeration-constant
:ref:`ShaderStage<enum_RenderingDevice_ShaderStage>` **SHADER_STAGE_TESSELATION_CONTROL** = ``2``
Fase di controllo della tassellazione di uno shader. Può essere utilizzata per creare geometria aggiuntiva da uno shader.
.. _class_RenderingDevice_constant_SHADER_STAGE_TESSELATION_EVALUATION:
.. rst-class:: classref-enumeration-constant
:ref:`ShaderStage<enum_RenderingDevice_ShaderStage>` **SHADER_STAGE_TESSELATION_EVALUATION** = ``3``
Fase di valutazione della tassellazione di uno shader. Può essere utilizzata per creare geometria aggiuntiva da uno shader.
.. _class_RenderingDevice_constant_SHADER_STAGE_COMPUTE:
.. rst-class:: classref-enumeration-constant
:ref:`ShaderStage<enum_RenderingDevice_ShaderStage>` **SHADER_STAGE_COMPUTE** = ``4``
Fase di calcolo di uno shader. Può essere utilizzata per eseguire attività di calcolo arbitrarie in uno shader, eseguendole sulla GPU anziché sulla CPU.
.. _class_RenderingDevice_constant_SHADER_STAGE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`ShaderStage<enum_RenderingDevice_ShaderStage>` **SHADER_STAGE_MAX** = ``5``
Rappresenta la dimensione dell'enumerazione :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``
Bit per la fase di vertice di uno shader (vedi anche :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``
Bit per la fase di frammento di uno shader (vedi anche :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``
Bit per la fase di controllo della tassellazione di uno shader (vedi anche :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``
Bit per la fase di valutazione della tassellazione di uno shader (vedi anche :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``
Bit per la fase di calcolo di uno shader (vedi anche :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``
Linguaggio di shading GLSL di Khronos (utilizzato nativamente da OpenGL e Vulkan). Questo è il linguaggio utilizzato per gli shader principali di Godot.
.. _class_RenderingDevice_constant_SHADER_LANGUAGE_HLSL:
.. rst-class:: classref-enumeration-constant
:ref:`ShaderLanguage<enum_RenderingDevice_ShaderLanguage>` **SHADER_LANGUAGE_HLSL** = ``1``
Linguaggio di shading di alto livello di Microsoft (utilizzato nativamente da Direct3D, ma può essere utilizzato anche 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``
Costante di specializzazione booleana.
.. _class_RenderingDevice_constant_PIPELINE_SPECIALIZATION_CONSTANT_TYPE_INT:
.. rst-class:: classref-enumeration-constant
:ref:`PipelineSpecializationConstantType<enum_RenderingDevice_PipelineSpecializationConstantType>` **PIPELINE_SPECIALIZATION_CONSTANT_TYPE_INT** = ``1``
Costante di specializzazione intera.
.. _class_RenderingDevice_constant_PIPELINE_SPECIALIZATION_CONSTANT_TYPE_FLOAT:
.. rst-class:: classref-enumeration-constant
:ref:`PipelineSpecializationConstantType<enum_RenderingDevice_PipelineSpecializationConstantType>` **PIPELINE_SPECIALIZATION_CONSTANT_TYPE_FLOAT** = ``2``
Costante di specializzazione in virgola mobile.
.. 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``
Supporto per lo spatial upscaling di MetalFX.
.. _class_RenderingDevice_constant_SUPPORTS_METALFX_TEMPORAL:
.. rst-class:: classref-enumeration-constant
:ref:`Features<enum_RenderingDevice_Features>` **SUPPORTS_METALFX_TEMPORAL** = ``4``
Supporto per il temporal upscaling di MetalFX.
.. _class_RenderingDevice_constant_SUPPORTS_BUFFER_DEVICE_ADDRESS:
.. rst-class:: classref-enumeration-constant
:ref:`Features<enum_RenderingDevice_Features>` **SUPPORTS_BUFFER_DEVICE_ADDRESS** = ``6``
Features support for buffer device address extension.
.. _class_RenderingDevice_constant_SUPPORTS_IMAGE_ATOMIC_32_BIT:
.. rst-class:: classref-enumeration-constant
:ref:`Features<enum_RenderingDevice_Features>` **SUPPORTS_IMAGE_ATOMIC_32_BIT** = ``7``
Supporto per operazioni atomiche su immagini a 32 bit.
.. 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``
Numero massimo di set di uniformi che si possono associare in un determinato momento.
.. _class_RenderingDevice_constant_LIMIT_MAX_FRAMEBUFFER_COLOR_ATTACHMENTS:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_FRAMEBUFFER_COLOR_ATTACHMENTS** = ``1``
Numero massimo di allegati del framebuffer di colore che si possono usare in un determinato momento.
.. _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``
Numero massimo di texture che si possono usare per ogni set di uniformi.
.. _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``
Numero massimo di campionatori che si possono usare per ogni set di uniformi.
.. _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``
Numero massimo di `buffer di memorizzazione <https://vkguide.dev/docs/chapter-4/storage_buffers/>`__ per ogni set di uniformi.
.. _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``
Numero massimo di immagini di memorizzazione per ogni set di uniformi.
.. _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``
Numero massimo di buffer di uniformi per ogni set di uniformi.
.. _class_RenderingDevice_constant_LIMIT_MAX_DRAW_INDEXED_INDEX:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_DRAW_INDEXED_INDEX** = ``7``
Indice massimo per un comando di disegno indicizzato.
.. _class_RenderingDevice_constant_LIMIT_MAX_FRAMEBUFFER_HEIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_FRAMEBUFFER_HEIGHT** = ``8``
Altezza massima di un framebuffer (in pixel).
.. _class_RenderingDevice_constant_LIMIT_MAX_FRAMEBUFFER_WIDTH:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_FRAMEBUFFER_WIDTH** = ``9``
Larghezza massima di un framebuffer (in pixel).
.. _class_RenderingDevice_constant_LIMIT_MAX_TEXTURE_ARRAY_LAYERS:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_TEXTURE_ARRAY_LAYERS** = ``10``
Numero massimo di strati di array di texture.
.. _class_RenderingDevice_constant_LIMIT_MAX_TEXTURE_SIZE_1D:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_TEXTURE_SIZE_1D** = ``11``
Dimensione massima supportata per le texture unidimensionali (in pixel su un singolo asse).
.. _class_RenderingDevice_constant_LIMIT_MAX_TEXTURE_SIZE_2D:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_TEXTURE_SIZE_2D** = ``12``
Dimensione massima supportata per le texture bidimensionali (in pixel su un singolo asse).
.. _class_RenderingDevice_constant_LIMIT_MAX_TEXTURE_SIZE_3D:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_TEXTURE_SIZE_3D** = ``13``
Dimensione massima supportata per le texture tridimensionali (in pixel su un singolo asse).
.. _class_RenderingDevice_constant_LIMIT_MAX_TEXTURE_SIZE_CUBE:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_TEXTURE_SIZE_CUBE** = ``14``
Dimensione massima supportata per le texture cubemap (in pixel su un singolo asse di una singola faccia).
.. _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``
Numero massimo di texture per ogni fase di uno 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``
Numero massimo di campionatori per ogni fase di uno 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``
Numero massimo di `buffer di memorizzazione <https://vkguide.dev/docs/chapter-4/storage_buffers/>`__ per ogni fase di uno 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``
Numero massimo di immagini di memorizzazione per ogni fase di uno 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``
Numero massimo di buffer di uniformi per ogni set di uniformi.
.. _class_RenderingDevice_constant_LIMIT_MAX_PUSH_CONSTANT_SIZE:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_PUSH_CONSTANT_SIZE** = ``20``
Dimensione massima di una costante push. Molti dispositivi sono limitati a 128 byte, quindi prova a evitare di superare i 128 byte nelle costanti push per garantire la compatibilità anche se la tua GPU segnala un valore più 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``
Dimensione massima di un buffer di uniformi.
.. _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``
Maximum vertex input attribute offset.
.. _class_RenderingDevice_constant_LIMIT_MAX_VERTEX_INPUT_ATTRIBUTES:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_VERTEX_INPUT_ATTRIBUTES** = ``23``
Numero massimo di attributi di ingresso di vertice.
.. _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``
Maximum vertex input binding stride.
.. _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``
Minimum uniform buffer offset alignment.
.. _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``
Dimensione massima della memoria condivisa per gli shader di calcolo.
.. _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``
Numero massimo di gruppi di lavoro per gli shader di calcolo sull'asse 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``
Numero massimo di gruppi di lavoro per gli shader di calcolo sull'asse 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``
Numero massimo di gruppi di lavoro per gli shader di calcolo sull'asse 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``
Numero massimo di invocazioni dei gruppi di lavoro per gli shader di calcolo.
.. _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``
Dimensione massima di un gruppo di lavoro per gli shader di calcolo sull'asse X.
.. _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``
Dimensione massima di un gruppo di lavoro per gli shader di calcolo sull'asse Y.
.. _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``
Dimensione massima di un gruppo di lavoro per gli shader di calcolo sull'asse Z.
.. _class_RenderingDevice_constant_LIMIT_MAX_VIEWPORT_DIMENSIONS_X:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_VIEWPORT_DIMENSIONS_X** = ``35``
Larghezza massima di una viewport (in pixel).
.. _class_RenderingDevice_constant_LIMIT_MAX_VIEWPORT_DIMENSIONS_Y:
.. rst-class:: classref-enumeration-constant
:ref:`Limit<enum_RenderingDevice_Limit>` **LIMIT_MAX_VIEWPORT_DIMENSIONS_Y** = ``36``
Altezza massima della viewport (in pixel).
.. _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``
Restituisce il valore più piccolo per :ref:`ProjectSettings.rendering/scaling_3d/scale<class_ProjectSettings_property_rendering/scaling_3d/scale>` quando si utilizza l'upscaler temporale MetalFX.
\ **Nota:** Il valore restituito viene moltiplicato per un fattore di ``1000000`` per preservare 6 cifre di precisione. Deve essere diviso per ``1000000.0`` per convertire il valore in un numero in virgola mobile.
.. _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``
Restituisce il valore più grande per :ref:`ProjectSettings.rendering/scaling_3d/scale<class_ProjectSettings_property_rendering/scaling_3d/scale>` quando si utilizza l'upscaler temporale MetalFX.
\ **Nota:** Il valore restituito viene moltiplicato per un fattore di ``1000000`` per preservare 6 cifre di precisione. Deve essere diviso per ``1000000.0`` per convertire il valore in un numero in virgola mobile.
.. 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``
Memoria occupata da texture.
.. _class_RenderingDevice_constant_MEMORY_BUFFERS:
.. rst-class:: classref-enumeration-constant
:ref:`MemoryType<enum_RenderingDevice_MemoryType>` **MEMORY_BUFFERS** = ``1``
Memoria occupata dai buffer.
.. _class_RenderingDevice_constant_MEMORY_TOTAL:
.. rst-class:: classref-enumeration-constant
:ref:`MemoryType<enum_RenderingDevice_MemoryType>` **MEMORY_TOTAL** = ``2``
Memoria totale occupata. Questa è maggiore della somma di :ref:`MEMORY_TEXTURES<class_RenderingDevice_constant_MEMORY_TEXTURES>` e :ref:`MEMORY_BUFFERS<class_RenderingDevice_constant_MEMORY_BUFFERS>`, poiché include anche l'utilizzo vario di memoria.
.. 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``
Non verrà aggiunto alcun indicatore di breadcrumb.
.. _class_RenderingDevice_constant_REFLECTION_PROBES:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **REFLECTION_PROBES** = ``65536``
Durante un arresto anomalo della GPU in modalità dev o debug, il messaggio di errore di Godot includerà ``"REFLECTION_PROBES"`` per ulteriore contesto sul momento in cui si è verificato l'arresto.
.. _class_RenderingDevice_constant_SKY_PASS:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **SKY_PASS** = ``131072``
Durante un arresto anomalo della GPU in modalità dev o debug, il messaggio di errore di Godot includerà ``"SKY_PASS"`` per ulteriore contesto sul momento in cui si è verificato l'arresto.
.. _class_RenderingDevice_constant_LIGHTMAPPER_PASS:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **LIGHTMAPPER_PASS** = ``196608``
Durante un arresto anomalo della GPU in modalità dev o debug, il messaggio di errore di Godot includerà ``"LIGHTMAPPER_PASS"`` per ulteriore contesto sul momento in cui si è verificato l'arresto.
.. _class_RenderingDevice_constant_SHADOW_PASS_DIRECTIONAL:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **SHADOW_PASS_DIRECTIONAL** = ``262144``
Durante un arresto anomalo della GPU in modalità dev o debug, il messaggio di errore di Godot includerà ``"SHADOW_PASS_DIRECTIONAL"`` per ulteriore contesto sul momento in cui si è verificato l'arresto.
.. _class_RenderingDevice_constant_SHADOW_PASS_CUBE:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **SHADOW_PASS_CUBE** = ``327680``
Durante un arresto anomalo della GPU in modalità dev o debug, il messaggio di errore di Godot includerà ``"SHADOW_PASS_CUBE"`` per ulteriore contesto sul momento in cui si è verificato l'arresto.
.. _class_RenderingDevice_constant_OPAQUE_PASS:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **OPAQUE_PASS** = ``393216``
Durante un arresto anomalo della GPU in modalità dev o debug, il messaggio di errore di Godot includerà ``"OPAQUE_PASS"`` per ulteriore contesto sul momento in cui si è verificato l'arresto.
.. _class_RenderingDevice_constant_ALPHA_PASS:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **ALPHA_PASS** = ``458752``
Durante un arresto anomalo della GPU in modalità dev o debug, il messaggio di errore di Godot includerà ``"ALPHA_PASS"`` per ulteriore contesto sul momento in cui si è verificato l'arresto.
.. _class_RenderingDevice_constant_TRANSPARENT_PASS:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **TRANSPARENT_PASS** = ``524288``
Durante un arresto anomalo della GPU in modalità dev o debug, il messaggio di errore di Godot includerà ``"TRANSPARENT_PASS"`` per ulteriore contesto sul momento in cui si è verificato l'arresto.
.. _class_RenderingDevice_constant_POST_PROCESSING_PASS:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **POST_PROCESSING_PASS** = ``589824``
Durante un arresto anomalo della GPU in modalità dev o debug, il messaggio di errore di Godot includerà ``"POST_PROCESSING_PASS"`` per ulteriore contesto sul momento in cui si è verificato l'arresto.
.. _class_RenderingDevice_constant_BLIT_PASS:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **BLIT_PASS** = ``655360``
Durante un arresto anomalo della GPU in modalità dev o debug, il messaggio di errore di Godot includerà ``"BLIT_PASS"`` per ulteriore contesto sul momento in cui si è verificato l'arresto.
.. _class_RenderingDevice_constant_UI_PASS:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **UI_PASS** = ``720896``
Durante un arresto anomalo della GPU in modalità dev o debug, il messaggio di errore di Godot includerà ``"UI_PASS"`` per ulteriore contesto sul momento in cui si è verificato l'arresto.
.. _class_RenderingDevice_constant_DEBUG_PASS:
.. rst-class:: classref-enumeration-constant
:ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` **DEBUG_PASS** = ``786432``
Durante un arresto anomalo della GPU in modalità dev o debug, il messaggio di errore di Godot includerà ``"DEBUG_PASS"`` per ulteriore contesto sul momento in cui si è verificato l'arresto.
.. 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``
Non cancellare o ignorare alcun allegato.
.. _class_RenderingDevice_constant_DRAW_CLEAR_COLOR_0:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_COLOR_0** = ``1``
Cancella il primo allegato di colore.
.. _class_RenderingDevice_constant_DRAW_CLEAR_COLOR_1:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_COLOR_1** = ``2``
Cancella il secondo allegato di colore.
.. _class_RenderingDevice_constant_DRAW_CLEAR_COLOR_2:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_COLOR_2** = ``4``
Cancella il terzo allegato di colore.
.. _class_RenderingDevice_constant_DRAW_CLEAR_COLOR_3:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_COLOR_3** = ``8``
Cancella il quarto allegato di colore.
.. _class_RenderingDevice_constant_DRAW_CLEAR_COLOR_4:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_COLOR_4** = ``16``
Cancella il quinto allegato di colore.
.. _class_RenderingDevice_constant_DRAW_CLEAR_COLOR_5:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_COLOR_5** = ``32``
Cancella il sesto allegato di colore.
.. _class_RenderingDevice_constant_DRAW_CLEAR_COLOR_6:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_COLOR_6** = ``64``
Cancella il settimo allegato di colore.
.. _class_RenderingDevice_constant_DRAW_CLEAR_COLOR_7:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_COLOR_7** = ``128``
Cancella l'ottavo allegato di colore.
.. _class_RenderingDevice_constant_DRAW_CLEAR_COLOR_MASK:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_COLOR_MASK** = ``255``
Maschera per cancellare tutti gli allegati di colore.
.. _class_RenderingDevice_constant_DRAW_CLEAR_COLOR_ALL:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_COLOR_ALL** = ``255``
Cancella tutti gli allegati di colore.
.. _class_RenderingDevice_constant_DRAW_IGNORE_COLOR_0:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_COLOR_0** = ``256``
Ignora il contenuto precedente del primo allegato di colore.
.. _class_RenderingDevice_constant_DRAW_IGNORE_COLOR_1:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_COLOR_1** = ``512``
Ignora il contenuto precedente del secondo allegato di colore.
.. _class_RenderingDevice_constant_DRAW_IGNORE_COLOR_2:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_COLOR_2** = ``1024``
Ignora il contenuto precedente del terzo allegato di colore.
.. _class_RenderingDevice_constant_DRAW_IGNORE_COLOR_3:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_COLOR_3** = ``2048``
Ignora il contenuto precedente del quarto allegato di colore.
.. _class_RenderingDevice_constant_DRAW_IGNORE_COLOR_4:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_COLOR_4** = ``4096``
Ignora il contenuto precedente del quinto allegato di colore.
.. _class_RenderingDevice_constant_DRAW_IGNORE_COLOR_5:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_COLOR_5** = ``8192``
Ignora il contenuto precedente del sesto allegato di colore.
.. _class_RenderingDevice_constant_DRAW_IGNORE_COLOR_6:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_COLOR_6** = ``16384``
Ignora il contenuto precedente del settimo allegato di colore.
.. _class_RenderingDevice_constant_DRAW_IGNORE_COLOR_7:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_COLOR_7** = ``32768``
Ignora il contenuto precedente dell'ottavo allegato di colore.
.. _class_RenderingDevice_constant_DRAW_IGNORE_COLOR_MASK:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_COLOR_MASK** = ``65280``
Maschera per ignorare il contenuto precedente di tutti gli allegati di colore.
.. _class_RenderingDevice_constant_DRAW_IGNORE_COLOR_ALL:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_COLOR_ALL** = ``65280``
Ignora il contenuto precedente di tutti gli allegati di colore.
.. _class_RenderingDevice_constant_DRAW_CLEAR_DEPTH:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_DEPTH** = ``65536``
Cancella l'allegato di profondità.
.. _class_RenderingDevice_constant_DRAW_IGNORE_DEPTH:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_DEPTH** = ``131072``
Ignora il contenuto precedente dell'allegato di profondità.
.. _class_RenderingDevice_constant_DRAW_CLEAR_STENCIL:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_STENCIL** = ``262144``
Cancella l'allegato di stencil.
.. _class_RenderingDevice_constant_DRAW_IGNORE_STENCIL:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_STENCIL** = ``524288``
Ignora il contenuto precedente dell'allegato di stencil.
.. _class_RenderingDevice_constant_DRAW_CLEAR_ALL:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_CLEAR_ALL** = ``327935``
Cancella tutti gli allegati.
.. _class_RenderingDevice_constant_DRAW_IGNORE_ALL:
.. rst-class:: classref-enumeration-constant
:ref:`DrawFlags<enum_RenderingDevice_DrawFlags>` **DRAW_IGNORE_ALL** = ``720640``
Ignora il contenuto precedente di tutti gli allegati.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Costanti
----------------
.. _class_RenderingDevice_constant_INVALID_ID:
.. rst-class:: classref-constant
**INVALID_ID** = ``-1`` :ref:`🔗<class_RenderingDevice_constant_INVALID_ID>`
Restituito dalle funzioni che restituiscono un ID se un valore non è valido.
.. _class_RenderingDevice_constant_INVALID_FORMAT_ID:
.. rst-class:: classref-constant
**INVALID_FORMAT_ID** = ``-1`` :ref:`🔗<class_RenderingDevice_constant_INVALID_FORMAT_ID>`
Restituito dalle funzioni che restituiscono un ID formato se un valore non è valido.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni dei metodi
--------------------------------------------
.. _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>`
**Deprecato:** Barriers are automatically inserted by RenderingDevice.
Questo metodo non fa nulla.
.. 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>`
Cancella i contenuti di ``buffer``, cancellando ``size_bytes``, a partire da ``offset``.
Stampa un errore se:
- la dimensione non è un multiplo di quattro
- la regione specificata da ``offset`` + ``size_bytes`` supera il buffer
- un elenco di disegno è attualmente attivo (creato da :ref:`draw_list_begin()<class_RenderingDevice_method_draw_list_begin>`)
- un elenco di calcolo è attualmente attivo (creato da :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`` byte dal buffer ``src_buffer`` a partire da ``src_offset`` nel buffer ``dst_buffer`` a ``dst_offset``.
Stampa un errore se:
- ``size`` supera la dimensione di ``src_buffer`` o ``dst_buffer`` ai rispettivi offset
- un elenco di disegno è attualmente attivo (creato da :ref:`draw_list_begin()<class_RenderingDevice_method_draw_list_begin>`)
- un elenco di calcolo è attualmente attivo (creato da :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>`
Restituisce una copia dei dati del ``buffer`` specificato, facoltativamente è possibile impostare ``offset_bytes`` e ``size_bytes`` per copiare solo una parte del buffer.
\ **Nota:** Questo metodo impedirà alla GPU di funzionare finché i dati non vengono recuperati. Fare riferimento a :ref:`buffer_get_data_async()<class_RenderingDevice_method_buffer_get_data_async>` per un'alternativa che restituisce i dati in modo più performante.
.. 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>`
Versione asincrona di :ref:`buffer_get_data()<class_RenderingDevice_method_buffer_get_data>`. RenderingDevice chiamerà ``callback`` in una certa quantità di frame con i dati che il buffer aveva al momento della richiesta.
\ **Nota:** Al momento, il ritardo corrisponde alla quantità di frame specificata da :ref:`ProjectSettings.rendering/rendering_device/vsync/frame_queue_size<class_ProjectSettings_property_rendering/rendering_device/vsync/frame_queue_size>`.
\ **Nota:** Scaricare buffer di grandi dimensioni può avere un costo proibitivo per il tempo reale, anche quando si utilizza il metodo asincrono, a causa di limitazioni della larghezza di banda nell'hardware. Quando si gestiscono grandi risorse, è possibile regolare impostazioni come :ref:`ProjectSettings.rendering/rendering_device/staging_buffer/block_size_kb<class_ProjectSettings_property_rendering/rendering_device/staging_buffer/block_size_kb>` per migliorare la velocità di trasferimento a costo di memoria aggiuntiva.
::
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>`
Restituisce l'indirizzo del ``buffer`` specificato che può essere passato agli shader in qualsiasi modo per accedere ai dati sottostanti. Il buffer deve essere stato creato con questa funzionalità abilitata.
\ **Nota:** È necessario verificare che la GPU supporti questa funzionalità chiamando :ref:`has_feature()<class_RenderingDevice_method_has_feature>` con :ref:`SUPPORTS_BUFFER_DEVICE_ADDRESS<class_RenderingDevice_constant_SUPPORTS_BUFFER_DEVICE_ADDRESS>` come parametro.
.. 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>`
Aggiorna una regione di ``size_bytes`` byte, a partire da ``offset``, nel buffer, con i dati ``data``.
Stampa un errore se:
- la regione specificata da ``offset`` + ``size_bytes`` supera il buffer
- un elenco di disegno è attualmente attivo (creato da :ref:`draw_list_begin()<class_RenderingDevice_method_draw_list_begin>`)
- un elenco di calcolo è attualmente attivo (creato da :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 marcatore di timestamp con il nome ``name``. È utilizzato per la creazione di report sulle prestazioni con i metodi :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>` e :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>`
Alza una barriera di elaborazione Vulkan nella ``compute_list`` specificata.
.. 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>`
Avvia un elenco di comandi di calcolo creati con i metodi ``compute_*``. Il valore restituito deve essere passato ad altre funzioni ``compute_list_*``.
Non è possibile creare più elenchi di calcolo allo stesso tempo; è necessario prima terminare l'elenco di calcolo precedente usando :ref:`compute_list_end()<class_RenderingDevice_method_compute_list_end>`.
Una semplice operazione di calcolo potrebbe apparire così (il codice non è un esempio 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)
# No barrier, let them run all together.
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>`
Indica alla GPU quale pipeline di calcolo utilizzare durante l'elaborazione dell'elenco di calcolo. Se lo shader è cambiato dall'ultima volta che è stata chiamata questa funzione, Godot scollegherà tutti i set di descrittori e li ricollegherà all'interno di :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>`
Associa il set di uniformi ``uniform_set`` all'elenco di calcolo ``compute_list``. Godot assicura che tutte le texture nel set uniforme abbiano le maschere di accesso Vulkan attuali. Se Godot dovesse cambiare le maschere di accesso delle texture, ciò innalzerebbe una barriera Vulkan di memoria delle immagini.
.. 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>`
Invia l'elenco di calcolo per l'elaborazione sulla GPU. Questo è l'equivalente di calcolo di :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>`
Invia l'elenco di calcolo per l'elaborazione sulla GPU con i conteggi dei gruppi specificati memorizzati nel ``buffer`` a ``offset``. Il buffer deve essere stato creato con il 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>`
Finisce un elenco di comandi di calcolo creati con i metodi ``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>`
Sets the push constant data to ``buffer`` for the specified ``compute_list``. The shader determines how this binary data is used. The buffer's size in bytes must also be specified in ``size_bytes`` (this can be obtained by calling the :ref:`PackedByteArray.size()<class_PackedByteArray_method_size>` method on the passed ``buffer``).
.. 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 una nuova pipeline di calcolo. È possibile accedervi con il RID restituito.
Una volta finito con il RID, si consiglia di liberarlo tramite il metodo :ref:`free_rid()<class_RenderingDevice_method_free_rid>` del RenderingServer.
.. 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>`
Restituisce ``true`` se la pipeline di calcolo specificata dal :ref:`RID<class_RID>` ``compute_pipeline`` è valida, altrimenti ``false``.
.. 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 nuovo **RenderingDevice** locale. Ciò è molto utile per eseguire operazioni di elaborazione sulla GPU indipendentemente dal resto del motore.
.. 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 un'area per un'etichetta di debug del buffer dei comandi che è possibile visualizzare in strumenti di terze parti come `RenderDoc <https://renderdoc.org/>`__. Tutte le aree devono essere terminate con una chiamata a :ref:`draw_command_end_label()<class_RenderingDevice_method_draw_command_end_label>`. Quando visualizzate dalla serie lineare di invii a una singola coda, le chiamate a :ref:`draw_command_begin_label()<class_RenderingDevice_method_draw_command_begin_label>` e a :ref:`draw_command_end_label()<class_RenderingDevice_method_draw_command_end_label>` devono coincidere ed essere bilanciate.
L'estensione Vulkan ``VK_EXT_DEBUG_UTILS_EXTENSION_NAME`` deve essere disponibile e abilitata affinché l'area per l'etichetta di debug del buffer dei comandi funzioni. Vedi anche :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>`
Termina la regione per un'etichetta di debug del buffer dei comandi avviata da una chiamata 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>`
**Deprecato:** Inserting labels no longer applies due to command reordering.
Questo metodo non fa nulla.
.. 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>`
Avvia un elenco di comandi di disegno raster creati con i metodi ``draw_*``. Bisogna passare il valore restituito ad altre funzioni ``draw_list_*``.
Non è possibile creare più elenchi di disegno allo stesso tempo; è necessario prima terminare l'elenco di disegno precedente tramite il metodo :ref:`draw_list_end()<class_RenderingDevice_method_draw_list_end>`.
Una semplice operazione di disegno potrebbe essere simile a questa (il codice non è un esempio completo):
::
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)
# Disegna opaco.
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)
# Disegna filo.
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()
Il parametro ``draw_flags`` indica se gli allegati di texture del framebuffer devono essere cancellati o ignorati. È possibile utilizzare solo uno dei due flag per ogni singolo allegato. Ignorare un allegato significa che qualsiasi contenuto presente prima della draw list verrà completamente scartato, riducendo la larghezza di banda di memoria usata dal passaggio di rendering, ma producendo risultati inefficaci se i pixel non vengono sostituiti. Il comportamento predefinito consente al motore di determinare l'operazione corretta da utilizzare se la texture è scartabile, il che può comportare un aumento delle prestazioni. Vedi :ref:`RDTextureFormat<class_RDTextureFormat>` o :ref:`texture_set_discardable()<class_RenderingDevice_method_texture_set_discardable>`.
Il parametro ``breadcrumb`` può essere un intero arbitrario a 32 bit, utile per diagnosticare i crash sulla GPU. Se Godot è compilato in modalità dev o debug, quando la GPU si blocca, Godot scaricherà tutti gli shader in esecuzione al momento del crash e il breadcrumb è utile per diagnosticare a quali passaggi appartenevano quegli shader.
Non influisce sul comportamento del rendering e può essere impostato su 0. Si consiglia di utilizzare le enumerazioni :ref:`BreadcrumbMarker<enum_RenderingDevice_BreadcrumbMarker>` per coerenza, ma non è obbligatorio. È anche possibile usare operazioni bit a bit per aggiungere ulteriori dati, ad esempio:
::
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>`
Variazione di alto livello di :ref:`draw_list_begin()<class_RenderingDevice_method_draw_list_begin>`, con i parametri regolati automaticamente per disegnare sulla finestra specificata dall'ID ``screen``.
\ **Nota:** Non può essere utilizzato con i RenderingDevice locali, poiché questi non hanno uno schermo. Se richiamato su un RenderingDevice locale, :ref:`draw_list_begin_for_screen()<class_RenderingDevice_method_draw_list_begin_for_screen>` restituisce :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>`
**Deprecato:** Split draw lists are used automatically by RenderingDevice.
Questo metodo non fa nulla e restituisce sempre un :ref:`PackedInt64Array<class_PackedInt64Array>` vuoto.
.. 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>`
Associa l'array di indici ``index_array`` alla lista di disegno ``draw_list``.
.. 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>`
Associa la rendering pipeline (``render_pipeline``) alla lista di disegno (``draw_list``) specificata.
.. 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>`
Associa ``uniform_set`` alla lista di disegno ``draw_list``. Deve essere specificato anche un ``set_index``, ovvero un identificatore che inizia da ``0`` e che deve corrispondere a quello previsto dalla lista di disegno.
.. 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>`
Associa l'array di vertici (``vertex_array``) alla lista di disegno (``draw_list``) specificata.
.. 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>`
Rimuove e disabilita il rettangolo scissor per il ``draw_list`` specificato. Vedi anche :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>`
Invia l'elenco di disegno ``draw_list`` per il rendering sulla GPU. Questo è l'equivalente raster di :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>`
Invia l'elenco di disegno ``draw_list`` per il rendering sulla GPU con i parametri specificati memorizzati nel ``buffer`` a ``offset``. I parametri sono numeri interi: numero di vertici, numero di istanze, primo vertice, prima istanza. E quando si utilizzano gli indici: numero di indici, numero di istanze, primo indice, offset dei vertici, prima istanza. Il buffer deve essere stato creato con il 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 rettangolo scissor e lo abilita per il ``draw_list`` specificato. I rettangoli scissor sono utilizzati per ritagliare scartando i frammenti che non rientrano in una specifica porzione rettangolare dello schermo. Vedi anche :ref:`draw_list_disable_scissor()<class_RenderingDevice_method_draw_list_disable_scissor>`.
\ **Nota:** Il ``rect`` specificato viene automaticamente intersecato con le dimensioni dello schermo, il che significa che non può superare le dimensioni dello schermo.
.. 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>`
Finisce un elenco di comandi di disegno raster creati con i metodi ``draw_*``.
.. 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>`
Imposta le costanti di fusione per l'elenco di disegno ``draw_list`` specificato sul colore ``color``. Le costanti di fusione sono utilizzate solo se la pipeline grafica viene creata con il flag :ref:`DYNAMIC_STATE_BLEND_CONSTANTS<class_RenderingDevice_constant_DYNAMIC_STATE_BLEND_CONSTANTS>` impostato.
.. 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>`
Imposta i dati costanti push su ``buffer`` per l'elenco di disegno ``draw_list``. Lo shader determina come si utilizzano questi dati binari. Anche la dimensione del buffer in byte deve essere specificata in ``size_bytes`` (è possibile ricavarla chiamando il metodo :ref:`PackedByteArray.size()<class_PackedByteArray_method_size>` sul ``buffer`` passato).
.. 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>`
Passa al passaggio successivo di disegno.
.. 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>`
**Deprecato:** Split draw lists are used automatically by RenderingDevice.
Questo metodo non fa nulla e restituisce sempre un :ref:`PackedInt64Array<class_PackedInt64Array>` vuoto.
.. 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>`
Crea un nuovo framebuffer. È possibile accedervi con il RID restituito.
Una volta finito con il RID, si consiglia di liberarlo tramite il metodo :ref:`free_rid()<class_RenderingDevice_method_free_rid>` del RenderingServer.
.. 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>`
Crea un nuovo framebuffer vuoto. È possibile accedervi con il RID restituito.
Una volta finito con il RID, si consiglia di liberarlo tramite il metodo :ref:`free_rid()<class_RenderingDevice_method_free_rid>` del RenderingServer.
.. 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>`
Crea un nuovo framebuffer multipassaggio. È possibile accedervi con il RID restituito.
Una volta finito con il RID, si consiglia di liberarlo tramite il metodo :ref:`free_rid()<class_RenderingDevice_method_free_rid>` del RenderingServer.
.. 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>`
Crea un nuovo formato framebuffer con i parametri ``attachments`` e ``view_count`` specificati. Restituisce l'ID univoco del formato framebuffer del nuovo framebuffer.
Se ``view_count`` è maggiore o uguale a ``2``, abilita multiview che è utilizzato per il rendering VR. Ciò richiede il supporto per l'estensione multiview Vulkan.
.. 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>`
Crea un nuovo formato framebuffer vuoto con il numero specificato di campioni (``samples``) e restituisce il suo 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>`
Crea un nuovo formato framebuffer multipass con i parametri ``attachments``, ``passes`` e ``view_count`` specificati e restituisce il suo ID. Se ``view_count`` è maggiore o uguale a ``2``, abilita multiview che è utilizzato per il rendering VR. Ciò richiede il supporto per l'estensione multiview Vulkan.
.. 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>`
Restituisce il numero di campioni di texture utilizzati per l'ID del formato framebuffer ``format`` (restituito da :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>`
Restituisce l'ID formato del framebuffer specificato dal RID ``framebuffer``. Questo ID è garantito come univoco per gli stessi formati e non deve essere liberato.
.. 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>`
Restituisce ``true`` se il framebuffer specificato dal :ref:`RID<class_RID>` ``framebuffer`` è valido, altrimenti ``false``.
.. 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>`
Prova a liberare un oggetto nel RenderingDevice. Per evitare perdite di memoria, questo dovrebbe essere chiamato dopo aver utilizzato un oggetto, poiché la gestione della memoria non avviene automaticamente quando si utilizza direttamente il RenderingDevice.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_full_barrier:
.. rst-class:: classref-method
|void| **full_barrier**\ (\ ) :ref:`🔗<class_RenderingDevice_method_full_barrier>`
**Deprecato:** Barriers are automatically inserted by RenderingDevice.
Questo metodo non fa nulla.
.. 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>`
Restituisce il timestamp in tempo della CPU per la fase di rendering specificata da ``index`` (in microsecondi dall'avvio del motore). Vedi anche :ref:`get_captured_timestamp_gpu_time()<class_RenderingDevice_method_get_captured_timestamp_gpu_time>` e :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>`
Restituisce il timestamp in tempo della GPU per la fase di rendering specificata da ``index`` (in microsecondi dall'avvio del motore). Vedi anche :ref:`get_captured_timestamp_cpu_time()<class_RenderingDevice_method_get_captured_timestamp_cpu_time>` e :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>`
Restituisce il nome del timestamp per la fase di rendering specificata dall'indice ``index``. Vedi anche :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>`
Restituisce il numero totale di timestamp (passi di rendering) disponibili per la profilazione.
.. 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>`
Restituisce l'indice dell'ultima frame renderizzata che ha timestamp di rendering disponibili per l'interrogazione.
.. 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>`
Restituisce quante allocazioni la GPU ha effettuato per le strutture interne del driver.
È utilizzato solo da Vulkan nelle build di debug e può restituire 0 quando questa informazione non è tracciata o è sconosciuta.
.. 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>`
Uguale a :ref:`get_device_allocation_count()<class_RenderingDevice_method_get_device_allocation_count>` ma filtrato per un determinato tipo di oggetto.
L'argomento tipo deve essere compreso nell'intervallo ``[0; get_tracked_object_type_count - 1]``. Se :ref:`get_tracked_object_type_count()<class_RenderingDevice_method_get_tracked_object_type_count>` è 0, l'argomento tipo viene ignorato e restituisce sempre 0.
Questo è utilizzato solo da Vulkan nelle build di debug e può restituire 0 quando queste informazioni non sono tracciate o sono sconosciute.
.. 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>`
Uguale a :ref:`get_device_total_memory()<class_RenderingDevice_method_get_device_total_memory>` ma filtrato per un determinato tipo di oggetto.
L'argomento tipo deve essere compreso nell'intervallo ``[0; get_tracked_object_type_count - 1]``. Se :ref:`get_tracked_object_type_count()<class_RenderingDevice_method_get_tracked_object_type_count>` è 0, l'argomento tipo viene ignorato e restituisce sempre 0.
Questo è utilizzato solo da Vulkan nelle build di debug e può restituire 0 quando queste informazioni non sono tracciate o sono sconosciute.
.. 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>`
Restituisce il nome della scheda video (ad esempio "GeForce GTX 1080/PCIe/SSE2"). Equivalente a :ref:`RenderingServer.get_video_adapter_name()<class_RenderingServer_method_get_video_adapter_name>`. Vedi anche :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>`
Restituisce l'identificatore univoco universale per la cache della pipeline. È utilizzato per memorizzare nella cache i file di shader sul disco, il che evita di ricompilare gli shader nelle esecuzioni successive del motore. Questo UUID varia a seconda del modello della scheda grafica, ma anche della versione del driver. Pertanto, l'aggiornamento dei driver grafici invaliderà la cache degli shader.
.. 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>`
Restituisce quanti byte la GPU sta utilizzando.
È utilizzato solo da Vulkan nelle build di debug e può restituire 0 quando questa informazione non viene tracciata o è sconosciuta.
.. 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>`
Restituisce il fornitore della scheda video (ad esempio "NVIDIA Corporation"). Equivalente a :ref:`RenderingServer.get_video_adapter_vendor()<class_RenderingServer_method_get_video_adapter_vendor>`. Vedi anche :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>`
Restituisce quante allocazioni il driver GPU ha effettuato per le strutture interne del driver.
È utilizzato solo da Vulkan nelle build di debug e può restituire 0 quando questa informazione non è tracciata o è sconosciuta.
.. 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>`
Uguale a :ref:`get_driver_allocation_count()<class_RenderingDevice_method_get_driver_allocation_count>` ma filtrato per un dato tipo di oggetto.
L'argomento tipo deve essere compreso nell'intervallo ``[0; get_tracked_object_type_count - 1]``. Se :ref:`get_tracked_object_type_count()<class_RenderingDevice_method_get_tracked_object_type_count>` è 0, l'argomento tipo viene ignorato e restituisce sempre 0.
Questo è utilizzato solo da Vulkan nelle build di debug e può restituire 0 quando queste informazioni non sono tracciate o sono sconosciute.
.. 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>`
Restituisce una stringa di report nel formato CSV attraverso i seguenti metodi:
- :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>`\
Questo è utilizzato solo da Vulkan nelle build di debug. Godot deve essere avviato anche con l':doc:`argomento della riga di comando <../tutorials/editor/command_line_tutorial>` ``--extra-gpu-memory-tracking``.
.. 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>`
Uguale a :ref:`get_driver_total_memory()<class_RenderingDevice_method_get_driver_total_memory>` ma filtrato per un dato tipo di oggetto.
L'argomento tipo deve essere compreso nell'intervallo ``[0; get_tracked_object_type_count - 1]``. Se :ref:`get_tracked_object_type_count()<class_RenderingDevice_method_get_tracked_object_type_count>` è 0, l'argomento tipo viene ignorato e restituisce sempre 0.
Questo è utilizzato solo da Vulkan nelle build di debug e può restituire 0 quando queste informazioni non sono tracciate o sono sconosciute.
.. 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>`
Restituisce l'identificatore univoco della ``resource`` del driver per il ``rid`` specificato. Alcuni tipi di risorse driver ignorano il ``rid`` specificato. ``index`` è sempre ignorato ma deve essere specificato comunque.
.. 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>`
Restituisce quanti byte il driver GPU sta utilizzando per le strutture interne del driver.
È utilizzato solo da Vulkan nelle build di debug e può restituire 0 quando questa informazione non è tracciata o è sconosciuta.
.. 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>`
Restituisce il conteggio dei frame mantenuto dall'API grafica. Valori più alti risultano in un ritardo degli input più elevato, ma un rendimento più regolare. Per il **RenderingDevice** principale, i frame sono ciclati (solitamente 3 con V-Sync a triplo buffer abilitato). Tuttavia, i **RenderingDevice** locali hanno solo 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>`
Restituisce l'utilizzo della memoria in byte corrispondente al tipo ``type``. Quando si utilizza Vulkan, queste statistiche sono calcolate dal `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>`
Restituisce una stringa con un report delle prestazioni del frame precedente. Viene aggiornato ogni 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>`
Restituisce il nome del tipo di oggetto per l'indice di tipo ``type_index``. Questo valore deve essere compreso nell'intervallo ``[0; get_tracked_object_type_count - 1]``. Se :ref:`get_tracked_object_type_count()<class_RenderingDevice_method_get_tracked_object_type_count>` è 0, l'argomento tipo viene ignorato e restituisce sempre la stessa stringa.
Il valore restituito è importante perché dà un significato ai tipi passati a :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>` e :ref:`get_device_allocs_by_object_type()<class_RenderingDevice_method_get_device_allocs_by_object_type>`. Esempi di stringhe che può restituire (non esaustivi):
- DEVICE_MEMORY
- PIPELINE_CACHE
- SWAPCHAIN_KHR
- COMMAND_POOL
Quindi se ad esempio ``get_tracked_object_name(5)`` restituisce "COMMAND_POOL", allora ``get_device_memory_by_object_type(5)`` restituisce i byte utilizzati dalla GPU per i pool di comandi.
Questo è utilizzato solo da Vulkan nelle build di debug. Godot deve anche essere avviato con l':doc:`argomento della riga di comando <../tutorials/editor/command_line_tutorial>` ``--extra-gpu-memory-tracking``.
.. 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>`
Restituisce quanti tipi di oggetti tracciabili ci sono.
Questo è usato solo da Vulkan nelle build di debug. Godot deve anche essere avviato con l':doc:`argomento della riga di comando <../tutorials/editor/command_line_tutorial>` ``--extra-gpu-memory-tracking``.
.. 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>`
Restituisce ``true`` se la funzionalità ``feature`` è supportata dalla 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>`
Crea un nuovo array di indici. È possibile accedervi con il RID restituito.
Una volta finito con il RID, si consiglia di liberarlo tramite il metodo :ref:`free_rid()<class_RenderingDevice_method_free_rid>` del RenderingServer.
.. 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>`
Crea un nuovo buffer di indici. È possibile accedervi con il RID restituito.
Una volta finito con il RID, si consiglia di liberarlo tramite il metodo :ref:`free_rid()<class_RenderingDevice_method_free_rid>` del RenderingDevice.
.. 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>`
Restituisce il valore del limite ``limit``. Questo limite varia a seconda dell'hardware grafico attuale (e avvolte della versione del driver). Se il limite specificato viene superato, si verificheranno errori di rendering.
È possibile ricavare i limiti per vari hardware grafici nel `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>`
Crea una nuova pipeline di rendering. È possibile accedervi con il RID restituito.
Una volta finito con il RID, si consiglia di liberarlo tramite il metodo :ref:`free_rid()<class_RenderingDevice_method_free_rid>` del RenderingServer.
.. 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>`
Restituisce ``true`` se la pipeline di rendering specificata dal :ref:`RID<class_RID>` ``render_pipeline`` è valida, altrimenti ``false``.
.. 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>`
Crea un nuovo campionatore. È possibile accedervi con il RID restituito.
Una volta finito con il RID, si consiglia di liberarlo tramite il metodo :ref:`free_rid()<class_RenderingDevice_method_free_rid>` del RenderingServer.
.. 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>`
Restituisce ``true`` se l'implementazione supporta l'utilizzo di una texture con il formato ``format`` con il filtro di campionamento ``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>`
Restituisce il formato del framebuffer dello schermo specificato.
\ **Nota:** Solo il **RenderingDevice** principale restituito dal :ref:`RenderingServer.get_rendering_device()<class_RenderingServer_method_get_rendering_device>` ha un formato. Se chiamato su un **RenderingDevice** locale, questo metodo stampa un errore e restituisce :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>`
Restituisce l'altezza (in pixel) della finestra corrispondente al contesto dell'API grafica per l'ID finestra specificato. Nonostante il parametro abbia il nome ``screen``, restituisce la dimensione della *finestra*. Vedi anche :ref:`screen_get_width()<class_RenderingDevice_method_screen_get_width>`.
\ **Nota:** Solo il **RenderingDevice** principale restituito da :ref:`RenderingServer.get_rendering_device()<class_RenderingServer_method_get_rendering_device>` ha un'altezza. Se chiamato su un **RenderingDevice** locale, questo metodo stampa un errore e restituisce :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>`
Restituisce la larghezza (in pixel) della finestra corrispondente al contesto dell'API grafica per l'ID finestra specificato. Nonostante il parametro abbia il nome ``screen``, restituisce la dimensione della *finestra*. Vedi anche :ref:`screen_get_height()<class_RenderingDevice_method_screen_get_height>`.
\ **Nota:** Solo il **RenderingDevice** principale restituito da :ref:`RenderingServer.get_rendering_device()<class_RenderingServer_method_get_rendering_device>` ha una larghezza. Se chiamato su un **RenderingDevice** locale, questo metodo stampa un errore e restituisce :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>`
Imposta il nome della risorsa per l'``id`` su ``name``. È utilizzato per il debug con strumenti di terze parti come `RenderDoc <https://renderdoc.org/>`__.
È possibile assegnare un nome ai seguenti tipi di risorse: texture, sampler, vertex buffer, index buffer, uniform buffer, texture buffer, storage buffer, uniform set buffer, shader, render pipeline e compute pipeline. I framebuffer non possono avere un nome. Tentare di nominare un tipo di risorsa incompatibile stamperà un errore.
\ **Nota:** I nomi delle risorse vengono impostati solo quando il motore è eseguito in modalità verbosa (:ref:`OS.is_stdout_verbose()<class_OS_method_is_stdout_verbose>` = ``true``) o quando si utilizza una build del motore compilata con l'opzione ``dev_mode=yes`` SCons. Il driver grafico deve anche supportare l'estensione Vulkan ``VK_EXT_DEBUG_UTILS_EXTENSION_NAME`` affinché le risorse con nome funzionino.
.. 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>`
Compila uno shader binario da ``spirv_data`` e restituisce i dati binari compilati come un :ref:`PackedByteArray<class_PackedByteArray>`. Questo shader compilato è specifico per il modello di GPU e per la versione del driver utilizzati; non funzionerà sui modelli di GPU diversi o persino sulle versioni di driver diverse. Vedi anche :ref:`shader_compile_spirv_from_source()<class_RenderingDevice_method_shader_compile_spirv_from_source>`.
\ ``name`` è un nome facoltativo leggibile in chiaro che può essere assegnato allo shader compilato per scopi organizzativi.
.. 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>`
Compila uno SPIR-V dal codice sorgente dello shader in ``shader_source`` e restituisce lo SPIR-V come :ref:`RDShaderSPIRV<class_RDShaderSPIRV>`. Questo shader di linguaggio intermedio è portabile su diversi modelli di GPU e versioni di driver, ma non può essere eseguito direttamente dalle GPU finché non viene compilato in uno shader binario attraverso :ref:`shader_compile_binary_from_spirv()<class_RenderingDevice_method_shader_compile_binary_from_spirv>`.
Se ``allow_cache`` è ``true``, utilizza la cache degli shader generata da Godot. Ciò evita un passaggio potenzialmente lungo per compilare lo shader, se lo shader è già nella cache. Se ``allow_cache`` è ``false``, la cache degli shader di Godot è ignorata e lo shader sarà sempre ricompilato.
.. 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>`
Crea una nuova istanza di shader da uno shader compilato in binario. È possibile accedervi con il RID restituito.
Una volta finito con il RID, si consiglia di liberarlo tramite il metodo :ref:`free_rid()<class_RenderingDevice_method_free_rid>` del RenderingServer. Vedi anche :ref:`shader_compile_binary_from_spirv()<class_RenderingDevice_method_shader_compile_binary_from_spirv>` e :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>`
Crea una nuova istanza di shader da codice SPIR-V intermedio. È possibile accedervi con il RID restituito.
Una volta finito con il RID, si consiglia di liberarlo tramite il metodo :ref:`free_rid()<class_RenderingDevice_method_free_rid>` del RenderingServer. Vedi anche :ref:`shader_compile_spirv_from_source()<class_RenderingDevice_method_shader_compile_spirv_from_source>` e :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>`
Crea un RID segnaposto allocando un RID senza inizializzarlo per l'uso in :ref:`shader_create_from_bytecode()<class_RenderingDevice_method_shader_create_from_bytecode>`. Ciò consente di creare un RID per uno shader e di passarlo in giro, ma rimandando la compilazione dello shader in un secondo momento.
.. 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>`
Restituisce la maschera interna di input del vertice. Internamente, la maschera di input del vertice è un intero senza segno composto dalle posizioni (specificate in GLSL tramite. ``layout(location = ...)``) delle variabili di input (specificate in GLSL dalla parola chiave ``in``).
.. 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>`
Crea un `buffer di memorizzazione <https://vkguide.dev/docs/chapter-4/storage_buffers/>`__ con ``data`` e ``usage`` specificati. È possibile accedervi con il RID restituito.
Una volta finito con il RID, si consiglia di liberarlo tramite il metodo :ref:`free_rid()<class_RenderingDevice_method_free_rid>` del RenderingServer.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_submit:
.. rst-class:: classref-method
|void| **submit**\ (\ ) :ref:`🔗<class_RenderingDevice_method_submit>`
Inserisce i buffer di configurazione e di comando di disegno del frame, quindi contrassegna il dispositivo locale come in fase di elaborazione (il che consente di chiamare :ref:`sync()<class_RenderingDevice_method_sync>`).
\ **Nota:** Disponibile solo nei RenderingDevice locali.
.. rst-class:: classref-item-separator
----
.. _class_RenderingDevice_method_sync:
.. rst-class:: classref-method
|void| **sync**\ (\ ) :ref:`🔗<class_RenderingDevice_method_sync>`
Forza una sincronizzazione tra CPU e GPU, la quale potrebbe essere necessaria in alcuni casi. Chiamalo solo quando necessario, poiché la sincronizzazione tra CPU e GPU ha un costo in termini di prestazioni.
\ **Nota:** Disponibile solo nei RenderingDevice locali.
\ **Nota:** :ref:`sync()<class_RenderingDevice_method_sync>` può essere chiamato solo dopo un :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>`
Crea un nuovo buffer di texture. È possibile accedervi con il RID restituito.
Una volta finito con il RID, si consiglia di liberarlo tramite il metodo :ref:`free_rid()<class_RenderingDevice_method_free_rid>` del RenderingServer.
.. 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>`
Cancella la ``texture`` specificata sostituendo tutti i suoi pixel con il colore ``color``. ``base_mipmap`` e ``mipmap_count`` determinano quali mipmap della texture sono influenzate da questa operazione di cancellazione, mentre ``base_layer`` e ``layer_count`` determinano quali livelli di una texture 3D (o array di texture) sono influenzati da questa operazione di cancellazione. Per le texture 2D (che hanno un solo livello come predefinito), ``base_layer`` deve essere ``0`` e ``layer_count`` deve essere ``1``.
\ **Nota:** ``texture`` non può essere cancellato mentre viene creato una lista di disegno che la usa come parte di un framebuffer. Assicurati che la lista di disegno sia finalizzata (e che la texture di colore/profondità che la usa non sia impostata su :ref:`FINAL_ACTION_CONTINUE<class_RenderingDevice_constant_FINAL_ACTION_CONTINUE>`) per cancellare questa 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>`
Copia la texture ``from_texture`` in ``to_texture`` con le coordinate specificate da ``from_pos``, ``to_pos`` e ``size``. L'asse Z di ``from_pos``, ``to_pos`` e ``size`` deve essere ``0`` per le texture bidimensionali. Devono essere specificati anche le mipmap/livelli di origine e destinazione, con questi parametri pari a ``0`` per le texture senza mipmap o con un solo livello. Restituisce :ref:`@GlobalScope.OK<class_@GlobalScope_constant_OK>` se la copia della texture è riuscita o :ref:`@GlobalScope.ERR_INVALID_PARAMETER<class_@GlobalScope_constant_ERR_INVALID_PARAMETER>` in caso contrario.
\ **Nota:** La texture ``from_texture`` non può essere copiata mentre viene creata una lista di disegno che la usa come parte di un framebuffer. Assicurati che la lista di disegno sia finalizzata (e che la texture di colore/profondità che lo usa non sia impostata su :ref:`FINAL_ACTION_CONTINUE<class_RenderingDevice_constant_FINAL_ACTION_CONTINUE>`) per copiare questa texture.
\ **Nota:** La texture ``from_texture`` richiede che :ref:`TEXTURE_USAGE_CAN_COPY_FROM_BIT<class_RenderingDevice_constant_TEXTURE_USAGE_CAN_COPY_FROM_BIT>` sia recuperata.
\ **Nota:** Non è possibile copiare ``to_texture`` mentre viene creato una lista di disegno che la utilizza come parte di un framebuffer. Assicurati che la lista di disegno sia finalizzata (e che la texture di colore/profondità che la usa non sia impostata su :ref:`FINAL_ACTION_CONTINUE<class_RenderingDevice_constant_FINAL_ACTION_CONTINUE>`) per copiare questa texture.
\ **Nota:** ``to_texture`` richiede che :ref:`TEXTURE_USAGE_CAN_COPY_TO_BIT<class_RenderingDevice_constant_TEXTURE_USAGE_CAN_COPY_TO_BIT>` sia recuperata.
\ **Nota:** ``from_texture`` e ``to_texture`` devono essere dello stesso tipo (colore o profondità).
.. 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>`
Crea una nuova texture. È possibile accedervi con il RID restituito.
Una volta finito con il RID, si consiglia di liberarlo tramite il metodo :ref:`free_rid()<class_RenderingDevice_method_free_rid>` del RenderingServer.
\ **Nota:** ``data`` accetta un :ref:`Array<class_Array>` di :ref:`PackedByteArray<class_PackedByteArray>`. Per i tipi :ref:`TEXTURE_TYPE_1D<class_RenderingDevice_constant_TEXTURE_TYPE_1D>`, :ref:`TEXTURE_TYPE_2D<class_RenderingDevice_constant_TEXTURE_TYPE_2D>` e :ref:`TEXTURE_TYPE_3D<class_RenderingDevice_constant_TEXTURE_TYPE_3D>`, questo array dovrebbe avere un solo elemento, un :ref:`PackedByteArray<class_PackedByteArray>` contenente tutti i dati per la texture. Per i tipi ``_ARRAY`` e ``_CUBE``, la lunghezza dovrebbe essere uguale al numero di :ref:`RDTextureFormat.array_layers<class_RDTextureFormat_property_array_layers>` in ``format``.
\ **Nota:** Da non confondere con :ref:`RenderingServer.texture_2d_create()<class_RenderingServer_method_texture_2d_create>`, che crea la risorsa :ref:`Texture2D<class_Texture2D>` specifica di Godot a differenza del tipo texture dell'API grafica.
.. 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>`
Restituisce un RID per un'immagine ``image`` esistente (``VkImage``) con il tipo ``type``, il formato ``format``, i campioni ``samples``, i flag d'utilizzo ``usage_flags``, la larghezza ``width``, l'altezza ``height``, la profondità ``depth``, i livelli ``layers`` e le mipmap ``mipmaps`` specificati. Si può utilizzare per consentire a Godot di renderizzare su immagini esterne.
.. 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>`
Crea una texture condivisa utilizzando la vista ``view`` e le informazioni sulla texture da ``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>`
Crea una texture condivisa utilizzando la vista ``view`` e le informazioni sulla texture da ``with_texture`` con il livello ``layer`` e la mipmap ``mipmap``. È possibile controllare il numero di mipmap incluse dalla texture originale tramite il parametro ``mipmaps``. Rilevante solo per texture con più livelli, come texture 3D, array di texture e cubemap. Per texture con un singolo livello, usa :ref:`texture_create_shared()<class_RenderingDevice_method_texture_create_shared>`.
Per texture 2D (che hanno un solo livello), ``layer`` deve essere ``0``.
\ **Nota:** Il layer slicing è supportato solo per array di texture 2D, non per texture 3D o cubemap.
.. 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>`
Restituisce i dati della ``texture`` per il livello ``layer`` come dati binari grezzi. Per le texture 2D (che hanno un solo livello), ``layer`` deve essere ``0``.
\ **Nota:** Non è possibile recuperare la ``texture`` mentre viene creata una lista di disegno che la utilizza come parte di un framebuffer. Assicurati che la lista di disegno sia finalizzata (e che la texture colore/profondità che la usa non sia impostata su :ref:`FINAL_ACTION_CONTINUE<class_RenderingDevice_constant_FINAL_ACTION_CONTINUE>`) per recuperare questa texture. Altrimenti, viene stampato un errore e viene restituito un :ref:`PackedByteArray<class_PackedByteArray>` vuoto.
\ **Nota:** ``texture`` richiede che sia recuperato :ref:`TEXTURE_USAGE_CAN_COPY_FROM_BIT<class_RenderingDevice_constant_TEXTURE_USAGE_CAN_COPY_FROM_BIT>`. Altrimenti, viene stampato un errore e viene restituito un :ref:`PackedByteArray<class_PackedByteArray>` vuoto.
\ **Nota:** Questo metodo impedirà alla GPU di funzionare finché i dati non vengono recuperati. Fare riferimento a :ref:`texture_get_data_async()<class_RenderingDevice_method_texture_get_data_async>` per un'alternativa che restituisce i dati in modo più performante.
.. 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>`
Versione asincrona di :ref:`texture_get_data()<class_RenderingDevice_method_texture_get_data>`. RenderingDevice chiamerà il ``callback`` in una certa quantità di frame con i dati che la texture aveva al momento della richiesta.
\ **Nota:** Al momento, il ritardo corrisponde alla quantità di frame specificata da :ref:`ProjectSettings.rendering/rendering_device/vsync/frame_queue_size<class_ProjectSettings_property_rendering/rendering_device/vsync/frame_queue_size>`.
\ **Nota:** Scaricare texture di grandi dimensioni può avere un costo proibitivo per il tempo reale, anche quando si utilizza il metodo asincrono, a causa di limitazioni della larghezza di banda nell'hardware. Quando si gestiscono grandi risorse, è possibile regolare impostazioni come :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>` e :ref:`ProjectSettings.rendering/rendering_device/staging_buffer/block_size_kb<class_ProjectSettings_property_rendering/rendering_device/staging_buffer/block_size_kb>` per migliorare la velocità di trasferimento a costo di memoria aggiuntiva.
::
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>`
Restituisce il formato di dati utilizzato per creare questa texture.
.. 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>`
**Deprecato:** Use :ref:`get_driver_resource()<class_RenderingDevice_method_get_driver_resource>` with :ref:`DRIVER_RESOURCE_TEXTURE<class_RenderingDevice_constant_DRIVER_RESOURCE_TEXTURE>` instead.
Restituisce il gestore grafico interno per questo oggetto texture. Da utilizzare quando si comunica con le API di terze parti, principalmente con GDExtension.
\ **Nota:** Questa funzione restituisce un ``uint64_t`` che mappa internamente un ``GLuint`` (OpenGL) o ``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>`
Restituisce ``true`` se la texture ``texture`` è scartabile, altrimenti ``false``. Vedi :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>`
Restituisce ``true`` se il formato specificato ``format`` è supportato per i\ ``usage_flags`` forniti, altrimenti ``false``.
.. 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>`
Restituisce ``true`` se la texture ``texture`` è condivisa, altrimenti ``false``. Vedi :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>`
Restituisce ``true`` se la texture ``texture`` è valida, altrimenti ``false``.
.. 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>`
Risolve la texture ``from_texture`` su ``to_texture`` con antialiasing multicampione abilitato. Deve essere utilizzato durante il rendering di un framebuffer affinché MSAA funzioni. Restituisce :ref:`@GlobalScope.OK<class_@GlobalScope_constant_OK>` in caso di successo, altrimenti :ref:`@GlobalScope.ERR_INVALID_PARAMETER<class_@GlobalScope_constant_ERR_INVALID_PARAMETER>`.
\ **Nota:** Le texture ``from_texture`` e ``to_texture`` devono avere le stesse dimensioni, formato e tipo (colore o profondità).
\ **Nota:** ``from_texture`` non può essere copiato mentre viene creato una lista di disegno che lo utilizza come parte di un framebuffer. Assicurati che la lista di disegno sia finalizzata (e che la texture di colore/profondità che la utilizza non sia impostata su :ref:`FINAL_ACTION_CONTINUE<class_RenderingDevice_constant_FINAL_ACTION_CONTINUE>`) per risolvere questa texture.
\ **Nota:** ``from_texture`` richiede che :ref:`TEXTURE_USAGE_CAN_COPY_FROM_BIT<class_RenderingDevice_constant_TEXTURE_USAGE_CAN_COPY_FROM_BIT>` sia recuperato.
\ **Nota:** ``from_texture`` deve essere multicampionato e deve anche essere 2D (o una porzione di una texture 3D/cubemap).
\ **Nota:** ``to_texture`` non può essere copiato mentre viene creato una lista di disegno che lo usa come parte di un framebuffer. Assicurati che la lista di disegno sia finalizzata (e che la texture di colore/profondità che la usa non sia impostata su :ref:`FINAL_ACTION_CONTINUE<class_RenderingDevice_constant_FINAL_ACTION_CONTINUE>`) per risolvere questa texture.
\ **Nota:** La texture ``to_texture`` richiede che :ref:`TEXTURE_USAGE_CAN_COPY_TO_BIT<class_RenderingDevice_constant_TEXTURE_USAGE_CAN_COPY_TO_BIT>` sia recuperato.
\ **Nota:** La texture ``to_texture`` **non** deve essere multicampionata e deve anche essere 2D (o una porzione di una texture 3D/cubemap).
.. 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>`
Aggiorna la proprietà scartabile della ``texture``.
Se una texture è scartabile, il suo contenuto non deve essere conservato tra i frame. Questo flag è rilevante solo quando la texture è usata come destinazione in una lista di disegno.
Questa informazione è usata dal **RenderingDevice** per capire se il contenuto di una texture può essere scartato, eliminando le scritture non necessarie nella memoria e aumentando le prestazioni.
.. 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>`
Aggiorna i dati della texture con nuovi dati, sostituendo i dati precedenti al loro posto. I dati aggiornati della texture devono avere le stesse dimensioni e lo stesso formato. Per le texture 2D (che hanno solo un livello), ``layer`` deve essere ``0``. Restituisce :ref:`@GlobalScope.OK<class_@GlobalScope_constant_OK>` se l'aggiornamento è riuscito, altrimenti :ref:`@GlobalScope.ERR_INVALID_PARAMETER<class_@GlobalScope_constant_ERR_INVALID_PARAMETER>`.
\ **Nota:** L'aggiornamento delle texture non è consentito durante la creazione di una lista di disegno o di calcolo.
\ **Nota:** La ``texture`` esistente non può essere aggiornata mentre viene creata una lista di disegno che la utilizza come parte di un framebuffer. Assicurati che la lista di disegno sia finalizzata (e che la texture di colore/profondità che la usa non sia impostata su :ref:`FINAL_ACTION_CONTINUE<class_RenderingDevice_constant_FINAL_ACTION_CONTINUE>`) per aggiornare questa texture.
\ **Nota:** La ``texture`` attuale richiede che :ref:`TEXTURE_USAGE_CAN_UPDATE_BIT<class_RenderingDevice_constant_TEXTURE_USAGE_CAN_UPDATE_BIT>` sia aggiornabile.
.. 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>`
Crea un nuovo buffer di uniformi. È possibile accedervi con il RID restituito.
Una volta finito con il RID, si consiglia di liberarlo tramite il metodo :ref:`free_rid()<class_RenderingDevice_method_free_rid>` del RenderingDevice.
.. 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>`
Crea un nuovo set di uniformi. È possibile accedervi con il RID restituito.
Una volta finito con il RID, si consiglia di liberarlo tramite il metodo :ref:`free_rid()<class_RenderingDevice_method_free_rid>` del RenderingServer.
.. 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>`
Verifica se ``uniform_set`` è valido, ovvero se qualcosa lo possiede.
.. 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 di vertici basato sui buffer specificati. Facoltativamente, ``offsets`` (in byte) può essere definito per ogni buffer.
.. 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 nuovo buffer di vertici. È possibile accedervi con il RID restituito.
Una volta finito con il RID, si consiglia di liberarlo tramite il metodo :ref:`free_rid()<class_RenderingDevice_method_free_rid>` del RenderingServer.
.. 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 nuovo formato di vertici con le descrizioni di vertici ``vertex_descriptions``. Restituisce un ID univoco del formato di vertici corrispondente al formato appena creato.
.. |virtual| replace:: :abbr:`virtual (Questo metodo dovrebbe solitamente essere sovrascritto dall'utente per aver un effetto.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Questo metodo non ha effetti collaterali. Non modifica alcuna variabile appartenente all'istanza.)`
.. |vararg| replace:: :abbr:`vararg (Questo metodo accetta qualsiasi numero di argomenti oltre a quelli descritti qui.)`
.. |constructor| replace:: :abbr:`constructor (Questo metodo è utilizzato per creare un tipo.)`
.. |static| replace:: :abbr:`static (Questo metodo non necessita di alcun'istanza per essere chiamato, quindi può essere chiamato direttamente usando il nome della classe.)`
.. |operator| replace:: :abbr:`operator (Questo metodo descrive un operatore valido da usare con questo tipo come operando di sinistra.)`
.. |bitfield| replace:: :abbr:`BitField (Questo valore è un intero composto da una maschera di bit dei seguenti flag.)`
.. |void| replace:: :abbr:`void (Nessun valore restituito.)`
Reference in New Issue View Git Blame Copy Permalink